@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-ZUL5AVTX.cjs

@@ -0,0 +1,1993 @@
+'use strict';
+
+var chunkRMHC2VG7_cjs = require('./chunk-RMHC2VG7.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/ContextCompiler.ts
+chunkRMHC2VG7_cjs.init_CompilerBase();
+var BANNED_DEFAULT_PATTERNS = [
+  { pattern: /\bgit\s+add\s+(?:-A|--all|\.)(?=\s|$)/i, rule: "F.001/F.011 - git add -A leaked .env twice" },
+  { pattern: /:\s*any\b|\bas\s+any\b|<any>/i, rule: "global CLAUDE.md - no `any` in TypeScript, use `unknown`" },
+  { pattern: /\bregex\b.+\.(?:hs|hsplus|holo)\b/i, rule: "F.014 - no regex on .hs/.hsplus/.holo, use @holoscript/core" },
+  { pattern: /\bmock\s+(?:the\s+)?(?:db|database)\b/i, rule: "founder-default - real DB in tests, mock-vs-prod divergence" }
+];
+var VENDOR_AS_SUBSTRATE_PATTERNS = [
+  { pattern: /managed_agents_replaces_holomesh/i, rule: "W.GOLD.002 - vendor framework cannot replace HoloMesh" },
+  { pattern: /vector_store_as_source_of_truth/i, rule: "docs/LLM_CAPABILITIES.md hard-don'ts - vendor stores never source-of-truth" },
+  { pattern: /api_keys_as_identity/i, rule: "W.GOLD.004 - wallets are identity, API keys are sessions" }
+];
+var KNOWN_DIAMOND_IDS = /* @__PURE__ */ new Set([
+  "W.GOLD.001",
+  // Architecture beats alignment
+  "P.GOLD.001",
+  // Failure knowledge decays slower than success knowledge
+  "W.GOLD.188",
+  // Algebraic Trust (paired with W.GOLD.189)
+  "W.GOLD.189"
+  // Algebraic Trust tri-layer (algebra + history + oracle)
+  // Add more as graduate.py promotes - verify against D:/GOLD/INDEX.md.
+]);
+var DEFAULT_FLUENT_PROSE_CHARS = 150;
+var ContextCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "ContextCompiler";
+    this.options = {
+      formats: options.formats ?? ["claude_md"]
+    };
+  }
+  getRequiredCapability() {
+    return ans.ANSCapabilityPath.AGENT_INFERENCE;
+  }
+  /**
+   * Compile a HoloScript context composition to agent-surface formats.
+   *
+   * Phases:
+   *   1. extract - walk the HoloComposition AST, collect all v1 traits
+   *      into the typed ContextAST shape
+   *   2. validate - apply BLOCK rules (Diamond-invariant violations) +
+   *      WARN rules (soft guidelines). BLOCK rules throw; WARN rules
+   *      accumulate in diagnostics.
+   *   3. emit - dispatch to per-format emitters. Phase 1 ships claude_md
+   *      and agents_md. cursor_rules + skill_md + anthropic_system_prompt
+   *      + brain_includes + mcp_context_loader are filed follow-ups.
+   */
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const ast = this.extractContextAST(composition);
+    this.validate(ast);
+    const files = {};
+    for (const format of this.options.formats) {
+      switch (format) {
+        case "claude_md":
+          files["CLAUDE.md"] = this.emitClaudeMd(ast);
+          break;
+        case "agents_md":
+          files["AGENTS.md"] = this.emitAgentsMd(ast);
+          break;
+        case "cursor_rules": {
+          const cursorFiles = this.emitCursorRules(ast);
+          for (const [path, content] of Object.entries(cursorFiles)) {
+            files[path] = content;
+          }
+          break;
+        }
+        case "skill_md":
+          files["SKILL.md"] = this.emitSkillMd(ast);
+          break;
+        case "anthropic_system_prompt":
+        case "brain_includes":
+        case "mcp_context_loader":
+          throw new Error(
+            `Format "${format}" is a Phase 1+ follow-up; not yet emitted. See ai-ecosystem research/2026-05-06_context-as-compile-target.md section Recommended sequence for the rollout order.`
+          );
+        default: {
+          const exhaustive = format;
+          throw new Error(`Unknown emit format: ${String(exhaustive)}`);
+        }
+      }
+    }
+    return { files, ast, diagnostics: ast.warnings };
+  }
+  // --- Phase 1: extract -----------------------------------------------
+  extractContextAST(composition) {
+    const ast = {
+      visionPillars: [],
+      refusals: [],
+      hardDonts: [],
+      defaults: [],
+      graduatedWisdoms: [],
+      feedbacks: [],
+      escalations: [],
+      verifyTokens: [],
+      gapRules: [],
+      citationRules: [],
+      skills: [],
+      includes: [],
+      routines: [],
+      hardPhysicalGaps: [],
+      invocationModes: [],
+      dateDisciplines: [],
+      domainPreferences: [],
+      embodiedProjections: [],
+      editorialDefaults: [],
+      researchDefaults: [],
+      trackBAuthorities: [],
+      narrativeOpenings: [],
+      triggerPhrases: [],
+      proseAfters: [],
+      domainDispatches: [],
+      corpusMutabilities: [],
+      warnings: []
+    };
+    for (const trait of composition.traits ?? []) {
+      this.dispatchTrait(trait, ast);
+    }
+    for (const obj of composition.objects ?? []) {
+      this.extractFromObject(obj, ast);
+    }
+    return ast;
+  }
+  extractFromObject(obj, ast) {
+    const traits = obj.traits ?? [];
+    for (const trait of traits) {
+      this.dispatchTrait(trait, ast);
+    }
+  }
+  dispatchTrait(trait, ast) {
+    const cfg = trait.config;
+    switch (trait.name) {
+      case "identity": {
+        const allowedToolsList = stringListField(cfg, "allowed_tools");
+        ast.identity = {
+          name: stringField(cfg, "name", ""),
+          role: stringField(cfg, "role", ""),
+          domain: stringField(cfg, "domain", ""),
+          surface: stringField(cfg, "surface", "any") ?? "any",
+          noMonopoly: boolField(cfg, "no_monopoly", false),
+          description: stringFieldOrUndef(cfg, "description"),
+          allowedTools: allowedToolsList.length > 0 ? allowedToolsList : void 0,
+          commandTemplate: stringFieldOrUndef(cfg, "command_template")
+        };
+        break;
+      }
+      case "authority_order":
+        ast.authorityOrder = { tiers: stringListField(cfg, "tiers") };
+        break;
+      case "vision_pillar":
+        ast.visionPillars.push({
+          id: stringField(cfg, "id", ""),
+          claim: stringField(cfg, "claim", ""),
+          citation: stringFieldOrUndef(cfg, "citation")
+        });
+        break;
+      case "output_shape":
+        ast.outputShape = {
+          silentTo: stringField(cfg, "silent_to", ""),
+          loudTo: stringField(cfg, "loud_to", ""),
+          noMetaOutput: boolField(cfg, "no_meta_output", false),
+          surfaceHint: stringField(cfg, "surface_hint", "")
+        };
+        break;
+      case "production_rule":
+        ast.productionRule = {
+          noDevNoMockNoLocalhost: boolField(cfg, "no_dev_no_mock_no_localhost", false),
+          exception: stringFieldOrUndef(cfg, "exception")
+        };
+        break;
+      case "refusal":
+        ast.refusals.push({
+          name: stringField(cfg, "name", ""),
+          when: stringField(cfg, "when", ""),
+          do: stringField(cfg, "do", ""),
+          doNot: stringListField(cfg, "do_not"),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "hard_dont":
+        ast.hardDonts.push({
+          name: stringField(cfg, "name", ""),
+          reason: stringField(cfg, "reason", ""),
+          alternative: stringFieldOrUndef(cfg, "alternative"),
+          appliesTo: stringListField(cfg, "applies_to")
+        });
+        break;
+      case "default":
+        ast.defaults.push({
+          name: stringField(cfg, "name", ""),
+          when: stringField(cfg, "when", ""),
+          do: stringField(cfg, "do", ""),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "graduated_wisdom":
+        ast.graduatedWisdoms.push({
+          id: stringField(cfg, "id", ""),
+          claim: stringField(cfg, "claim", ""),
+          tier: stringField(cfg, "tier", "gold")
+        });
+        break;
+      case "feedback":
+        ast.feedbacks.push({
+          id: stringField(cfg, "id", ""),
+          claim: stringField(cfg, "claim", ""),
+          source: stringFieldOrUndef(cfg, "source")
+        });
+        break;
+      case "escalation":
+        ast.escalations.push({
+          trigger: stringField(cfg, "trigger", ""),
+          doAction: stringField(cfg, "do_action", ""),
+          recipient: stringField(cfg, "recipient", ""),
+          refuseToEscalateWhen: stringListField(cfg, "refuse_to_escalate_when")
+        });
+        break;
+      case "verify_token":
+        ast.verifyTokens.push({
+          meaning: stringField(cfg, "meaning", ""),
+          example: stringField(cfg, "example", "")
+        });
+        break;
+      case "gap_rule":
+        ast.gapRules.push({
+          name: stringField(cfg, "name", ""),
+          when: stringField(cfg, "when", ""),
+          do: stringListField(cfg, "do"),
+          doNot: stringListField(cfg, "do_not"),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "citation_rule":
+        ast.citationRules.push({
+          fluentProseThresholdChars: numberField(
+            cfg,
+            "fluent_prose_threshold_chars",
+            DEFAULT_FLUENT_PROSE_CHARS
+          ),
+          required: stringListField(cfg, "required"),
+          exemption: stringFieldOrUndef(cfg, "exemption"),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "skill":
+        ast.skills.push({
+          name: stringField(cfg, "name", ""),
+          invocableAs: stringField(cfg, "invocable_as", ""),
+          authority: stringField(cfg, "authority", ""),
+          authoritativeFor: stringListField(cfg, "authoritative_for"),
+          refusals: stringListField(cfg, "refusals")
+        });
+        break;
+      case "include":
+        ast.includes.push({
+          source: stringField(cfg, "source", ""),
+          selector: stringFieldOrUndef(cfg, "selector")
+        });
+        break;
+      case "routine":
+        ast.routines.push({
+          id: stringField(cfg, "id", ""),
+          schedule: stringField(cfg, "schedule", ""),
+          skill: stringField(cfg, "skill", ""),
+          promptRef: stringField(cfg, "prompt_ref", ""),
+          sla: stringField(cfg, "sla", ""),
+          outputDir: stringFieldOrUndef(cfg, "output_dir"),
+          cleanExitScript: stringFieldOrUndef(cfg, "clean_exit_script")
+        });
+        break;
+      case "hard_physical_gap":
+        ast.hardPhysicalGaps.push({
+          name: stringField(cfg, "name", ""),
+          reason: stringField(cfg, "reason", ""),
+          appliesTo: stringListField(cfg, "applies_to"),
+          alternative: stringFieldOrUndef(cfg, "alternative")
+        });
+        break;
+      case "invocation_mode":
+        ast.invocationModes.push({
+          mode: stringField(cfg, "mode", "explicit"),
+          when: stringField(cfg, "when", ""),
+          effect: stringField(cfg, "effect", ""),
+          example: stringFieldOrUndef(cfg, "example")
+        });
+        break;
+      case "date_discipline": {
+        const crossRefs = stringListField(cfg, "cross_references");
+        ast.dateDisciplines.push({
+          wisdomId: stringField(cfg, "wisdom_id", ""),
+          refusalContract: stringField(cfg, "refusal_contract", ""),
+          requiredComponents: stringListField(cfg, "required_components"),
+          shapeTemplate: stringField(cfg, "shape_template", ""),
+          reason: stringFieldOrUndef(cfg, "reason"),
+          crossReferences: crossRefs.length > 0 ? crossRefs : void 0
+        });
+        break;
+      }
+      case "domain_preference":
+        ast.domainPreferences.push({
+          domain: stringField(cfg, "domain", ""),
+          skills: stringListField(cfg, "skills"),
+          notes: stringFieldOrUndef(cfg, "notes"),
+          ceiling: stringFieldOrUndef(cfg, "ceiling")
+        });
+        break;
+      case "authority":
+        ast.trackBAuthorities.push({
+          target: stringField(cfg, "target", ""),
+          actionType: stringField(cfg, "action_type", ""),
+          requires: stringListField(cfg, "requires"),
+          founderRatificationRequired: boolField(
+            cfg,
+            "founder_ratification_required",
+            false
+          ),
+          notes: stringFieldOrUndef(cfg, "notes")
+        });
+        break;
+      case "embodied_projection":
+        ast.embodiedProjections.push({
+          surface: stringField(cfg, "surface", ""),
+          projectionKind: stringField(cfg, "projection_kind", "read-only"),
+          trigger: stringField(cfg, "trigger", ""),
+          notes: stringFieldOrUndef(cfg, "notes")
+        });
+        break;
+      case "editorial_default":
+        ast.editorialDefaults.push({
+          name: stringField(cfg, "name", ""),
+          paperId: stringFieldOrUndef(cfg, "paper_id"),
+          paperPhase: stringFieldOrUndef(cfg, "paper_phase"),
+          when: stringField(cfg, "when", ""),
+          do: stringField(cfg, "do", ""),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "research_default":
+        ast.researchDefaults.push({
+          name: stringField(cfg, "name", ""),
+          paperId: stringFieldOrUndef(cfg, "paper_id"),
+          paperPhase: stringFieldOrUndef(cfg, "paper_phase"),
+          when: stringField(cfg, "when", ""),
+          do: stringField(cfg, "do", ""),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "narrative_opening":
+        ast.narrativeOpenings.push({
+          posture: stringField(cfg, "posture", ""),
+          reason: stringFieldOrUndef(cfg, "reason")
+        });
+        break;
+      case "trigger_phrase":
+        ast.triggerPhrases.push({
+          phrase: stringField(cfg, "phrase", ""),
+          context: stringFieldOrUndef(cfg, "context")
+        });
+        break;
+      case "prose_after":
+        ast.proseAfters.push({
+          trait: stringField(cfg, "trait", ""),
+          paragraphs: stringListField(cfg, "paragraphs")
+        });
+        break;
+      case "domain_dispatch":
+        ast.domainDispatches.push({
+          domain: stringField(cfg, "domain", ""),
+          skills: stringListField(cfg, "skills")
+        });
+        break;
+      case "corpus_mutability":
+        ast.corpusMutabilities.push({
+          policy: stringField(cfg, "policy", ""),
+          description: stringField(cfg, "description", "")
+        });
+        break;
+      default:
+        ast.warnings.push({
+          severity: "warning",
+          rule: "unknown-trait",
+          message: `Trait "${trait.name}" is not in vocabulary v1. Ignored. Add to vocabulary if load-bearing.`
+        });
+        break;
+    }
+  }
+  // --- Phase 2: validate (BLOCK rules throw, WARN rules accumulate) --
+  validate(ast) {
+    for (const def of ast.defaults) {
+      for (const banned of BANNED_DEFAULT_PATTERNS) {
+        if (banned.pattern.test(def.do)) {
+          throw new ContextCompileError(
+            `@default "${def.name}" recommends a banned pattern (matches ${banned.pattern}). Rule: ${banned.rule}.`
+          );
+        }
+      }
+    }
+    for (const dont of ast.hardDonts) {
+      const haystack = `${dont.name} ${dont.reason}`;
+      for (const vendorPat of VENDOR_AS_SUBSTRATE_PATTERNS) {
+        if (vendorPat.pattern.test(haystack)) {
+          throw new ContextCompileError(
+            `@hard_dont "${dont.name}" appears to author a vendor-as-substrate pattern. Rule: ${vendorPat.rule}. (A correct hard_dont SAYS "do not adopt vendor as substrate" - this one's framing matches the inverse.)`
+          );
+        }
+      }
+    }
+    for (const wisdom of ast.graduatedWisdoms) {
+      if (wisdom.tier === "diamond" && !KNOWN_DIAMOND_IDS.has(wisdom.id)) {
+        throw new ContextCompileError(
+          `@graduated_wisdom "${wisdom.id}" claims tier="diamond" but is not in the compiler's known-Diamond set. Diamond declaration is founder-only (D:/GOLD/INDEX.md). If this is a new Diamond entry, update KNOWN_DIAMOND_IDS in ContextCompiler.ts in the same commit that lands the GOLD entry.`
+        );
+      }
+    }
+    const physicalGapNames = new Set(ast.hardPhysicalGaps.map((g) => g.name));
+    for (const skill of ast.skills) {
+      for (const claim of skill.authoritativeFor) {
+        if (physicalGapNames.has(claim)) {
+          throw new ContextCompileError(
+            `@skill "${skill.name}" claims authoritative_for="${claim}" but that's a @hard_physical_gap (Trezor/Quest 3/in-person - non-absorbable). Founder skill section "Hard physical gaps the skill never absorbs". Either remove the claim or, if the skill genuinely covers the decision-side (yes/no/when/how-much) without the embodied step, narrow the authoritative_for entry to make the boundary explicit.`
+          );
+        }
+      }
+    }
+    for (const wisdom of ast.graduatedWisdoms) {
+      if (wisdom.tier !== "diamond" && !/^[WPG]\.GOLD\.\d+$/.test(wisdom.id)) {
+        ast.warnings.push({
+          severity: "warning",
+          rule: "F.023 vault-id-format",
+          message: `@graduated_wisdom id "${wisdom.id}" doesn't match expected format (W.GOLD.NNN | P.GOLD.NNN | G.GOLD.NNN). Possible typo or stale citation.`
+        });
+      }
+    }
+  }
+  // --- Phase 3: emit -- compile_to_claude_md -------------------------
+  emitClaudeMd(ast) {
+    const lines = [];
+    if (ast.identity) {
+      lines.push(`# ${ast.identity.name}`);
+      lines.push("");
+      lines.push(`> **Role**: ${ast.identity.role}`);
+      lines.push(`> **Domain**: ${ast.identity.domain}`);
+      lines.push(`> **Surface**: ${ast.identity.surface}`);
+      if (ast.identity.noMonopoly) {
+        lines.push(
+          `> **No-monopoly rule**: this context applies the absorb-as-adapter architectural posture (per docs/LLM_CAPABILITIES.md section Architectural posture).`
+        );
+      }
+      lines.push("");
+    }
+    for (const opening of ast.narrativeOpenings) {
+      const postureLines = opening.posture.split(/\r?\n/);
+      for (const pl of postureLines) {
+        lines.push(`> ${pl}`);
+      }
+      if (opening.reason) {
+        const reasonLines = opening.reason.split(/\r?\n/);
+        for (const rl of reasonLines) {
+          lines.push(`> ${rl}`);
+        }
+      }
+      lines.push("");
+    }
+    if (ast.authorityOrder && ast.authorityOrder.tiers.length > 0) {
+      lines.push(`## Authority order (read top-down; the first match wins)`);
+      lines.push("");
+      ast.authorityOrder.tiers.forEach((tier, idx) => {
+        lines.push(`${idx + 1}. **${tier}**`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "authority_order");
+    }
+    if (ast.visionPillars.length > 0) {
+      lines.push(`## Vision pillars (follow; do not drift)`);
+      lines.push("");
+      ast.visionPillars.forEach((pillar, idx) => {
+        const cite = pillar.citation ? ` *(${pillar.citation})*` : "";
+        lines.push(`${idx + 1}. **${pillar.claim}**${cite}`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "vision_pillar");
+    }
+    if (ast.refusals.length > 0) {
+      lines.push(`## The Four Refusals`);
+      lines.push("");
+      lines.push(
+        `These are not guidelines. They are refusals. If you catch yourself about to do any of the following, stop and reframe before continuing.`
+      );
+      lines.push("");
+      for (const refusal of ast.refusals) {
+        lines.push(`### Refuse the ${refusal.name}`);
+        lines.push("");
+        lines.push(`**When**: ${refusal.when}`);
+        lines.push("");
+        lines.push(`**Do**: ${refusal.do}`);
+        lines.push("");
+        if (refusal.doNot.length > 0) {
+          lines.push(`**Do not**: ${refusal.doNot.map((d) => `\`${d}\``).join(", ")}`);
+          lines.push("");
+        }
+        if (refusal.reason) {
+          lines.push(`**Reason**: ${refusal.reason}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "refusal");
+    }
+    if (ast.hardDonts.length > 0) {
+      lines.push(`## Hard don'ts (cross-provider red lines)`);
+      lines.push("");
+      lines.push(`| Name | Reason | Alternative |`);
+      lines.push(`|---|---|---|`);
+      for (const dont of ast.hardDonts) {
+        lines.push(
+          `| **${dont.name}** | ${dont.reason} | ${dont.alternative ?? "*(none)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "hard_dont");
+    }
+    if (ast.defaults.length > 0) {
+      lines.push(`## Known founder defaults (answer immediately)`);
+      lines.push("");
+      lines.push(`| When | Answer | Reason |`);
+      lines.push(`|---|---|---|`);
+      for (const def of ast.defaults) {
+        lines.push(
+          `| ${def.when} | **${def.do}** | ${def.reason ?? "*(no citation)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "default");
+    }
+    if (ast.domainPreferences.length > 0) {
+      lines.push("## Domain preferences (beyond engineering)");
+      lines.push("");
+      lines.push("| Domain | Skills to delegate to | Notes / ceiling |");
+      lines.push("|---|---|---|");
+      for (const pref of ast.domainPreferences) {
+        const skills = pref.skills.length > 0 ? pref.skills.map((s) => `\`${s}\``).join(", ") : "*(in-skill default)*";
+        const notesParts = [];
+        if (pref.ceiling) notesParts.push(`Ceiling: ${pref.ceiling}`);
+        if (pref.notes) notesParts.push(pref.notes);
+        const notes = notesParts.join("; ") || "";
+        lines.push(`| **${pref.domain}** | ${skills} | ${notes} |`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "domain_preference");
+    }
+    this.appendTrackBAuthority(lines, ast);
+    this.appendProseAfter(lines, ast, "authority");
+    this.appendPapersProgramDefaults(lines, ast);
+    this.appendProseAfter(lines, ast, "editorial_default");
+    this.appendProseAfter(lines, ast, "research_default");
+    if (ast.outputShape) {
+      lines.push(`## Output shape \u2014 SILENT-TO-JOSEPH, LOUD-TO-THE-AGENT`);
+      lines.push("");
+      lines.push(`- **Silent to**: ${ast.outputShape.silentTo}`);
+      lines.push(`- **Loud to**: ${ast.outputShape.loudTo}`);
+      if (ast.outputShape.noMetaOutput) {
+        lines.push(`- **No meta-output**: do not narrate the protocol back to the user`);
+      }
+      if (ast.outputShape.surfaceHint) {
+        lines.push(`- **Surface hint**: ${ast.outputShape.surfaceHint}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "output_shape");
+    }
+    if (ast.productionRule) {
+      lines.push(`## Production-only rule (no dev, no mock, no localhost)`);
+      lines.push("");
+      if (ast.productionRule.noDevNoMockNoLocalhost) {
+        lines.push(`No dev. No mock. No localhost. The real service exists - hit it.`);
+      }
+      if (ast.productionRule.exception) {
+        lines.push("");
+        lines.push(`**Exception**: ${ast.productionRule.exception}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "production_rule");
+    }
+    if (ast.hardPhysicalGaps.length > 0) {
+      lines.push(`## Hard physical gaps (skill never absorbs)`);
+      lines.push("");
+      for (const gap of ast.hardPhysicalGaps) {
+        lines.push(`- **${gap.name}** - ${gap.reason}`);
+        if (gap.alternative) {
+          lines.push(`  - Alternative: ${gap.alternative}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "hard_physical_gap");
+    }
+    if (ast.skills.length > 0) {
+      lines.push(`## Skills`);
+      lines.push("");
+      for (const skill of ast.skills) {
+        lines.push(`### \`${skill.invocableAs}\` - ${skill.name}`);
+        lines.push("");
+        lines.push(`**Authority**: ${skill.authority}`);
+        lines.push("");
+        if (skill.authoritativeFor.length > 0) {
+          lines.push(`**Authoritative for**: ${skill.authoritativeFor.join(", ")}`);
+          lines.push("");
+        }
+        if (skill.refusals && skill.refusals.length > 0) {
+          lines.push(`**Refusals enforced**: ${skill.refusals.join(", ")}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "skill");
+    }
+    if (ast.invocationModes.length > 0) {
+      lines.push("## Invocation modes (Track D)");
+      lines.push("");
+      for (const mode of ast.invocationModes) {
+        lines.push(`### ${mode.mode}`);
+        lines.push("");
+        lines.push(`- **When**: ${mode.when}`);
+        lines.push(`- **Effect**: ${mode.effect}`);
+        if (mode.example) {
+          lines.push(`- **Example**: \`${mode.example}\``);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "invocation_mode");
+    }
+    appendEmbodiedProjectionSection(lines, ast.embodiedProjections);
+    this.appendProseAfter(lines, ast, "embodied_projection");
+    if (ast.routines.length > 0) {
+      lines.push(`## Recurring routines (A-00X)`);
+      lines.push("");
+      lines.push(`| ID | Schedule | Skill | Output |`);
+      lines.push(`|---|---|---|---|`);
+      for (const routine of ast.routines) {
+        lines.push(
+          `| ${routine.id} | \`${routine.schedule}\` | ${routine.skill} | ${routine.outputDir ?? "*(varies)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "routine");
+    }
+    if (ast.escalations.length > 0) {
+      lines.push(`## Escape hatch`);
+      lines.push("");
+      for (const esc of ast.escalations) {
+        lines.push(`- **Trigger**: ${esc.trigger}`);
+        lines.push(`  - **Action**: ${esc.doAction}`);
+        lines.push(`  - **Recipient**: ${esc.recipient}`);
+        if (esc.refuseToEscalateWhen.length > 0) {
+          lines.push(
+            `  - **Refuse to escalate when**: ${esc.refuseToEscalateWhen.join(", ")}`
+          );
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "escalation");
+    }
+    if (ast.dateDisciplines.length > 0) {
+      const firstWisdom = ast.dateDisciplines[0]?.wisdomId;
+      const wisdomSuffix = ast.dateDisciplines.length === 1 && firstWisdom ? ` (${firstWisdom})` : "";
+      lines.push(`## Date discipline${wisdomSuffix}`);
+      lines.push("");
+      for (const d of ast.dateDisciplines) {
+        const wisdomLabel = d.wisdomId ? ` (${d.wisdomId})` : "";
+        lines.push(`### Refusal contract${wisdomLabel}`);
+        lines.push("");
+        lines.push(`**${d.refusalContract}**`);
+        lines.push("");
+        if (d.requiredComponents.length > 0) {
+          lines.push("**Required components** (all must be present):");
+          for (const comp of d.requiredComponents) {
+            lines.push(`- ${comp}`);
+          }
+          lines.push("");
+        }
+        if (d.shapeTemplate) {
+          lines.push("**Output shape**:");
+          lines.push("");
+          lines.push("```");
+          lines.push(d.shapeTemplate);
+          lines.push("```");
+          lines.push("");
+        }
+        if (d.reason) {
+          lines.push(`**Reason**: ${d.reason}`);
+          lines.push("");
+        }
+        if (d.crossReferences && d.crossReferences.length > 0) {
+          lines.push(`**Cross-references**: ${d.crossReferences.join(", ")}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "date_discipline");
+    }
+    if (ast.citationRules.length > 0) {
+      lines.push(`## Citation discipline`);
+      lines.push("");
+      for (const rule of ast.citationRules) {
+        lines.push(
+          `- Fluent prose over **${rule.fluentProseThresholdChars} chars** must include one of: ${rule.required.join(", ")}`
+        );
+        if (rule.exemption) {
+          lines.push(`  - Exemption: ${rule.exemption}`);
+        }
+        if (rule.reason) {
+          lines.push(`  - Reason: ${rule.reason}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "citation_rule");
+    }
+    if (ast.graduatedWisdoms.length > 0 || ast.feedbacks.length > 0) {
+      lines.push(`## Authority cross-references`);
+      lines.push("");
+      if (ast.graduatedWisdoms.length > 0) {
+        lines.push(`### GOLD-tier wisdom`);
+        lines.push("");
+        for (const wisdom of ast.graduatedWisdoms) {
+          lines.push(`- **${wisdom.id}** *(${wisdom.tier})* - ${wisdom.claim}`);
+        }
+        lines.push("");
+      }
+      if (ast.feedbacks.length > 0) {
+        lines.push(`### Feedback memory`);
+        lines.push("");
+        for (const fb of ast.feedbacks) {
+          const src = fb.source ? ` (${fb.source})` : "";
+          lines.push(`- **${fb.id}**${src} - ${fb.claim}`);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "graduated_wisdom");
+      this.appendProseAfter(lines, ast, "feedback");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(
+      `*Generated by HoloScript ContextCompiler (compile_to_claude_md). Source: HoloScript composition. Vocabulary: v3 (ratified 2026-05-07).*`
+    );
+    lines.push("");
+    return lines.join("\n");
+  }
+  // --- Phase 3: emit -- compile_to_agents_md -------------------------
+  /**
+   * Emit AGENTS.md - cross-tool agent context format. Read by Codex,
+   * Copilot, Cursor, Continue, Windsurf, Amp, Devin (any tool that
+   * follows the AGENTS.md convention seeded by the Codex docs).
+   *
+   * Differences from claude_md (per Phase 1 follow-up task spec):
+   *   - "## Project principles" instead of "## Vision pillars"
+   *   - "## Hard rules" instead of "## The Refusals" (Codex audience
+   *     uses non-ritual rule-list framing; refusals + hard donts are
+   *     merged into one flat ranked list under this single section)
+   *   - "## Conventions" instead of "## Known defaults"
+   *   - "## Workflows" instead of "## Skills" (Codex's closer term)
+   *
+   * Shared sections (authority order, output shape, production rule,
+   * hard physical gaps, recurring routines, escalation, citation
+   * discipline, authority cross-references) keep the same name across
+   * surfaces - those names are universal-context terms, not
+   * Claude-specific framings.
+   */
+  emitAgentsMd(ast) {
+    const lines = [];
+    lines.push("# AGENTS.md");
+    lines.push("");
+    if (ast.identity) {
+      lines.push(`> **Role**: ${ast.identity.role}`);
+      lines.push(`> **Domain**: ${ast.identity.domain}`);
+      lines.push(
+        `> **Surface**: ${ast.identity.surface} (cross-tool: read by Codex, Copilot, Cursor, Continue, Windsurf, Amp, Devin)`
+      );
+      if (ast.identity.noMonopoly) {
+        lines.push(
+          `> **No-monopoly rule**: this context applies the absorb-as-adapter architectural posture (per docs/LLM_CAPABILITIES.md section Architectural posture).`
+        );
+      }
+      lines.push("");
+    }
+    for (const opening of ast.narrativeOpenings) {
+      const postureLines = opening.posture.split(/\r?\n/);
+      for (const pl of postureLines) {
+        lines.push(`> ${pl}`);
+      }
+      if (opening.reason) {
+        const reasonLines = opening.reason.split(/\r?\n/);
+        for (const rl of reasonLines) {
+          lines.push(`> ${rl}`);
+        }
+      }
+      lines.push("");
+    }
+    if (ast.authorityOrder && ast.authorityOrder.tiers.length > 0) {
+      lines.push("## Authority order (read top-down; first match wins)");
+      lines.push("");
+      ast.authorityOrder.tiers.forEach((tier, idx) => {
+        lines.push(`${idx + 1}. **${tier}**`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "authority_order");
+    }
+    if (ast.visionPillars.length > 0) {
+      lines.push("## Project principles (follow; do not drift)");
+      lines.push("");
+      ast.visionPillars.forEach((pillar, idx) => {
+        const cite = pillar.citation ? ` *(${pillar.citation})*` : "";
+        lines.push(`${idx + 1}. **${pillar.claim}**${cite}`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "vision_pillar");
+    }
+    if (ast.refusals.length > 0 || ast.hardDonts.length > 0) {
+      lines.push("## Hard rules (The Four Refusals + cross-provider red lines)");
+      lines.push("");
+      lines.push(
+        "Rules below are non-negotiable. Each names what to do, what NOT to do, and why."
+      );
+      lines.push("");
+      for (const refusal of ast.refusals) {
+        lines.push(`### ${refusal.name}`);
+        lines.push("");
+        lines.push(`- **When**: ${refusal.when}`);
+        lines.push(`- **Do**: ${refusal.do}`);
+        if (refusal.doNot.length > 0) {
+          lines.push(`- **Do not**: ${refusal.doNot.map((d) => `\`${d}\``).join(", ")}`);
+        }
+        if (refusal.reason) {
+          lines.push(`- **Reason**: ${refusal.reason}`);
+        }
+        lines.push("");
+      }
+      for (const dont of ast.hardDonts) {
+        lines.push(`### ${dont.name}`);
+        lines.push("");
+        lines.push(`- **Reason**: ${dont.reason}`);
+        if (dont.alternative) {
+          lines.push(`- **Alternative**: ${dont.alternative}`);
+        }
+        if (dont.appliesTo.length > 0) {
+          lines.push(`- **Applies to**: ${dont.appliesTo.join(", ")}`);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "refusal");
+      this.appendProseAfter(lines, ast, "hard_dont");
+    }
+    if (ast.defaults.length > 0) {
+      lines.push("## Conventions (answer immediately)");
+      lines.push("");
+      lines.push("| When | Do | Reason |");
+      lines.push("|---|---|---|");
+      for (const def of ast.defaults) {
+        lines.push(
+          `| ${def.when} | **${def.do}** | ${def.reason ?? "*(no citation)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "default");
+    }
+    if (ast.domainPreferences.length > 0) {
+      lines.push("## Domain preferences (beyond engineering)");
+      lines.push("");
+      lines.push("| Domain | Skills to delegate to | Notes / ceiling |");
+      lines.push("|---|---|---|");
+      for (const pref of ast.domainPreferences) {
+        const skills = pref.skills.length > 0 ? pref.skills.map((s) => `\`${s}\``).join(", ") : "*(in-skill default)*";
+        const notesParts = [];
+        if (pref.ceiling) notesParts.push(`Ceiling: ${pref.ceiling}`);
+        if (pref.notes) notesParts.push(pref.notes);
+        const notes = notesParts.join("; ") || "";
+        lines.push(`| **${pref.domain}** | ${skills} | ${notes} |`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "domain_preference");
+    }
+    this.appendTrackBAuthority(lines, ast);
+    this.appendProseAfter(lines, ast, "authority");
+    this.appendPapersProgramDefaults(lines, ast);
+    this.appendProseAfter(lines, ast, "editorial_default");
+    this.appendProseAfter(lines, ast, "research_default");
+    if (ast.outputShape) {
+      lines.push("## Output shape \u2014 SILENT-TO-JOSEPH, LOUD-TO-THE-AGENT");
+      lines.push("");
+      lines.push(`- **Silent to**: ${ast.outputShape.silentTo}`);
+      lines.push(`- **Loud to**: ${ast.outputShape.loudTo}`);
+      if (ast.outputShape.noMetaOutput) {
+        lines.push("- **No meta-output**: do not narrate the protocol back to the user");
+      }
+      if (ast.outputShape.surfaceHint) {
+        lines.push(`- **Surface hint**: ${ast.outputShape.surfaceHint}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "output_shape");
+    }
+    if (ast.productionRule) {
+      lines.push("## Production-only rule (no dev, no mock, no localhost)");
+      lines.push("");
+      if (ast.productionRule.noDevNoMockNoLocalhost) {
+        lines.push("No dev. No mock. No localhost. The real service exists - hit it.");
+      }
+      if (ast.productionRule.exception) {
+        lines.push("");
+        lines.push(`**Exception**: ${ast.productionRule.exception}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "production_rule");
+    }
+    if (ast.hardPhysicalGaps.length > 0) {
+      lines.push("## Hard physical gaps (never absorb)");
+      lines.push("");
+      for (const gap of ast.hardPhysicalGaps) {
+        lines.push(`- **${gap.name}** - ${gap.reason}`);
+        if (gap.alternative) {
+          lines.push(`  - Alternative: ${gap.alternative}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "hard_physical_gap");
+    }
+    if (ast.skills.length > 0) {
+      lines.push("## Workflows");
+      lines.push("");
+      for (const skill of ast.skills) {
+        lines.push(`### ${skill.name} (\`${skill.invocableAs}\`)`);
+        lines.push("");
+        lines.push(`- **Authority**: ${skill.authority}`);
+        if (skill.authoritativeFor.length > 0) {
+          lines.push(`- **Authoritative for**: ${skill.authoritativeFor.join(", ")}`);
+        }
+        if (skill.refusals && skill.refusals.length > 0) {
+          lines.push(`- **Enforces rules**: ${skill.refusals.join(", ")}`);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "skill");
+    }
+    if (ast.invocationModes.length > 0) {
+      lines.push("## Invocation modes (Track D)");
+      lines.push("");
+      for (const mode of ast.invocationModes) {
+        lines.push(`### ${mode.mode}`);
+        lines.push("");
+        lines.push(`- **When**: ${mode.when}`);
+        lines.push(`- **Effect**: ${mode.effect}`);
+        if (mode.example) {
+          lines.push(`- **Example**: \`${mode.example}\``);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "invocation_mode");
+    }
+    appendEmbodiedProjectionSection(lines, ast.embodiedProjections);
+    this.appendProseAfter(lines, ast, "embodied_projection");
+    if (ast.routines.length > 0) {
+      lines.push("## Recurring routines (A-00X)");
+      lines.push("");
+      lines.push("| ID | Schedule | Skill | Output |");
+      lines.push("|---|---|---|---|");
+      for (const routine of ast.routines) {
+        lines.push(
+          `| ${routine.id} | \`${routine.schedule}\` | ${routine.skill} | ${routine.outputDir ?? "*(varies)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "routine");
+    }
+    if (ast.escalations.length > 0) {
+      lines.push("## Escape hatch");
+      lines.push("");
+      for (const esc of ast.escalations) {
+        lines.push(`- **Trigger**: ${esc.trigger}`);
+        lines.push(`  - **Action**: ${esc.doAction}`);
+        lines.push(`  - **Recipient**: ${esc.recipient}`);
+        if (esc.refuseToEscalateWhen.length > 0) {
+          lines.push(
+            `  - **Refuse to escalate when**: ${esc.refuseToEscalateWhen.join(", ")}`
+          );
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "escalation");
+    }
+    if (ast.dateDisciplines.length > 0) {
+      const firstWisdom = ast.dateDisciplines[0]?.wisdomId;
+      const wisdomSuffix = ast.dateDisciplines.length === 1 && firstWisdom ? ` (${firstWisdom})` : "";
+      lines.push(`## Date discipline${wisdomSuffix}`);
+      lines.push("");
+      for (const d of ast.dateDisciplines) {
+        const wisdomLabel = d.wisdomId ? ` (${d.wisdomId})` : "";
+        lines.push(`### Refusal contract${wisdomLabel}`);
+        lines.push("");
+        lines.push(`**${d.refusalContract}**`);
+        lines.push("");
+        if (d.requiredComponents.length > 0) {
+          lines.push("**Required components** (all must be present):");
+          for (const comp of d.requiredComponents) {
+            lines.push(`- ${comp}`);
+          }
+          lines.push("");
+        }
+        if (d.shapeTemplate) {
+          lines.push("**Output shape**:");
+          lines.push("");
+          lines.push("```");
+          lines.push(d.shapeTemplate);
+          lines.push("```");
+          lines.push("");
+        }
+        if (d.reason) {
+          lines.push(`**Reason**: ${d.reason}`);
+          lines.push("");
+        }
+        if (d.crossReferences && d.crossReferences.length > 0) {
+          lines.push(`**Cross-references**: ${d.crossReferences.join(", ")}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "date_discipline");
+    }
+    if (ast.citationRules.length > 0) {
+      lines.push("## Citation discipline");
+      lines.push("");
+      for (const rule of ast.citationRules) {
+        lines.push(
+          `- Fluent prose over **${rule.fluentProseThresholdChars} chars** must include one of: ${rule.required.join(", ")}`
+        );
+        if (rule.exemption) {
+          lines.push(`  - Exemption: ${rule.exemption}`);
+        }
+        if (rule.reason) {
+          lines.push(`  - Reason: ${rule.reason}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "citation_rule");
+    }
+    if (ast.graduatedWisdoms.length > 0 || ast.feedbacks.length > 0) {
+      lines.push("## Authority cross-references");
+      lines.push("");
+      if (ast.graduatedWisdoms.length > 0) {
+        lines.push("### GOLD-tier wisdom");
+        lines.push("");
+        for (const wisdom of ast.graduatedWisdoms) {
+          lines.push(`- **${wisdom.id}** *(${wisdom.tier})* - ${wisdom.claim}`);
+        }
+        lines.push("");
+      }
+      if (ast.feedbacks.length > 0) {
+        lines.push("### Feedback memory");
+        lines.push("");
+        for (const fb of ast.feedbacks) {
+          const src = fb.source ? ` (${fb.source})` : "";
+          lines.push(`- **${fb.id}**${src} - ${fb.claim}`);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "graduated_wisdom");
+      this.appendProseAfter(lines, ast, "feedback");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(
+      `*Generated by HoloScript ContextCompiler (compile_to_agents_md). Source: HoloScript composition. Vocabulary: v3 (ratified 2026-05-07). Cross-tool: Codex, Copilot, Cursor, Continue, Windsurf, Amp, Devin.*`
+    );
+    lines.push("");
+    return lines.join("\n");
+  }
+  // --- Phase 3: emit -- compile_to_cursor_rules ----------------------
+  /**
+   * Emit Cursor `.cursor/rules/*.mdc` files. Different output shape from
+   * claude_md / agents_md - one file per rule rather than a single big
+   * file (Cursor's idiom). Per spec:
+   * research/2026-05-06_cursor-mdc-spec.md.
+   *
+   * Layout:
+   *   .cursor/rules/refusal-<name>.mdc       (one per @refusal)
+   *   .cursor/rules/hard-dont-<name>.mdc     (one per @hard_dont)
+   *   .cursor/rules/default-<name>.mdc       (one per @default)
+   *   .cursor/rules/_ecosystem-context.mdc   (top-level blocks: identity,
+   *                                           authority order, vision
+   *                                           pillars, production rule,
+   *                                           output shape, gaps, routines,
+   *                                           skill registry, cross-refs)
+   *
+   * Frontmatter v1: every file emits with `alwaysApply: true` and empty
+   * `globs:`. Glob mapping from `applies_to` -> file patterns is deferred
+   * to v2 (see spec memo § "What the emitter does NOT do (v1 scope)").
+   *
+   * Returns Record<string, string> with full repo-relative paths as keys
+   * (e.g. ".cursor/rules/refusal-bandaid.mdc"). The consumer writes each
+   * entry to disk at exactly that path.
+   */
+  emitCursorRules(ast) {
+    const out = {};
+    for (const refusal of ast.refusals) {
+      const slug = toCursorSlug(refusal.name);
+      const filename = `.cursor/rules/refusal-${slug}.mdc`;
+      const description = oneLine(
+        `Refusal: ${refusal.name} - ${refusal.reason ?? refusal.when}`
+      );
+      const body = [];
+      body.push(`# Refusal: ${refusal.name}`);
+      body.push("");
+      body.push(`**When**: ${refusal.when}`);
+      body.push("");
+      body.push(`**Do**: ${refusal.do}`);
+      body.push("");
+      if (refusal.doNot.length > 0) {
+        body.push(`**Do not**: ${refusal.doNot.map((d) => `\`${d}\``).join(", ")}`);
+        body.push("");
+      }
+      if (refusal.reason) {
+        body.push(`**Reason**: ${refusal.reason}`);
+        body.push("");
+      }
+      out[filename] = wrapMdc(description, body);
+    }
+    for (const dont of ast.hardDonts) {
+      const slug = toCursorSlug(dont.name);
+      const filename = `.cursor/rules/hard-dont-${slug}.mdc`;
+      const description = oneLine(`Hard don't: ${dont.name} - ${dont.reason}`);
+      const body = [];
+      body.push(`# Hard don't: ${dont.name}`);
+      body.push("");
+      body.push(`**Reason**: ${dont.reason}`);
+      body.push("");
+      if (dont.alternative) {
+        body.push(`**Alternative**: ${dont.alternative}`);
+        body.push("");
+      }
+      if (dont.appliesTo.length > 0) {
+        body.push(`**Applies to**: ${dont.appliesTo.join(", ")}`);
+        body.push("");
+      }
+      out[filename] = wrapMdc(description, body);
+    }
+    for (const def of ast.defaults) {
+      const slug = toCursorSlug(def.name);
+      const filename = `.cursor/rules/default-${slug}.mdc`;
+      const description = oneLine(`Default: ${def.name} - ${def.when}`);
+      const body = [];
+      body.push(`# Default: ${def.name}`);
+      body.push("");
+      body.push(`**When**: ${def.when}`);
+      body.push("");
+      body.push(`**Do**: ${def.do}`);
+      body.push("");
+      if (def.reason) {
+        body.push(`**Reason**: ${def.reason}`);
+        body.push("");
+      }
+      out[filename] = wrapMdc(description, body);
+    }
+    const indexFilename = ".cursor/rules/_ecosystem-context.mdc";
+    const indexDescription = ast.identity ? oneLine(`Ecosystem context for ${ast.identity.name} (${ast.identity.role})`) : "Ecosystem context (HoloScript-generated)";
+    const idx = [];
+    if (ast.identity) {
+      idx.push(`# ${ast.identity.name}`);
+      idx.push("");
+      idx.push(`**Role**: ${ast.identity.role}`);
+      idx.push(`**Domain**: ${ast.identity.domain}`);
+      idx.push(`**Surface**: ${ast.identity.surface}`);
+      if (ast.identity.noMonopoly) {
+        idx.push("");
+        idx.push(
+          "No-monopoly rule: this context applies the absorb-as-adapter architectural posture (per docs/LLM_CAPABILITIES.md)."
+        );
+      }
+      idx.push("");
+    } else {
+      idx.push("# Ecosystem context");
+      idx.push("");
+    }
+    for (const opening of ast.narrativeOpenings) {
+      const postureLines = opening.posture.split(/\r?\n/);
+      for (const pl of postureLines) {
+        idx.push(`> ${pl}`);
+      }
+      if (opening.reason) {
+        const reasonLines = opening.reason.split(/\r?\n/);
+        for (const rl of reasonLines) {
+          idx.push(`> ${rl}`);
+        }
+      }
+      idx.push("");
+    }
+    if (ast.authorityOrder && ast.authorityOrder.tiers.length > 0) {
+      idx.push("## Authority order (read top-down; first match wins)");
+      idx.push("");
+      ast.authorityOrder.tiers.forEach((tier, i) => {
+        idx.push(`${i + 1}. **${tier}**`);
+      });
+      idx.push("");
+      this.appendProseAfter(idx, ast, "authority_order");
+    }
+    if (ast.visionPillars.length > 0) {
+      idx.push("## Vision pillars (follow; do not drift)");
+      idx.push("");
+      ast.visionPillars.forEach((pillar, i) => {
+        const cite = pillar.citation ? ` *(${pillar.citation})*` : "";
+        idx.push(`${i + 1}. **${pillar.claim}**${cite}`);
+      });
+      idx.push("");
+      this.appendProseAfter(idx, ast, "vision_pillar");
+    }
+    if (ast.domainPreferences.length > 0) {
+      idx.push("## Domain preferences (beyond engineering)");
+      idx.push("");
+      idx.push("| Domain | Skills to delegate to | Notes / ceiling |");
+      idx.push("|---|---|---|");
+      for (const pref of ast.domainPreferences) {
+        const skills = pref.skills.length > 0 ? pref.skills.map((s) => `\`${s}\``).join(", ") : "*(in-skill default)*";
+        const notesParts = [];
+        if (pref.ceiling) notesParts.push(`Ceiling: ${pref.ceiling}`);
+        if (pref.notes) notesParts.push(pref.notes);
+        const notes = notesParts.join("; ") || "";
+        idx.push(`| **${pref.domain}** | ${skills} | ${notes} |`);
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "domain_preference");
+    }
+    this.appendTrackBAuthority(idx, ast);
+    this.appendProseAfter(idx, ast, "authority");
+    this.appendPapersProgramDefaults(idx, ast);
+    this.appendProseAfter(idx, ast, "editorial_default");
+    this.appendProseAfter(idx, ast, "research_default");
+    if (ast.outputShape) {
+      idx.push("## Output shape \u2014 SILENT-TO-JOSEPH, LOUD-TO-THE-AGENT");
+      idx.push("");
+      idx.push(`- **Silent to**: ${ast.outputShape.silentTo}`);
+      idx.push(`- **Loud to**: ${ast.outputShape.loudTo}`);
+      if (ast.outputShape.noMetaOutput) {
+        idx.push("- **No meta-output**: do not narrate the protocol back to the user");
+      }
+      if (ast.outputShape.surfaceHint) {
+        idx.push(`- **Surface hint**: ${ast.outputShape.surfaceHint}`);
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "output_shape");
+    }
+    if (ast.productionRule) {
+      idx.push("## Production-only rule (no dev, no mock, no localhost)");
+      idx.push("");
+      if (ast.productionRule.noDevNoMockNoLocalhost) {
+        idx.push("No dev. No mock. No localhost. The real service exists - hit it.");
+      }
+      if (ast.productionRule.exception) {
+        idx.push("");
+        idx.push(`**Exception**: ${ast.productionRule.exception}`);
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "production_rule");
+    }
+    if (ast.hardPhysicalGaps.length > 0) {
+      idx.push("## Hard physical gaps (skill never absorbs)");
+      idx.push("");
+      for (const gap of ast.hardPhysicalGaps) {
+        idx.push(`- **${gap.name}** - ${gap.reason}`);
+        if (gap.alternative) {
+          idx.push(`  - Alternative: ${gap.alternative}`);
+        }
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "hard_physical_gap");
+    }
+    if (ast.skills.length > 0) {
+      idx.push("## Skill registry");
+      idx.push("");
+      for (const skill of ast.skills) {
+        idx.push(`- **${skill.invocableAs}** (${skill.name}) - ${skill.authority}`);
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "skill");
+    }
+    if (ast.invocationModes.length > 0) {
+      idx.push("## Invocation modes (Track D)");
+      idx.push("");
+      for (const mode of ast.invocationModes) {
+        idx.push(`### ${mode.mode}`);
+        idx.push("");
+        idx.push(`- **When**: ${mode.when}`);
+        idx.push(`- **Effect**: ${mode.effect}`);
+        if (mode.example) {
+          idx.push(`- **Example**: \`${mode.example}\``);
+        }
+        idx.push("");
+      }
+      this.appendProseAfter(idx, ast, "invocation_mode");
+    }
+    appendEmbodiedProjectionSection(idx, ast.embodiedProjections);
+    this.appendProseAfter(idx, ast, "embodied_projection");
+    if (ast.routines.length > 0) {
+      idx.push("## Recurring routines (A-00X)");
+      idx.push("");
+      idx.push("| ID | Schedule | Skill | Output |");
+      idx.push("|---|---|---|---|");
+      for (const routine of ast.routines) {
+        idx.push(
+          `| ${routine.id} | \`${routine.schedule}\` | ${routine.skill} | ${routine.outputDir ?? "*(varies)*"} |`
+        );
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "routine");
+    }
+    if (ast.escalations.length > 0) {
+      idx.push("## Escape hatch");
+      idx.push("");
+      for (const esc of ast.escalations) {
+        idx.push(`- **Trigger**: ${esc.trigger}`);
+        idx.push(`  - **Action**: ${esc.doAction}`);
+        idx.push(`  - **Recipient**: ${esc.recipient}`);
+        if (esc.refuseToEscalateWhen.length > 0) {
+          idx.push(
+            `  - **Refuse to escalate when**: ${esc.refuseToEscalateWhen.join(", ")}`
+          );
+        }
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "escalation");
+    }
+    if (ast.dateDisciplines.length > 0) {
+      const firstWisdom = ast.dateDisciplines[0]?.wisdomId;
+      const wisdomSuffix = ast.dateDisciplines.length === 1 && firstWisdom ? ` (${firstWisdom})` : "";
+      idx.push(`## Date discipline${wisdomSuffix}`);
+      idx.push("");
+      for (const d of ast.dateDisciplines) {
+        const wisdomLabel = d.wisdomId ? ` (${d.wisdomId})` : "";
+        idx.push(`### Refusal contract${wisdomLabel}`);
+        idx.push("");
+        idx.push(`**${d.refusalContract}**`);
+        idx.push("");
+        if (d.requiredComponents.length > 0) {
+          idx.push("**Required components** (all must be present):");
+          for (const comp of d.requiredComponents) {
+            idx.push(`- ${comp}`);
+          }
+          idx.push("");
+        }
+        if (d.shapeTemplate) {
+          idx.push("**Output shape**:");
+          idx.push("");
+          idx.push("```");
+          idx.push(d.shapeTemplate);
+          idx.push("```");
+          idx.push("");
+        }
+        if (d.reason) {
+          idx.push(`**Reason**: ${d.reason}`);
+          idx.push("");
+        }
+        if (d.crossReferences && d.crossReferences.length > 0) {
+          idx.push(`**Cross-references**: ${d.crossReferences.join(", ")}`);
+          idx.push("");
+        }
+      }
+      this.appendProseAfter(idx, ast, "date_discipline");
+    }
+    if (ast.citationRules.length > 0) {
+      idx.push("## Citation discipline");
+      idx.push("");
+      for (const rule of ast.citationRules) {
+        idx.push(
+          `- Fluent prose over **${rule.fluentProseThresholdChars} chars** must include one of: ${rule.required.join(", ")}`
+        );
+        if (rule.exemption) {
+          idx.push(`  - Exemption: ${rule.exemption}`);
+        }
+        if (rule.reason) {
+          idx.push(`  - Reason: ${rule.reason}`);
+        }
+      }
+      idx.push("");
+      this.appendProseAfter(idx, ast, "citation_rule");
+    }
+    if (ast.graduatedWisdoms.length > 0 || ast.feedbacks.length > 0) {
+      idx.push("## Authority cross-references");
+      idx.push("");
+      if (ast.graduatedWisdoms.length > 0) {
+        idx.push("### GOLD-tier wisdom");
+        idx.push("");
+        for (const wisdom of ast.graduatedWisdoms) {
+          idx.push(`- **${wisdom.id}** *(${wisdom.tier})* - ${wisdom.claim}`);
+        }
+        idx.push("");
+      }
+      if (ast.feedbacks.length > 0) {
+        idx.push("### Feedback memory");
+        idx.push("");
+        for (const fb of ast.feedbacks) {
+          const src = fb.source ? ` (${fb.source})` : "";
+          idx.push(`- **${fb.id}**${src} - ${fb.claim}`);
+        }
+        idx.push("");
+      }
+      this.appendProseAfter(idx, ast, "graduated_wisdom");
+      this.appendProseAfter(idx, ast, "feedback");
+    }
+    idx.push("---");
+    idx.push("");
+    idx.push(
+      "*Generated by HoloScript ContextCompiler (compile_to_cursor_rules). Source: HoloScript composition. Vocabulary: v3 (ratified 2026-05-07). Per-rule files emit alongside this index under .cursor/rules/.*"
+    );
+    idx.push("");
+    out[indexFilename] = wrapMdc(indexDescription, idx);
+    return out;
+  }
+  // --- Phase 3: emit -- compile_to_skill_md --------------------------
+  /**
+   * Emit SKILL.md - Claude Code skill format. Read by Claude Code's
+   * skill discovery system at `~/.claude/skills/<name>/SKILL.md` and
+   * `<repo>/.claude/skills/<name>/SKILL.md` (per-window per-repo
+   * skills are loaded into the available-skills block at session start).
+   *
+   * Format differs from claude_md / agents_md / cursor_rules: Claude
+   * Code parses a YAML frontmatter block at the top of the file
+   * (`name:`, `description:`, `allowed-tools:`) for skill registration,
+   * THEN reads the markdown body as the skill prompt. The frontmatter
+   * is what makes a SKILL.md invocable as `/<name>`.
+   *
+   * Phase 2(a) target: this emitter is the dependency for self-hosting
+   * the founder skill - `compositions/founder.hs` becomes source-of-
+   * truth, `~/.claude/skills/founder/SKILL.md` becomes the emitted
+   * artifact. Round-trip parity is the validation gate.
+   *
+   * Source fields:
+   *   - frontmatter `name:` <- ContextIdentity.name
+   *   - frontmatter `description:` <- ContextIdentity.description (required
+   *     for skill discovery; emitter throws if missing - Claude Code
+   *     refuses to register a skill without one)
+   *   - frontmatter `allowed-tools:` <- ContextIdentity.allowedTools
+   *     (defaults to a sensible cross-tool set if omitted)
+   *
+   * Body sections mirror agents_md / claude_md - same vocabulary, same
+   * authority order, same refusals, etc. - so the agent's operational
+   * behavior is consistent across surfaces.
+   */
+  emitSkillMd(ast) {
+    if (!ast.identity) {
+      throw new ContextCompileError(
+        `compile_to_skill_md requires an @identity trait. Claude Code's skill discovery reads the YAML frontmatter \`name:\` field, which comes from ContextIdentity.name. Add an @identity block to the composition.`
+      );
+    }
+    if (!ast.identity.description) {
+      throw new ContextCompileError(
+        `compile_to_skill_md requires @identity.description. Claude Code refuses to register a skill without a description (skill discovery gate). Add a 'description' field to the @identity trait.`
+      );
+    }
+    const lines = [];
+    lines.push("---");
+    lines.push(`name: ${yamlScalar(ast.identity.name)}`);
+    let enrichedDescription = ast.identity.description;
+    if (ast.triggerPhrases.length > 0) {
+      enrichedDescription += "\n\nTrigger phrases:";
+      for (const tp of ast.triggerPhrases) {
+        enrichedDescription += `
+- "${tp.phrase}"${tp.context ? ` (${tp.context})` : ""}`;
+      }
+    }
+    lines.push(formatYamlDescription(enrichedDescription));
+    const tools = ast.identity.allowedTools && ast.identity.allowedTools.length > 0 ? ast.identity.allowedTools : ["Bash", "Read", "Write", "Edit", "Grep", "Glob", "WebFetch"];
+    lines.push(`allowed-tools: ${tools.join(", ")}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(`# ${ast.identity.name}`);
+    lines.push("");
+    lines.push(`> **Role**: ${ast.identity.role}`);
+    lines.push(`> **Domain**: ${ast.identity.domain}`);
+    lines.push(`> **Surface**: ${ast.identity.surface}`);
+    if (ast.identity.noMonopoly) {
+      lines.push(
+        `> **No-monopoly rule**: this skill applies the absorb-as-adapter architectural posture (per docs/LLM_CAPABILITIES.md section Architectural posture).`
+      );
+    }
+    lines.push("");
+    if (ast.identity.commandTemplate) {
+      lines.push(`**Command**: ${ast.identity.commandTemplate}`);
+      lines.push("");
+    }
+    for (const opening of ast.narrativeOpenings) {
+      const postureLines = opening.posture.split(/\r?\n/);
+      for (const pl of postureLines) {
+        lines.push(`> ${pl}`);
+      }
+      if (opening.reason) {
+        const reasonLines = opening.reason.split(/\r?\n/);
+        for (const rl of reasonLines) {
+          lines.push(`> ${rl}`);
+        }
+      }
+      lines.push("");
+    }
+    if (ast.authorityOrder && ast.authorityOrder.tiers.length > 0) {
+      lines.push("## Authority order (read top-down; first match wins)");
+      lines.push("");
+      ast.authorityOrder.tiers.forEach((tier, idx) => {
+        lines.push(`${idx + 1}. **${tier}**`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "authority_order");
+    }
+    if (ast.visionPillars.length > 0) {
+      lines.push("## Vision pillars (follow; do not drift)");
+      lines.push("");
+      ast.visionPillars.forEach((pillar, idx) => {
+        const cite = pillar.citation ? ` *(${pillar.citation})*` : "";
+        lines.push(`${idx + 1}. **${pillar.claim}**${cite}`);
+      });
+      lines.push("");
+      this.appendProseAfter(lines, ast, "vision_pillar");
+    }
+    if (ast.refusals.length > 0) {
+      lines.push("## The Four Refusals");
+      lines.push("");
+      lines.push(
+        "These are not guidelines. They are refusals. If you catch yourself about to do any of the following, stop and reframe before continuing."
+      );
+      lines.push("");
+      for (const refusal of ast.refusals) {
+        lines.push(`### Refuse the ${refusal.name}`);
+        lines.push("");
+        lines.push(`**When**: ${refusal.when}`);
+        lines.push("");
+        lines.push(`**Do**: ${refusal.do}`);
+        lines.push("");
+        if (refusal.doNot.length > 0) {
+          lines.push(`**Do not**: ${refusal.doNot.map((d) => `\`${d}\``).join(", ")}`);
+          lines.push("");
+        }
+        if (refusal.reason) {
+          lines.push(`**Reason**: ${refusal.reason}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "refusal");
+    }
+    if (ast.hardDonts.length > 0) {
+      lines.push("## Hard don'ts (cross-provider red lines)");
+      lines.push("");
+      lines.push(`| Name | Reason | Alternative |`);
+      lines.push(`|---|---|---|`);
+      for (const dont of ast.hardDonts) {
+        lines.push(
+          `| **${dont.name}** | ${dont.reason} | ${dont.alternative ?? "*(none)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "hard_dont");
+    }
+    if (ast.defaults.length > 0) {
+      lines.push("## Known founder defaults (answer immediately)");
+      lines.push("");
+      lines.push(`| When | Answer | Reason |`);
+      lines.push(`|---|---|---|`);
+      for (const def of ast.defaults) {
+        lines.push(
+          `| ${def.when} | **${def.do}** | ${def.reason ?? "*(no citation)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "default");
+    }
+    if (ast.domainPreferences.length > 0) {
+      lines.push("## Domain preferences (beyond engineering)");
+      lines.push("");
+      lines.push("| Domain | Skills to delegate to | Notes / ceiling |");
+      lines.push("|---|---|---|");
+      for (const pref of ast.domainPreferences) {
+        const skills = pref.skills.length > 0 ? pref.skills.map((s) => `\`${s}\``).join(", ") : "*(in-skill default)*";
+        const notesParts = [];
+        if (pref.ceiling) notesParts.push(`Ceiling: ${pref.ceiling}`);
+        if (pref.notes) notesParts.push(pref.notes);
+        const notes = notesParts.join("; ") || "";
+        lines.push(`| **${pref.domain}** | ${skills} | ${notes} |`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "domain_preference");
+    }
+    this.appendTrackBAuthority(lines, ast);
+    this.appendProseAfter(lines, ast, "authority");
+    this.appendPapersProgramDefaults(lines, ast);
+    this.appendProseAfter(lines, ast, "editorial_default");
+    this.appendProseAfter(lines, ast, "research_default");
+    if (ast.outputShape) {
+      lines.push("## Output shape \u2014 SILENT-TO-JOSEPH, LOUD-TO-THE-AGENT");
+      lines.push("");
+      lines.push(`- **Silent to**: ${ast.outputShape.silentTo}`);
+      lines.push(`- **Loud to**: ${ast.outputShape.loudTo}`);
+      if (ast.outputShape.noMetaOutput) {
+        lines.push("- **No meta-output**: do not narrate the protocol back to the user");
+      }
+      if (ast.outputShape.surfaceHint) {
+        lines.push(`- **Surface hint**: ${ast.outputShape.surfaceHint}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "output_shape");
+    }
+    if (ast.productionRule) {
+      lines.push("## Production-only rule (no dev, no mock, no localhost)");
+      lines.push("");
+      if (ast.productionRule.noDevNoMockNoLocalhost) {
+        lines.push("No dev. No mock. No localhost. The real service exists - hit it.");
+      }
+      if (ast.productionRule.exception) {
+        lines.push("");
+        lines.push(`**Exception**: ${ast.productionRule.exception}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "production_rule");
+    }
+    if (ast.hardPhysicalGaps.length > 0) {
+      lines.push("## Hard physical gaps (skill never absorbs)");
+      lines.push("");
+      for (const gap of ast.hardPhysicalGaps) {
+        lines.push(`- **${gap.name}** - ${gap.reason}`);
+        if (gap.alternative) {
+          lines.push(`  - Alternative: ${gap.alternative}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "hard_physical_gap");
+    }
+    if (ast.skills.length > 0) {
+      lines.push("## Skills this skill cross-references");
+      lines.push("");
+      for (const skill of ast.skills) {
+        lines.push(`### \`${skill.invocableAs}\` - ${skill.name}`);
+        lines.push("");
+        lines.push(`**Authority**: ${skill.authority}`);
+        lines.push("");
+        if (skill.authoritativeFor.length > 0) {
+          lines.push(`**Authoritative for**: ${skill.authoritativeFor.join(", ")}`);
+          lines.push("");
+        }
+        if (skill.refusals && skill.refusals.length > 0) {
+          lines.push(`**Refusals enforced**: ${skill.refusals.join(", ")}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "skill");
+    }
+    if (ast.invocationModes.length > 0) {
+      lines.push("## Invocation modes (Track D)");
+      lines.push("");
+      for (const mode of ast.invocationModes) {
+        lines.push(`### ${mode.mode}`);
+        lines.push("");
+        lines.push(`- **When**: ${mode.when}`);
+        lines.push(`- **Effect**: ${mode.effect}`);
+        if (mode.example) {
+          lines.push(`- **Example**: \`${mode.example}\``);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "invocation_mode");
+    }
+    appendEmbodiedProjectionSection(lines, ast.embodiedProjections);
+    this.appendProseAfter(lines, ast, "embodied_projection");
+    if (ast.routines.length > 0) {
+      lines.push("## Recurring routines (A-00X)");
+      lines.push("");
+      lines.push(`| ID | Schedule | Skill | Output |`);
+      lines.push(`|---|---|---|---|`);
+      for (const routine of ast.routines) {
+        lines.push(
+          `| ${routine.id} | \`${routine.schedule}\` | ${routine.skill} | ${routine.outputDir ?? "*(varies)*"} |`
+        );
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "routine");
+    }
+    if (ast.escalations.length > 0) {
+      lines.push("## Escape hatch");
+      lines.push("");
+      for (const esc of ast.escalations) {
+        lines.push(`- **Trigger**: ${esc.trigger}`);
+        lines.push(`  - **Action**: ${esc.doAction}`);
+        lines.push(`  - **Recipient**: ${esc.recipient}`);
+        if (esc.refuseToEscalateWhen.length > 0) {
+          lines.push(
+            `  - **Refuse to escalate when**: ${esc.refuseToEscalateWhen.join(", ")}`
+          );
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "escalation");
+    }
+    if (ast.dateDisciplines.length > 0) {
+      const firstWisdom = ast.dateDisciplines[0]?.wisdomId;
+      const wisdomSuffix = ast.dateDisciplines.length === 1 && firstWisdom ? ` (${firstWisdom})` : "";
+      lines.push(`## Date discipline${wisdomSuffix}`);
+      lines.push("");
+      for (const d of ast.dateDisciplines) {
+        const wisdomLabel = d.wisdomId ? ` (${d.wisdomId})` : "";
+        lines.push(`### Refusal contract${wisdomLabel}`);
+        lines.push("");
+        lines.push(`**${d.refusalContract}**`);
+        lines.push("");
+        if (d.requiredComponents.length > 0) {
+          lines.push("**Required components** (all must be present):");
+          for (const comp of d.requiredComponents) {
+            lines.push(`- ${comp}`);
+          }
+          lines.push("");
+        }
+        if (d.shapeTemplate) {
+          lines.push("**Output shape**:");
+          lines.push("");
+          lines.push("```");
+          lines.push(d.shapeTemplate);
+          lines.push("```");
+          lines.push("");
+        }
+        if (d.reason) {
+          lines.push(`**Reason**: ${d.reason}`);
+          lines.push("");
+        }
+        if (d.crossReferences && d.crossReferences.length > 0) {
+          lines.push(`**Cross-references**: ${d.crossReferences.join(", ")}`);
+          lines.push("");
+        }
+      }
+      this.appendProseAfter(lines, ast, "date_discipline");
+    }
+    if (ast.citationRules.length > 0) {
+      lines.push("## Citation discipline");
+      lines.push("");
+      for (const rule of ast.citationRules) {
+        lines.push(
+          `- Fluent prose over **${rule.fluentProseThresholdChars} chars** must include one of: ${rule.required.join(", ")}`
+        );
+        if (rule.exemption) {
+          lines.push(`  - Exemption: ${rule.exemption}`);
+        }
+        if (rule.reason) {
+          lines.push(`  - Reason: ${rule.reason}`);
+        }
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "citation_rule");
+    }
+    if (ast.graduatedWisdoms.length > 0 || ast.feedbacks.length > 0) {
+      lines.push("## Authority cross-references");
+      lines.push("");
+      if (ast.graduatedWisdoms.length > 0) {
+        lines.push("### GOLD-tier wisdom");
+        lines.push("");
+        for (const wisdom of ast.graduatedWisdoms) {
+          lines.push(`- **${wisdom.id}** *(${wisdom.tier})* - ${wisdom.claim}`);
+        }
+        lines.push("");
+      }
+      if (ast.feedbacks.length > 0) {
+        lines.push("### Feedback memory");
+        lines.push("");
+        for (const fb of ast.feedbacks) {
+          const src = fb.source ? ` (${fb.source})` : "";
+          lines.push(`- **${fb.id}**${src} - ${fb.claim}`);
+        }
+        lines.push("");
+      }
+      this.appendProseAfter(lines, ast, "graduated_wisdom");
+      this.appendProseAfter(lines, ast, "feedback");
+    }
+    if (ast.domainDispatches.length > 0) {
+      lines.push("## Domain \u2192 execution skill dispatch");
+      lines.push("");
+      lines.push(
+        "The engine rules with founder defaults, then delegates execution to the right skill:"
+      );
+      lines.push("");
+      lines.push("| Domain | Existing skills |");
+      lines.push("|---|---|");
+      for (const d of ast.domainDispatches) {
+        const skills = d.skills.length > 0 ? d.skills.map((s) => `\`${s}\``).join(", ") : "*(in-skill default)*";
+        lines.push(`| ${d.domain} | ${skills} |`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "domain_dispatch");
+    }
+    if (ast.corpusMutabilities.length > 0) {
+      lines.push("## Corpus mutability");
+      lines.push("");
+      for (const c of ast.corpusMutabilities) {
+        lines.push(`- **${c.policy}**: ${c.description}`);
+      }
+      lines.push("");
+      this.appendProseAfter(lines, ast, "corpus_mutability");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(
+      `*Generated by HoloScript ContextCompiler (compile_to_skill_md). Source: HoloScript composition. Vocabulary: v4 (2026-05-22). Phase 2(a) self-host target.*`
+    );
+    lines.push("");
+    return lines.join("\n");
+  }
+  appendTrackBAuthority(lines, ast) {
+    if (ast.trackBAuthorities.length === 0) {
+      return;
+    }
+    const renderRows = (heading, rows) => {
+      if (rows.length === 0) return;
+      lines.push(`### ${heading}`);
+      lines.push("");
+      lines.push("| Target | Action type | Requires | Founder ratification | Notes |");
+      lines.push("|---|---|---|---|---|");
+      for (const row of rows) {
+        const actionType = row.actionType ? `\`${mdTableCell(row.actionType)}\`` : "*(unspecified)*";
+        const requires = row.requires.length > 0 ? row.requires.map((r) => mdTableCell(r)).join("<br>") : "*(none)*";
+        const notes = row.notes ? mdTableCell(row.notes) : "";
+        lines.push(
+          `| ${mdTableCell(row.target)} | ${actionType} | ${requires} | ${row.founderRatificationRequired ? "Yes" : "No"} | ${notes} |`
+        );
+      }
+      lines.push("");
+    };
+    const mutableTargets = ast.trackBAuthorities.filter(
+      (row) => !row.founderRatificationRequired
+    );
+    const founderRatifiedTargets = ast.trackBAuthorities.filter(
+      (row) => row.founderRatificationRequired
+    );
+    lines.push("## Self-edit + tier-write authority (Track B)");
+    lines.push("");
+    lines.push(
+      "Every mutation requires backup-before-write, normal Edit/Write mutation, and append-only audit logging with a cited reason."
+    );
+    lines.push("");
+    renderRows("Mutable targets", mutableTargets);
+    renderRows("Founder-ratification-required targets", founderRatifiedTargets);
+  }
+  appendPapersProgramDefaults(lines, ast) {
+    if (ast.editorialDefaults.length === 0 && ast.researchDefaults.length === 0) {
+      return;
+    }
+    lines.push("## Papers program defaults");
+    lines.push("");
+    if (ast.editorialDefaults.length > 0) {
+      lines.push("### Editorial defaults");
+      lines.push("");
+      lines.push("| Scope | Question | Answer | Reason |");
+      lines.push("|---|---|---|---|");
+      for (const def of ast.editorialDefaults) {
+        lines.push(
+          `| ${this.formatPaperDefaultScope(def)} | ${def.when} | **${def.do}** | ${def.reason ?? "*(no citation)*"} |`
+        );
+      }
+      lines.push("");
+    }
+    if (ast.researchDefaults.length > 0) {
+      lines.push("### Research-decision defaults");
+      lines.push("");
+      lines.push("| Scope | Question | Answer | Reason |");
+      lines.push("|---|---|---|---|");
+      for (const def of ast.researchDefaults) {
+        lines.push(
+          `| ${this.formatPaperDefaultScope(def)} | ${def.when} | **${def.do}** | ${def.reason ?? "*(no citation)*"} |`
+        );
+      }
+      lines.push("");
+    }
+  }
+  formatPaperDefaultScope(def) {
+    const paperId = def.paperId?.trim();
+    const paperPhase = def.paperPhase?.trim();
+    if (paperId && paperPhase) return `${paperId} / ${paperPhase}`;
+    if (paperId) return paperId;
+    if (paperPhase) return paperPhase;
+    return "program-wide";
+  }
+  /**
+   * Emit @prose_after paragraphs for a given canonical trait name.
+   * Called after the structured rendering of each section so prose
+   * appears immediately after its target section in all emitters.
+   */
+  appendProseAfter(lines, ast, traitName) {
+    const prose = ast.proseAfters.filter((p) => p.trait === traitName);
+    for (const entry of prose) {
+      for (const paragraph of entry.paragraphs) {
+        lines.push(paragraph);
+      }
+      lines.push("");
+    }
+  }
+};
+var ContextCompileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContextCompileError";
+  }
+};
+function createContextCompiler(options) {
+  return new ContextCompiler(options);
+}
+function stringField(cfg, key, fallback) {
+  const v = cfg[key];
+  if (typeof v === "string") return v;
+  return fallback;
+}
+function stringFieldOrUndef(cfg, key) {
+  const v = cfg[key];
+  return typeof v === "string" ? v : void 0;
+}
+function numberField(cfg, key, fallback) {
+  const v = cfg[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function boolField(cfg, key, fallback) {
+  const v = cfg[key];
+  return typeof v === "boolean" ? v : fallback;
+}
+function mdTableCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/[\r\n]+/g, "<br>");
+}
+function yamlScalar(s) {
+  if (/^[A-Za-z][A-Za-z0-9_-]*$/.test(s) && !YAML_RESERVED.has(s.toLowerCase())) {
+    return s;
+  }
+  return JSON.stringify(s);
+}
+function formatYamlDescription(description) {
+  if (!description.includes("\n")) {
+    return `description: ${JSON.stringify(description)}`;
+  }
+  const lines = description.split("\n").map((line) => `  ${line}`);
+  return `description: >
+${lines.join("\n")}`;
+}
+var YAML_RESERVED = /* @__PURE__ */ new Set([
+  "yes",
+  "no",
+  "true",
+  "false",
+  "on",
+  "off",
+  "null",
+  "~"
+]);
+function stringListField(cfg, key) {
+  const v = cfg[key];
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "string");
+}
+function appendEmbodiedProjectionSection(lines, projections) {
+  if (projections.length === 0) return;
+  lines.push("## Embodied projections");
+  lines.push("");
+  for (const projection of projections) {
+    const surface = projection.surface || "unspecified-surface";
+    const kind = projection.projectionKind || "read-only";
+    lines.push(`### ${surface} / ${kind}`);
+    lines.push("");
+    lines.push(`- **Surface**: ${surface}`);
+    lines.push(`- **Projection kind**: ${kind}`);
+    if (projection.trigger) {
+      lines.push(`- **Trigger**: ${projection.trigger}`);
+    }
+    if (projection.notes) {
+      lines.push(`- **Notes**: ${projection.notes}`);
+    }
+    lines.push("");
+  }
+}
+function wrapMdc(description, bodyLines) {
+  const front = ["---", `description: ${description}`, "globs:", "alwaysApply: true", "---", ""];
+  return front.concat(bodyLines).join("\n");
+}
+function oneLine(s) {
+  return s.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function toCursorSlug(name) {
+  const base = name.toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]+/g, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+  if (base.length > 0) return base;
+  let h = 0;
+  for (let i = 0; i < name.length; i += 1) {
+    h = (h + name.charCodeAt(i)) % 1e6;
+  }
+  return `rule-${h.toString(36).padStart(4, "0")}`;
+}
+
+exports.ContextCompileError = ContextCompileError;
+exports.ContextCompiler = ContextCompiler;
+exports.createContextCompiler = createContextCompiler;
+//# sourceMappingURL=chunk-ZUL5AVTX.cjs.map
+//# sourceMappingURL=chunk-ZUL5AVTX.cjs.map