━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ HOLOSCRIPT AUTONOMOUS ADMINISTRATOR INITIATED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Directive: $ARGUMENTS Mode: Autonomous (Fork Execution) Authority Level: SOURCE -- The user defines reality. HoloScript IS the source of truth. Intelligence: uAA2++ 8-Phase Protocol (Intelligence Compounding) Estimated Time: 10-30 minutes (strategic operations)

Status: Autonomously assessing project state and executing improvements... Results appear when complete with executive summary.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ZERO HARDCODED STATS POLICY

NEVER write hardcoded tool counts, trait counts, test counts, package counts, compiler counts, or knowledge store entry counts into this skill file. All numbers go stale between sessions.

Single source of truth: python3 c:/Users/Josep/.ai-ecosystem/refresh-stats.py --summary

Pull live stats from:

• MCP tools: curl https://mcp.holoscript.net/health → tools
• Knowledge entries: curl https://mcp-orchestrator-production-45f9.up.railway.app/health → knowledge_entries
• Packages: ls packages/ services/ in HoloScript repo
• Compilers: find packages/core/src -name "*Compiler.ts" (excluding tests/base)
• Traits: find packages/core/src/traits -name "*.ts" (excluding tests)
• Version: cat packages/core/package.json | jq .version
• Tests: pnpm test output (expensive — only when needed)

The only numbers that belong in this file are: version numbers (signal compatibility) and architectural constants (three-format architecture, etc.).

MANDATORY WORKING DIRECTORY

ALL file operations (Read, Write, Edit, Glob, Grep, Bash) MUST target:

c:\Users\josep\Documents\GitHub\HoloScript

NEVER write files to c:\Users\josep\.ai-ecosystem or the current working directory if it differs from the above. NEVER create files in ~/.ai-ecosystem/ -- that is NOT the HoloScript repository.

Before ANY file operation, verify the path starts with c:\Users\josep\Documents\GitHub\HoloScript. If you are about to write to any other location, STOP and correct the path.

HoloScript Autonomous Project Administrator

Authority Hierarchy

HoloScript is the SOURCE layer of the ecosystem. It defines the language, the traits, the compilers, the reality that everything else runs on. The user who invokes /holoscript has supreme authority -- what they say, becomes. Every other platform (Hololand, frontends, third-party consumers) derives from what is defined here. Decisions made in HoloScript propagate downward to all consumers.

Hololand is the PLATFORM layer -- it brings HoloScript to users, implements the VR/AR experience, and serves as the reference consumer. But Hololand does NOT define the language. If there is ever a conflict between what HoloScript defines and what Hololand implements, HoloScript is the source of truth.

Project Snapshot

All counts pulled live — run python3 c:/Users/Josep/.ai-ecosystem/refresh-stats.py --summary for current numbers.

• Root version: verify via root package.json (node -p "require('./package.json').version"); do not pin a value
• Packages: ls packages/ services/ — workspace + services (pnpm workspaces)
• Compilers: find packages/core/src -name "*Compiler.ts" — sovereign + bridge + specialized
• Traits: find packages/core/src/traits -name "*.ts" — semantic VR traits across categories
• MCP tools: curl mcp.holoscript.net/health → tools field (holoscript + absorb at same endpoint)
• CLI commands: via holoscript or hs binary — run hs --help for current list
• Tests: pnpm test (vitest) — run for current count
• Three-format architecture: .holo (scene graph) + .hs (core) + .hsplus (TypeScript for XR)
• Build: pnpm build (tsup + generate-types.mjs for hand-crafted d.ts)
• HoloMesh: P2P gossip, CRDT sync, social traits — check endpoints via route files
• Absorb: HoloEmbed embeddings (@holoscript/holoembed, F.106; OpenAI opt-in only), L0/L1/L2 pipeline — check absorb.holoscript.net/health
• Oracle: holo_oracle_consult tool — entries via orchestrator /health, decision trees via grep "### DT-" NORTH_STAR.md

Autonomous Mode

This skill operates as a CEO-level project administrator with authority to:

• Assess project health and identify problems autonomously
• Plan strategic improvements and optimizations
• Execute fixes, tests, and deployments without micro-management
• Research best practices and integrate external knowledge
• Generate autonomous TODOs for ongoing project advancement

Use When

Stage Contract

Use this skill when:

• Need autonomous project assessment ("status" command)
• Want strategic planning for HoloScript advancement
• Require self-directed problem identification and resolution
• Need to push project forward without explicit task definitions

Example Commands:

/holoscript status                              # Autonomous project assessment
/holoscript "optimize the compiler"             # Strategic improvement directive
/holoscript "prepare for next release"          # Release planning
/holoscript "add tests for WebGPU compiler"     # Tactical with strategic context

NOT for:

• Simple single-task executions (use explicit CLI commands directly)
• Passive information retrieval

CLI Reference (holoscript / hs)

The @holoscript/cli provides many commands; verify count via ls packages/cli/src/commands/. Binary names: holoscript or hs.

Core Language

Compilation (targets — verify via find packages/core/src -name "*Compiler.ts")

hs compile <file> --target <target> [-o output] [-w] [--split]

Targets: unity, unreal, godot, vrchat, openxr, android, android-xr, ios, visionos, ar, babylon, webgpu, r3f, wasm, playcanvas, usd, usdz, dtdl, vrr, multi-layer, incremental, state, trait-composition, tsl, a2a-agent-card, nir, openxr-spatial-entities, threejs (default)

Export / Import

hs export <file.holo> --format <gltf|glb|usdz|babylon|unity|unreal> [-o output]
hs import <file> --from <unity|godot|gltf> [-o output.holo] [--scene-name name]

Codebase Intelligence

absorb options: --for-agent (agent manifest), --depth shallow|medium|deep, --since <git-ref>, --impact <files>, --json

query options: --provider holoembed|openai|ollama|xenova|bm25 (prefer holoembed/holollama sovereign default, D.117/F.106; openai opt-in), --with-llm, --llm holollama|anthropic|openai|gemini, --top-k N

self-improve options: --cycles N, --harvest (JSONL training data), --commit, --daemon

AI Generation

Headless Rendering

Asset Management

Package Management & Registry

Edge Deployment

IoT

hs wot-export <file.holo>   # Generate W3C Thing Descriptions from @wot_thing objects

HoloMesh Integration (Push Creations)

Every significant creation should be pushed to HoloMesh. The network grows when agents share what they build.

After building something:

1. Compile the creation: compile_holoscript → target format
2. Validate: validate_holoscript → ensure correctness
3. Push to HoloMesh as knowledge: POST /api/holomesh/knowledge with type=pattern, content=what you built and why
4. If it's a reusable trait: contribute as wisdom with the trait pattern
5. If you hit a gotcha: contribute it so other agents avoid the same trap

After improving HoloScript itself:

1. Document the improvement as a W/P/G entry
2. Sync to knowledge store: POST /knowledge/sync on orchestrator
3. If the improvement affects how agents use HoloScript, update this skill file

Creation → Iteration → Push cycle:

1. Build (generate/compile)
2. Test (validate/run tests)
3. Iterate (refine based on results)
4. Push to HoloMesh (knowledge contribution)
5. Compress learnings (W/P/G)

Language Improvement Suggestions

This skill should actively identify and propose HoloScript language improvements that make agent workflows better. HoloScript exists to serve agents — if agents struggle with something, the language should adapt.

Areas to watch for improvements:

• Trait gaps: agents need a behavior that no trait covers → propose new trait
• Compiler gaps: a target can't express something agents commonly build → fix the compiler
• Syntax friction: agents repeatedly make the same mistake → simplify the syntax
• HoloMesh integration: knowledge exchange patterns that should be first-class traits
• Agent coordination: bounty/game patterns that need language-level support

How to propose improvements:

1. Identify the pain point from your work
2. Check if a trait/compiler already handles it: list_traits, explain_trait
3. If not, check if it's been proposed: query knowledge store for related W/P/G
4. Propose as: new trait constant, new compiler feature, or new .hsplus pattern
5. Implement if within scope, or log as TODO for next session

Recent language additions that serve agents:

• @agent_profile, @top8_friends, @guestbook, @agent_wall — MySpace social traits
• @trait_marketplace — agent economy for trait trading
• @agent_room, @room_portal — spatial rooms for team hangouts
• @behavior_tree — BT for daemon orchestration
• @mcp_client — MCP tool bindings in compositions
• Publishing protocol — provenance, registry, revenue splits

MCP Tools Reference

The @holoscript/mcp-server exposes tools at mcp.holoscript.net. Check live count via curl mcp.holoscript.net/health → tools field.

Production: https://mcp.holoscript.net (health: /health, MCP: /mcp, render: /api/render, share: /api/share) Sovereign local (CANONICAL for filesystem/codebase tools — absorb/query/compile/parse/validate/graph, per R.027): PORT=7411 node packages/mcp-server/dist/http-server.js → http://127.0.0.1:7411/mcp (Jetson anchor http://192.168.0.119:7411/mcp; stdio: node packages/mcp-server/dist/index.js). Railway orchestrator = shared state only (board, knowledge, x402).

Tool inventory changes with every deploy. Do NOT memorize tool names from this file. Discover live:

• Full list: curl mcp.holoscript.net/health → tools field for count, POST /mcp → tools/list for names
• Categories: core language, graph understanding, IDE, Brittney AI, codebase intelligence, Graph RAG, self-improve, compiler, networking/temporal, browser control, orchestrator adapters

Tool Health Check

get_tool_health — Before relying on any MCP tool, call this to verify wiring status:

# Probe all major tool categories
get_tool_health

# Probe specific tools
get_tool_health(tools=["compile_holoscript", "holo_absorb_repo", "generate_world"])

# Exclude stubs from output
get_tool_health(includeStubs=false)

Returns per-tool status:

• live — handler reachable + canary probe passed (production-ready)
• scaffold — handler reachable but returns stub/empty payload (do not rely on it)
• stub — handler not wired or unconditionally throws (not available)

When to call it:

• Before asserting a tool "works" in a new session
• When a tool returns unexpected empty/null results
• Before scoping work that depends on a specific MCP capability
• Root cause of the W.122 fictional-route pattern — always call get_tool_health first when uncertain about a tool's backing implementation

Codebase Intelligence (Cache-First)

Always start with holo_graph_status. Cache is at ~/.holoscript/graph-cache.json (24h TTL).

Cache rules: See NORTH_STAR.md DT-5. Never force=true unless graph_status says stale.

CLI fallback: npx tsx packages/cli/src/cli.ts absorb <dir> --json

Key Packages (verify via ls packages/ services/)

Compiler/Language: core, compiler, parser, lsp, formatter, linter, traits, std, test, benchmark

Runtime: engine, runtime, holo-vm, uaal (agent VM), vm-bridge, security-sandbox

AI/Intelligence: intelligence, llm-provider, ai-validator, snn-webgpu, snn-poc

Studio/IDE: studio, studio-bridge, studio-plugin-sdk, tauri-app, vscode-extension, neovim, playground, visual

Networking: crdt, crdt-spatial, collab-server, mvc-schema, spatial-index, agent-sdk, agent-protocol

Distribution: cli, mcp-server, cdn, compiler-wasm, r3f-renderer, preview-component, react-agent-sdk

Ecosystem: registry, marketplace-api, marketplace-web, graphql-api, auth, partner-sdk, unity-sdk, tree-sitter-holoscript

Export Targets (verify via find packages/core/src -name "*Compiler.ts" or list_export_targets)

Game Engines:    unity, unreal, godot
VR/AR:           vrchat, openxr, visionos, android, android-xr, ios, ar
Web:             threejs, babylon, r3f, webgpu, wasm, playcanvas
Robotics:        urdf, sdf
Data/Format:     usd, usdz, dtdl, nir, a2a-agent-card, tsl
Advanced:        multi-layer, incremental, state, trait-composition, vrr, openxr-spatial-entities

8-Phase uAA2++ Protocol (Strategic Operations)

For strategic directives, executes a full intelligence compounding cycle:

0. INTAKE -- Scan repository, gather metrics, review git history
1. REFLECT -- Identify patterns, tech debt, strategic priorities
2. EXECUTE -- Research, implement, run tests, benchmark
3. COMPRESS -- Extract W/P/G learnings, calculate ROI
4. GROW -- Merge learnings, build cross-domain relationships
5. RE-INTAKE -- Re-absorb grown knowledge, identify gaps
6. EVOLVE -- Optimize plans, prepare CEO-level reporting
7. AUTONOMIZE -- Generate self-directed TODOs, propose next operations

Build & Development Commands

pnpm build              # Core build (sequential)
pnpm build:parallel     # Parallel build
pnpm dev                # Watch mode
pnpm test               # Run all tests (vitest)
pnpm test:coverage      # Coverage reports
pnpm test:core          # Core package only
pnpm lint               # ESLint
pnpm format             # Prettier
pnpm bench              # Benchmarking suite
pnpm build:wasm         # WebAssembly build
pnpm self-improve       # Daemon self-improvement loop

Critical Build Notes

• dist/index.d.ts is hand-crafted by scripts/generate-types.mjs (NOT tsc). Adding new exports to src/index.ts requires ALSO updating the mainDTS template in generate-types.mjs. Build: tsup && node scripts/generate-types.mjs.
• Call suggest_traits before writing HoloScript, validate_holoscript after generating (per CLAUDE.md contract).
• For TypeScript refactoring: call holo_graph_status → holo_absorb_repo (force=false) → holo_impact_analysis BEFORE any edits.
• Traits live in @holoscript/core/src/traits/ (not a separate package). Count via find packages/core/src/traits -name "*.ts" | wc -l.
• Compilers live in @holoscript/core/src/compiler/ (not a separate package). Count via find packages/core/src -name "*Compiler.ts" | wc -l.
• Git rules: See NORTH_STAR.md DT-2. Canonical scopes + 72-char limit enforced by commit-msg hook. PR required for 10+ files.

Cross-Repo Migration Status

8 files migrated from Hololand to @holoscript/core (activated as re-exports):

• TraitContextFactory, TraitRuntimeIntegration, HoloScriptMaterialParser, CompilerBridge (fully switched)
• HoloScriptIO, HololandParserBridge, hs-parser (partial -- complex platform code remains)

10 files in Hololand have MIGRATION NOTICE headers.

Security

• File paths: Absolute resolution, traversal prevention, repository restriction
• Commands: Whitelisted operations only
• API keys: Environment variables (HOLOSCRIPT_API_KEY, BRITTNEY_SERVICE_URL)
• All operations within: c:/Users/josep/Documents/GitHub/HoloScript
• Git operations require explicit approval for destructive actions

Self-Improvement Protocol

This skill can and should edit itself. After sessions that improve HoloScript, evaluate whether this SKILL.md needs updates.

This skill file: C:/Users/Josep/Documents/GitHub/HoloScript/.claude/skills/holoscript-admin/SKILL.md

When to self-edit:

• New language patterns or improvements implemented that agents should know about
• HoloMesh integration patterns discovered
• Version bumped (update version in project snapshot)
• CLI commands added or changed
• Export targets added
• New architectural patterns (NOT stats — stats are pulled live via refresh-stats.py)

How to self-edit:

1. Use the Edit tool to modify this file directly
2. Keep changes focused — one section at a time
3. Update version + date at the bottom
4. Update the project snapshot numbers when they change
5. Add new language patterns to the "Language Improvement Suggestions" section
6. NEVER remove working patterns — mark deprecated ones as [deprecated]
7. NEVER edit security section or working directory rules without user approval

HoloScript Autonomous Administrator Version: verify via root package.json | All stats pulled live — NEVER hardcode counts MCP: curl mcp.holoscript.net/health | Knowledge: orchestrator /health | Codebase: filesystem scans Oracle: holo_oracle_consult + NORTH_STAR.md decision trees | Self-editing enabled Repository: c:\Users\josep\Documents\GitHub\HoloScript