intentdna 1.9.0 → 1.9.3

package/dist/runtime/skill-adapter.js

@@ -1,14 +1,11 @@
 /**
- * Intent DNA — Skill Adapter
+ * Intent DNA - Skill Adapter
  *
- * Compiles DNA roles + workflow + genes into Claude Code skill files
- * (.claude/skills/<name>/SKILL.md).
- *
- * Skills are compiled views of DNA's structured definitions — not stored content.
+ * Generated Skills are transport launchers. Execution semantics live only in
+ * the canonical executable plan and durable run service.
  */
-import { mkdir, writeFile, readdir, readFile, rm } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
-import { getControllerKindMetadata } from "../schema/controller-registry.js";
 import { assertSafeGeneratedName, toKebabCase } from "./agent-md.js";
 import { resolveWorkflowVariableReferences, valueUsesArguments, workflowUsesArguments, } from "./workflow-runtime-manifest.js";
 const SENTINEL = "<!-- intentdna:managed — do not edit manually -->";
@@ -20,249 +17,53 @@ function resolveContainedPath(baseDir, ...segments) {
     }
     return target;
 }
-function isHumanRole(role) {
-    return role?.model?.trim().toLowerCase() === "human";
-}
-function isInteractiveRole(role) {
-    return role?.model?.trim().toLowerCase() === "interactive";
+export const CANONICAL_SKILL_RUN_REQUEST_SCHEMA_VERSION = "intentdna.skill_run_request.v1";
+function canonicalSkillRequest(kind, key, acceptsArgument, options) {
+    return {
+        schema_version: CANONICAL_SKILL_RUN_REQUEST_SCHEMA_VERSION,
+        dna_sources: options?.dnaSources?.length
+            ? [...options.dnaSources]
+            : [".dna/configs"],
+        target: { kind, key },
+        inputs: acceptsArgument
+            ? {
+                ARGUMENTS: "$ARGUMENTS",
+                arguments: "$ARGUMENTS",
+                task_id: "$ARGUMENTS",
+                workflow: key,
+            }
+            : { workflow: key },
+        input_policy: "declared_only",
+        max_concurrency: 1,
+    };
 }
-// ── Compile Controller → Skill ─────────────────────────────
-export function compileControllerToSkill(controllerKey, controller, variables, workflows) {
-    const controllerVariables = variables ? resolveWorkflowVariableReferences(variables) : undefined;
-    const kindMetadata = getControllerKindMetadata(controller.kind);
-    if (!kindMetadata?.supportsSkillGeneration) {
-        throw new Error(`Unsupported controller kind: ${controller.kind}`);
-    }
-    const diagnosisWorkflowName = controller.diagnosis_workflow;
-    const fixWorkflowName = controller.fix_workflow;
-    const diagnosisArtifactPath = controller.diagnosis_artifact_path;
-    const diagnosisReviewArtifactPath = controller.diagnosis_review_artifact_path;
-    const reviewArtifactPath = controller.review_artifact_path;
-    const analyzerRole = controller.roles.analyzer;
-    const analysisReviewerRole = controller.roles.analysis_reviewer;
-    const surgeonRole = controller.roles.surgeon;
-    const fixReviewerRole = controller.roles.fix_reviewer;
-    const testRunnerRole = controller.roles.test_runner;
-    if (!diagnosisWorkflowName ||
-        !fixWorkflowName ||
-        !diagnosisArtifactPath ||
-        !diagnosisReviewArtifactPath ||
-        !reviewArtifactPath ||
-        !analyzerRole ||
-        !analysisReviewerRole ||
-        !surgeonRole ||
-        !fixReviewerRole ||
-        !testRunnerRole) {
-        throw new Error(`Controller '${controllerKey}' is missing fix-loop skill generation fields`);
-    }
-    const skillName = `dna-${toKebabCase(controllerKey)}`;
-    assertSafeGeneratedName(skillName, "skill name");
-    const analyzerAgent = `dna-${toKebabCase(analyzerRole)}`;
-    const analysisReviewerAgent = `dna-${toKebabCase(analysisReviewerRole)}`;
-    const surgeonAgent = `dna-${toKebabCase(surgeonRole)}`;
-    const fixReviewerAgent = `dna-${toKebabCase(fixReviewerRole)}`;
-    const testRunnerAgent = `dna-${toKebabCase(testRunnerRole)}`;
-    const diagnosisWorkflow = workflows?.[diagnosisWorkflowName];
-    const fixWorkflow = workflows?.[fixWorkflowName];
-    const diagnosisAnalyzeStep = requireStepByRole(diagnosisWorkflow, analyzerRole, diagnosisWorkflowName);
-    const diagnosisReviewStep = requireStepByRole(diagnosisWorkflow, analysisReviewerRole, diagnosisWorkflowName);
-    const fixBugsStep = requireStepByRole(fixWorkflow, surgeonRole, fixWorkflowName);
-    const reviewChangesStep = requireStepByRole(fixWorkflow, fixReviewerRole, fixWorkflowName);
-    const verifyReportStep = requireStepByRole(fixWorkflow, testRunnerRole, fixWorkflowName);
-    const stepPrompt = (step) => step.prompt || step.description || "";
-    const policy = normalizeControllerPolicy(controller);
+function canonicalSkillBody(params) {
     const lines = [];
-    lines.push("---");
-    lines.push(`name: ${skillName}`);
-    lines.push(`description: "Use when user says /${skillName}. ${escapeYaml(controller.description || controller.name)}"`);
-    lines.push("user-invocable: true");
-    lines.push("triggers:");
-    lines.push(`  - "${toKebabCase(controllerKey)}"`);
-    lines.push(`  - "run ${toKebabCase(controllerKey)}"`);
-    lines.push("---");
-    lines.push("");
     lines.push(SENTINEL);
     lines.push(`<!-- Compiled: ${new Date().toISOString()} -->`);
     lines.push("");
-    lines.push(`# /${skillName} <module>`);
+    lines.push(`# /${params.skillName}${params.acceptsArgument ? " <argument>" : ""}`);
     lines.push("");
     lines.push("<Purpose>");
-    lines.push(controller.description || controller.name);
+    lines.push(params.description);
     lines.push("</Purpose>");
     lines.push("");
-    lines.push("<Controller>");
-    lines.push(`kind: ${controller.kind}`);
-    lines.push(`max_rounds: ${controller.max_rounds}`);
-    lines.push(`diagnosis_workflow: ${diagnosisWorkflowName}`);
-    lines.push(`fix_workflow: ${fixWorkflowName}`);
-    lines.push(`progress_artifact_path: ${controller.progress_artifact_path}`);
-    lines.push("</Controller>");
-    lines.push("");
-    lines.push("<Steps>");
-    lines.push("0. Validate the module argument before using it in any artifact path.");
-    lines.push("   - The module argument must match /^[A-Za-z0-9_-]+$/.");
-    lines.push("   - If it contains '/', '.', '..', spaces, braces, glob characters, or path separators, stop with the configured stop report.");
-    lines.push("   - Do not read or write controller artifacts until the module argument is safe.");
-    lines.push("1. Check diagnosis artifact freshness before any fix round.");
-    lines.push(`   - Diagnosis artifact: ${diagnosisArtifactPath}`);
-    lines.push(`   - Diagnosis review artifact: ${diagnosisReviewArtifactPath}`);
-    lines.push("2. Create a stable controller_run_id once for this invocation before using any artifact path.");
-    lines.push("   - Reuse the same controller_run_id in every child Agent prompt and in every progress validation.");
-    lines.push("   - Do not regenerate controller_run_id inside fix rounds.");
-    lines.push("3. Reuse the diagnosis artifact only when all diagnosis reuse criteria pass:");
-    for (const criterion of policy.diagnosis_reuse_criteria) {
-        lines.push(`   - ${criterion}`);
-    }
-    lines.push("   Reuse skips fresh analyzer and analysis_reviewer agents; it never skips the declared diagnosis contract completion gates or the persisted diagnosis review JSON approval gate before any surgeon step.");
-    lines.push(`4. If diagnosis is missing, invalid, stale, or scope-changed, run the analyzer once with fresh context:`);
-    lines.push("   a. Spawn fresh analyzer agent with controller_run_id, then wait for completion.");
-    lines.push("   ```");
-    lines.push("   Agent(");
-    lines.push(`     subagent_type="${analyzerAgent}",`);
-    lines.push(`     prompt="controller_run_id=<controller_run_id>. ${escapePrompt(stepPrompt(diagnosisAnalyzeStep))}"`);
-    lines.push("   )");
-    lines.push("   ```");
-    pushWorkflowStepVerifierLines(lines, diagnosisAnalyzeStep, "   ");
-    lines.push(`   b. Diagnosis artifact gate: read ${controller.diagnosis_artifact_path}; validate it exists, is non-empty, names the safe module argument, and is current for this module before continuing.`);
-    lines.push("   c. Spawn fresh analysis_reviewer agent with controller_run_id, then wait for completion.");
-    lines.push("   ```");
-    lines.push("   Agent(");
-    lines.push(`     subagent_type="${analysisReviewerAgent}",`);
-    lines.push(`     prompt="controller_run_id=<controller_run_id>; expected_review_artifact=${controller.diagnosis_review_artifact_path}. ${escapePrompt(stepPrompt(diagnosisReviewStep))}"`);
-    lines.push("   )");
-    lines.push("   ```");
-    pushWorkflowStepVerifierLines(lines, diagnosisReviewStep, "   ");
-    lines.push("5. If the diagnosis artifact was reused, do not spawn analyzer or analysis_reviewer; rerun the declared diagnosis contract completion gates against the existing artifacts:");
-    pushWorkflowStepVerifierLines(lines, diagnosisReviewStep, "   ");
-    lines.push(`6. Diagnosis review JSON gate: read ${controller.diagnosis_review_artifact_path}; require existing valid JSON with verdict APPROVE before fix rounds.`);
-    lines.push("   If the review JSON is missing, invalid, or verdict is not APPROVE, stop immediately with the configured stop report; do NOT enter fix rounds.");
-    lines.push(`7. For round 1..${controller.max_rounds}, set current_round to the loop number and run one fresh context fix round with sequential gates:`);
-    lines.push("   a. Spawn fresh surgeon agent with controller_run_id and current_round, then wait for completion.");
-    lines.push("   ```");
-    lines.push("   Agent(");
-    lines.push(`     subagent_type="${surgeonAgent}",`);
-    lines.push(`     prompt="controller_run_id=<controller_run_id>; current_round=<current_round>. Fresh context round for $ARGUMENTS. ${escapePrompt(stepPrompt(fixBugsStep))}"`);
-    lines.push("   )");
-    lines.push("   ```");
-    pushWorkflowStepVerifierLines(lines, fixBugsStep, "   ");
-    lines.push("   b. Fix handoff gate: validate the current round handoff and fix commit, or an explicit no-commit handoff for current_round, before review.");
-    lines.push("   c. Spawn fresh fix_reviewer agent with controller_run_id, current_round, and expected review artifact path, then wait for completion.");
-    lines.push("   ```");
-    lines.push("   Agent(");
-    lines.push(`     subagent_type="${fixReviewerAgent}",`);
-    lines.push(`     prompt="controller_run_id=<controller_run_id>; current_round=<current_round>; expected_review_artifact=${controller.review_artifact_path}. Fresh context review for $ARGUMENTS. ${escapePrompt(stepPrompt(reviewChangesStep))}"`);
-    lines.push("   )");
-    lines.push("   ```");
-    pushWorkflowStepVerifierLines(lines, reviewChangesStep, "   ");
-    lines.push(`   d. Review JSON gate: read ${controller.review_artifact_path}; validate it exists, is valid JSON, module equals the safe module argument, round equals the provided current_round, run_id equals the provided controller_run_id, updated_at is present, and verdict is APPROVE or REQUEST_CHANGES before verification.`);
-    lines.push("   e. Spawn fresh test_runner agent only after the review gate passes; include controller_run_id and current_round, then wait for completion.");
-    lines.push("   ```");
-    lines.push("   Agent(");
-    lines.push(`     subagent_type="${testRunnerAgent}",`);
-    lines.push(`     prompt="controller_run_id=<controller_run_id>; current_round=<current_round>. Fresh context verification for $ARGUMENTS. The progress JSON run_id must equal the provided controller_run_id and round must equal the provided current_round; do not use manual-run during controller execution. ${escapePrompt(stepPrompt(verifyReportStep))}"`);
-    lines.push("   )");
-    lines.push("   ```");
-    pushWorkflowStepVerifierLines(lines, verifyReportStep, "   ");
-    lines.push(`   f. Progress JSON read/provenance validation: read ${controller.progress_artifact_path}. The controller must read this JSON sidecar, not Markdown prose.`);
-    lines.push("   g. Verify progress JSON provenance before branching:");
-    for (const check of policy.progress_provenance_checks) {
-        lines.push(`      - ${check}`);
-    }
-    lines.push(`      - ${policy.progress_provenance_failure}`);
-    lines.push("   h. Branch only from the JSON verdict:");
-    for (const branch of policy.verdict_branches) {
-        lines.push(`      - ${branch}`);
-    }
-    lines.push(`8. If max ${controller.max_rounds} rounds is reached, stop with the configured stop report.`);
-    lines.push("</Steps>");
-    lines.push("");
-    lines.push("<Verdict_Mapping>");
-    for (const line of policy.verdict_mapping) {
-        lines.push(line);
-    }
-    lines.push("</Verdict_Mapping>");
-    lines.push("");
-    lines.push("<Stop_Report>");
-    lines.push("Every critical decision in the stop report must cite at least one verifier result_id, trace_id, or ArtifactManifest artifact id; prose-only claims are not sufficient.");
-    for (const line of policy.stop_report) {
-        lines.push(line);
-    }
-    lines.push("</Stop_Report>");
+    lines.push("<Canonical_Run_Request>");
+    lines.push(JSON.stringify(params.request, null, 2));
+    lines.push("</Canonical_Run_Request>");
     lines.push("");
-    lines.push("<Constraints>");
-    for (const constraint of policy.constraints) {
-        lines.push(`- ${constraint}`);
-    }
-    lines.push("</Constraints>");
+    lines.push("<Execution>");
+    lines.push("Execution authority belongs only to the canonical runtime plan and durable ledger.");
+    lines.push(params.acceptsArgument
+        ? "Replace the literal $ARGUMENTS values in the request with the invocation argument, then call `dna_run_start` exactly once unless this invocation already has a durable run_id."
+        : "Call `dna_run_start` with the request exactly once unless this invocation already has a durable run_id.");
+    lines.push("Keep the returned run_id. Use `dna_run_next` to obtain the next opaque runtime action; never infer execution order or domain transitions from this Skill text.");
+    lines.push("When the runtime returns an attempt, execute only its returned packet through the harness worker surface and use `dna_attempt_attach`, `dna_attempt_heartbeat`, and `dna_attempt_submit` with the returned durable identities.");
+    lines.push("When the runtime returns wait, preserve the run_id and report that the run is resumable. When it returns a terminal state, report the durable terminal reason and result references.");
+    lines.push("If a required harness capability is unavailable, preserve the typed unsupported result. Do not emulate the missing capability or fall back to prose scheduling.");
+    lines.push("</Execution>");
     lines.push("");
-    let content = lines.join("\n") + "\n";
-    if (controllerVariables) {
-        for (const [key, value] of Object.entries(controllerVariables)) {
-            content = content.replaceAll(`{{${key}}}`, value);
-        }
-    }
-    const dirName = skillName;
-    const fileName = join(dirName, "SKILL.md");
-    return attachSkillBody({ name: skillName, fileName, dirName, content }, {
-        description: controller.description || controller.name,
-        triggers: [toKebabCase(controllerKey), `run ${toKebabCase(controllerKey)}`],
-        kind: "controller",
-        mapEntry: {
-            name: skillName,
-            dirName,
-            source: controllerKey,
-            kind: "controller",
-            bodyPath: join(dirName, "skill-bodies", "body.md"),
-            roles: Object.values(controller.roles),
-            consumes: [
-                { step_id: "controller", type: "file", path: controller.diagnosis_artifact_path, description: "Diagnosis artifact" },
-                { step_id: "controller", type: "file", path: controller.diagnosis_review_artifact_path, description: "Diagnosis review artifact" },
-                { step_id: "controller", type: "file", path: controller.review_artifact_path, description: "Fix review artifact" },
-                { step_id: "controller", type: "file", path: controller.progress_artifact_path, description: "Progress JSON artifact" },
-            ],
-            produces: [
-                { step_id: "controller", type: "file", path: controller.progress_artifact_path, description: "Progress JSON artifact" },
-            ],
-        },
-    });
-}
-function requireStepByRole(workflow, role, workflowName) {
-    const step = workflow?.steps.find((candidate) => candidate.role === role);
-    if (!step) {
-        throw new Error(`Controller workflow '${workflowName}' must include a step for role '${role}'`);
-    }
-    return step;
-}
-function pushWorkflowStepVerifierLines(lines, step, indent) {
-    if (step.completion?.length) {
-        lines.push(`${indent}Completion gates for workflow step '${step.id}' must pass in declaration order before treating the step as complete:`);
-        for (let i = 0; i < step.completion.length; i++) {
-            lines.push(`${indent}   ${i + 1}. ${describeCompletionCheck(step.completion[i])}`);
-        }
-    }
-    if (step.checkpoints?.length) {
-        lines.push(`${indent}Checkpoint gates for workflow step '${step.id}' must pass in declaration order before transitioning:`);
-        for (let i = 0; i < step.checkpoints.length; i++) {
-            const checkpoint = step.checkpoints[i];
-            const action = checkpoint.action ?? "block";
-            const command = checkpoint.command ? `; command: ${checkpoint.command}` : "";
-            lines.push(`${indent}   ${i + 1}. ${checkpoint.assert}: ${checkpoint.message} (${action}${command})`);
-        }
-    }
-    if (step.completion?.some((check) => check.command_success) || step.checkpoints?.some((check) => check.command)) {
-        lines.push(`${indent}Command-backed completion/checkpoint gates must use runtime verifier_policy semantics: first authorize the declared raw command against exact allow_commands or allow_command_prefixes, then resolve templates safely, execute the exact resolved command, require exit code 0 for pass, treat policy denial as exit_code=126, and treat any non-zero exit code as blocking failure unless the checkpoint action is warn.`);
-    }
-}
-function describeCompletionCheck(check) {
-    if (check.file_exists)
-        return `file_exists: ${check.file_exists}`;
-    if (check.file_not_empty)
-        return `file_not_empty: ${check.file_not_empty}`;
-    if (check.file_contains)
-        return `file_contains: ${check.file_contains.path} matches ${check.file_contains.pattern}`;
-    if (check.command_success)
-        return `command_success: execute exact command "${check.command_success}", require exit code 0, and block on any non-zero exit code`;
-    return "invalid completion check: exactly one completion check field is required";
+    return lines.join("\n");
 }
 function createSkillLauncher(params) {
     const lines = [];
@@ -271,8 +72,9 @@ function createSkillLauncher(params) {
     lines.push(`description: "Use when user says /${params.skillName}. ${escapeYaml(params.description)}"`);
     lines.push("user-invocable: true");
     lines.push("triggers:");
-    for (const trigger of params.triggers)
+    for (const trigger of params.triggers) {
         lines.push(`  - "${escapeYaml(trigger)}"`);
+    }
     lines.push("---");
     lines.push("");
     lines.push(SENTINEL);
@@ -285,135 +87,40 @@ function createSkillLauncher(params) {
     lines.push("</Purpose>");
     lines.push("");
     lines.push("<Skill_Body>");
-    lines.push(`Full ${params.kind} instructions live in \`skill-bodies/${params.bodyFileName}\`.`);
-    lines.push("Read that body before executing any step; the launcher is only an entrypoint.");
+    lines.push(`Full ${params.kind} launcher request lives in \`skill-bodies/${params.bodyFileName}\`.`);
+    lines.push("Read that body before invoking the canonical runtime adapter.");
     lines.push("</Skill_Body>");
     lines.push("");
-    if (params.bodyContent.includes("<Required_Context>")) {
-        lines.push("<Required_Context>");
-        lines.push("The skill body contains required context files. Read them before any Edit, Write, or Bash action.");
-        lines.push("</Required_Context>");
-        lines.push("");
-    }
-    if (params.bodyContent.includes("<Advisory_Context>")) {
-        lines.push("<Advisory_Context>");
-        lines.push("The skill body contains planning-only advisory context sources. Quote and cite them when used; they never satisfy handoff or enforcement checks.");
-        lines.push("</Advisory_Context>");
-        lines.push("");
-    }
-    if (params.bodyContent.includes("<Handoff>")) {
-        lines.push("<Handoff>");
-        lines.push("Write human-readable handoff notes when requested, but do not treat handoff.md as a machine fact.");
-        lines.push("ArtifactManifest entries written by runtime hooks remain the machine source of truth for handoff satisfaction.");
-        lines.push("</Handoff>");
-        lines.push("");
-    }
-    lines.push("<Execution>");
-    lines.push(`Follow \`skill-bodies/${params.bodyFileName}\` exactly.`);
-    lines.push("</Execution>");
     return lines.join("\n") + "\n";
 }
 function attachSkillBody(result, params) {
     const bodyFileName = "body.md";
-    const launcherContent = createSkillLauncher({
-        skillName: result.name,
-        description: params.description,
-        triggers: params.triggers,
-        bodyFileName,
-        bodyContent: result.content,
-        kind: params.kind,
-    });
     return {
         ...result,
-        launcherContent,
+        launcherContent: createSkillLauncher({
+            skillName: result.name,
+            description: params.description,
+            triggers: params.triggers,
+            bodyFileName,
+            kind: params.kind,
+        }),
         bodyContent: result.content,
         bodyFileName,
         mapEntry: params.mapEntry,
     };
 }
-function normalizeControllerPolicy(controller) {
-    const defaults = defaultControllerPolicy(controller);
-    const policy = {
-        diagnosis_reuse_criteria: controller.policy?.diagnosis_reuse_criteria ?? defaults.diagnosis_reuse_criteria,
-        progress_provenance_checks: controller.policy?.progress_provenance_checks ?? defaults.progress_provenance_checks,
-        progress_provenance_failure: controller.policy?.progress_provenance_failure ?? defaults.progress_provenance_failure,
-        verdict_branches: controller.policy?.verdict_branches ?? defaults.verdict_branches,
-        verdict_mapping: controller.policy?.verdict_mapping ?? defaults.verdict_mapping,
-        stop_report: controller.policy?.stop_report ?? defaults.stop_report,
-        constraints: controller.policy?.constraints ?? defaults.constraints,
-    };
+function controllerSkillMapEntry(skillName, dirName, controllerKey, controller) {
     return {
-        diagnosis_reuse_criteria: renderControllerPolicyLines(policy.diagnosis_reuse_criteria, controller),
-        progress_provenance_checks: renderControllerPolicyLines(policy.progress_provenance_checks, controller),
-        progress_provenance_failure: renderControllerPolicyText(policy.progress_provenance_failure, controller),
-        verdict_branches: renderControllerPolicyLines(policy.verdict_branches, controller),
-        verdict_mapping: renderControllerPolicyLines(policy.verdict_mapping, controller),
-        stop_report: renderControllerPolicyLines(policy.stop_report, controller),
-        constraints: renderControllerPolicyLines(policy.constraints, controller),
-    };
-}
-function renderControllerPolicyLines(lines, controller) {
-    return lines.map((line) => renderControllerPolicyText(line, controller));
-}
-function renderControllerPolicyText(text, controller) {
-    const replacements = {
-        "$progress_artifact_path": controller.progress_artifact_path,
-        "$diagnosis_artifact_path": controller.diagnosis_artifact_path ?? "",
-        "$diagnosis_review_artifact_path": controller.diagnosis_review_artifact_path ?? "",
-        "$review_artifact_path": controller.review_artifact_path ?? "",
-    };
-    let rendered = text;
-    for (const [token, value] of Object.entries(replacements)) {
-        rendered = rendered.replaceAll(token, value);
-    }
-    return rendered;
-}
-function defaultControllerPolicy(controller) {
-    return {
-        diagnosis_reuse_criteria: [
-            `${controller.diagnosis_artifact_path} exists`,
-            `${controller.diagnosis_review_artifact_path} exists and verdict is APPROVE`,
-            "the user did not explicitly request reanalysis",
-            "progress JSON does not invalidate the diagnosis",
-        ],
-        progress_provenance_checks: [
-            "module equals the safe module argument",
-            "round equals the provided current_round",
-            "run_id equals the provided controller_run_id",
-            `diagnosis_artifact equals ${controller.diagnosis_artifact_path}`,
-            `review_artifact equals ${controller.review_artifact_path}`,
-            "git_head or last_fix_commit references the current round's fix commit when available",
-            "updated_at is not earlier than the current round start time",
-        ],
-        progress_provenance_failure: "if provenance is missing, stale, or mismatched, stop with Verdict BLOCKED and failure_reason PROGRESS_PROVENANCE_MISMATCH",
-        verdict_branches: [
-            "PASS -> success stop",
-            "CONTINUE -> next fresh context fix round",
-            "REQUEST_CHANGES -> stop with the configured stop report",
-            "BLOCKED -> stop with the configured stop report",
-        ],
-        verdict_mapping: [
-            "PASS / CONTINUE / REQUEST_CHANGES / BLOCKED mapping:",
-            "- PASS: success stop",
-            "- CONTINUE: start the next fresh context round",
-            "- REQUEST_CHANGES: stop and report the requested changes",
-            "- BLOCKED: stop and report the blocker",
-            "- MAX_ROUNDS: stop and report max rounds reached",
-        ],
-        stop_report: [
-            "On REQUEST_CHANGES, BLOCKED, or MAX_ROUNDS, explain the stop reason, the evidence, the next action, and cite at least one verifier result_id, trace_id, or ArtifactManifest artifact id.",
-        ],
-        constraints: [
-            `The controller must schedule only from ${controller.progress_artifact_path}.`,
-            "Branch only from the progress JSON verdict.",
-        ],
+        name: skillName,
+        dirName,
+        source: controllerKey,
+        kind: "controller",
+        bodyPath: `${dirName}/skill-bodies/body.md`,
+        roles: Object.values(controller.roles),
+        consumes: [],
+        produces: [],
     };
 }
-// ── Compile Workflow → Skill ───────────────────────────────
-/**
- * Compile a WorkflowPlan + roles + IR into a SKILL.md file.
- * Variables from DNA config are substituted into prompts and descriptions.
- */
 function workflowSkillMapEntry(skillName, dirName, plan) {
     const consumes = [];
     const produces = [];
@@ -444,399 +151,58 @@ function workflowSkillMapEntry(skillName, dirName, plan) {
         dirName,
         source: plan.workflow_key ?? plan.source_workflow,
         kind: "workflow",
-        bodyPath: join(dirName, "skill-bodies", "body.md"),
+        bodyPath: `${dirName}/skill-bodies/body.md`,
         roles: [...new Set(plan.steps.map((step) => step.role))],
         consumes,
         produces,
     };
 }
+export function compileControllerToSkill(controllerKey, controller, _variables, _workflows, options) {
+    const skillName = `dna-${toKebabCase(controllerKey)}`;
+    assertSafeGeneratedName(skillName, "skill name");
+    const description = controller.description || controller.name;
+    const dirName = skillName;
+    const content = canonicalSkillBody({
+        skillName,
+        description,
+        request: canonicalSkillRequest("controller", controllerKey, true, options),
+        acceptsArgument: true,
+    });
+    return attachSkillBody({ name: skillName, fileName: join(dirName, "SKILL.md"), dirName, content }, {
+        description,
+        triggers: [toKebabCase(controllerKey), `run ${toKebabCase(controllerKey)}`],
+        kind: "controller",
+        mapEntry: controllerSkillMapEntry(skillName, dirName, controllerKey, controller),
+    });
+}
 export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
-    const lines = [];
     const skillName = `dna-${toKebabCase(plan.name)}`;
-    const surface = options?.surface ?? "claude_code";
-    const workflowId = plan.workflow_key ?? plan.source_workflow;
-    const skillVariables = variables ? resolveWorkflowVariableReferences(variables) : undefined;
-    const workflowVerifierSpecs = ir?.verifier_specs?.filter((spec) => spec.workflow_name === workflowId) ?? [];
+    assertSafeGeneratedName(skillName, "skill name");
+    const description = plan.description || plan.name;
+    const workflowKey = plan.workflow_key ?? plan.source_workflow;
+    const skillVariables = variables
+        ? resolveWorkflowVariableReferences(variables)
+        : undefined;
+    const workflowVerifierSpecs = ir?.verifier_specs?.filter((spec) => spec.workflow_name === workflowKey) ?? [];
     const rolePostChecks = [...new Set(plan.steps.map((step) => step.role))]
         .flatMap((roleName) => roles[roleName]?.post_checks ?? []);
-    const usesArguments = workflowUsesArguments(plan, skillVariables) ||
-        valueUsesArguments(workflowVerifierSpecs, skillVariables) ||
-        valueUsesArguments(rolePostChecks, skillVariables);
-    assertSafeGeneratedName(skillName, "skill name");
-    // Frontmatter
-    lines.push("---");
-    lines.push(`name: ${skillName}`);
-    lines.push(`description: "Use when user says /${skillName}. ${escapeYaml(plan.description || plan.name)}"`);
-    lines.push("user-invocable: true");
-    lines.push("triggers:");
-    lines.push(`  - "${plan.name}"`);
-    lines.push(`  - "run ${plan.name}"`);
-    lines.push("---");
-    lines.push("");
-    // Sentinel
-    lines.push(SENTINEL);
-    lines.push(`<!-- Compiled: ${new Date().toISOString()} -->`);
-    lines.push("");
-    // Title
-    lines.push(`# /${skillName}${usesArguments ? " <argument>" : ""}`);
-    lines.push("");
-    // Purpose
-    if (plan.description) {
-        lines.push("<Purpose>");
-        lines.push(plan.description);
-        lines.push("</Purpose>");
-        lines.push("");
-    }
-    lines.push("<Workflow_State>");
-    lines.push("At workflow start, call the MCP tool `dna_workflow_write` before any step or hook-triggering action so hook verifier evidence is attributed to this workflow instead of `*:direct`.");
-    lines.push(`Use workflow id \`${workflowId}\`.`);
-    lines.push("The MCP server initializes workflow_asset and resolved_variables from the compiled workflow runtime manifest. Do not submit either field from Skill text.");
-    const firstStep = plan.steps[0];
-    lines.push(`Initial state write: workflow=${workflowId}, current_step=${firstStep.id}, current_role=${firstStep.role}, iteration=1, active=true.`);
-    if (usesArguments) {
-        lines.push("Record the invocation argument as inputs.ARGUMENTS so handoff artifact paths like $ARGUMENTS can be resolved deterministically.");
-    }
-    else {
-        lines.push("This workflow has no invocation argument; omit inputs.ARGUMENTS from workflow state.");
-    }
-    lines.push(`Before each workflow step, call \`dna_workflow_write\` again with workflow, current_step, current_role, iteration, active=true${usesArguments ? ", and inputs.ARGUMENTS" : ""}.`);
-    lines.push("At workflow completion or terminal failure, call `dna_workflow_write` with active=false using the same workflow id.");
-    lines.push("</Workflow_State>");
-    lines.push("");
-    // Required Context — context files that must be read before any work
-    const workflowKeys = [plan.workflow_key, plan.source_workflow, plan.name].filter((key, index, keys) => Boolean(key) && keys.indexOf(key) === index);
-    const requiredReadAssets = [];
-    if (ir?.legibility_assets) {
-        const assets = ir.legibility_assets;
-        for (const asset of assets.mandatory ?? []) {
-            if (asset.type === "required_read" && !requiredReadAssets.includes(asset.path))
-                requiredReadAssets.push(asset.path);
-        }
-        for (const workflowKey of workflowKeys) {
-            for (const asset of assets.per_workflow?.[workflowKey] ?? []) {
-                if (asset.type === "required_read" && !requiredReadAssets.includes(asset.path))
-                    requiredReadAssets.push(asset.path);
-            }
-        }
-        for (const step of plan.steps) {
-            for (const asset of assets.per_role?.[step.role] ?? []) {
-                if (asset.type === "required_read" && !requiredReadAssets.includes(asset.path))
-                    requiredReadAssets.push(asset.path);
-            }
-        }
-    }
-    const contextFiles = requiredReadAssets.length > 0 ? requiredReadAssets : (() => {
-        if (!ir?.context_files)
-            return [];
-        const files = [];
-        if (ir.context_files.mandatory)
-            files.push(...ir.context_files.mandatory);
-        for (const workflowKey of workflowKeys) {
-            const workflowFiles = ir.context_files.per_workflow?.[workflowKey] ?? [];
-            for (const file of workflowFiles) {
-                if (!files.includes(file))
-                    files.push(file);
-            }
-        }
-        if (ir.context_files.per_role) {
-            for (const step of plan.steps) {
-                const roleFiles = ir.context_files.per_role[step.role];
-                if (roleFiles) {
-                    for (const f of roleFiles) {
-                        if (!files.includes(f))
-                            files.push(f);
-                    }
-                }
-            }
-        }
-        return files;
-    })();
-    if (contextFiles.length > 0) {
-        lines.push("<Required_Context>");
-        lines.push("Your context is EMPTY at startup. You MUST read these files first:");
-        lines.push("");
-        for (let i = 0; i < contextFiles.length; i++) {
-            lines.push(`${i + 1}. ${contextFiles[i]}`);
-        }
-        lines.push("");
-        lines.push("Without reading these, you cannot perform your role.");
-        lines.push("Hook will warn on first Edit/Bash/Write until these are read.");
-        lines.push("</Required_Context>");
-        lines.push("");
-    }
-    if (ir?.context_sources?.length) {
-        lines.push("<Advisory_Context>");
-        lines.push("These sources are planning-only references. They do not satisfy ArtifactManifest, handoff consumes, completion checks, or enforcement facts.");
-        lines.push("If you use them, quote the relevant passage and cite the source id.");
-        lines.push("");
-        for (const source of ir.context_sources) {
-            const locator = source.path ?? source.url ?? "(no locator)";
-            const title = source.title ? ` — ${source.title}` : "";
-            lines.push(`- ${source.id}: ${source.type} ${locator}${title}`);
-        }
-        for (const instruction of ir.planning_context?.instructions ?? []) {
-            lines.push(`- Planning instruction: ${instruction}`);
-        }
-        lines.push("</Advisory_Context>");
-        lines.push("");
-    }
-    // Steps — agent-owned steps are delegated; human-owned steps stay in the main session.
-    const usedRoles = new Set(plan.steps.map((s) => s.role));
-    const hasHumanSteps = plan.steps.some((step) => isHumanRole(roles[step.role]));
-    const hasInteractiveSteps = plan.steps.some((step) => isInteractiveRole(roles[step.role]));
-    // Pre-compute handoff targets: steps that are pointed to by another step's handoff_to
-    const handoffTargets = new Set();
-    for (const step of plan.steps) {
-        if (step.handoff_to)
-            handoffTargets.add(step.handoff_to);
-    }
-    lines.push("<Steps>");
-    let stepNumber = 0;
-    for (let i = 0; i < plan.parallel_groups.length; i++) {
-        const group = plan.parallel_groups[i];
-        for (const stepId of group.step_ids) {
-            stepNumber++;
-            const step = plan.steps.find((s) => s.id === stepId);
-            const agentType = `dna-${toKebabCase(step.role)}`;
-            const humanOwned = isHumanRole(roles[step.role]);
-            const interactiveOwned = isInteractiveRole(roles[step.role]);
-            const runIf = step.run_if ? `\n   **Condition**: ${step.run_if}` : "";
-            const optional = step.optional ? " (optional)" : "";
-            // Build agent prompt: anti-recursion + role identity + task
-            const promptParts = [
-                "Do NOT spawn sub-agents.",
-                `You are the ${agentType} agent.`,
-            ];
-            // Reflection gate: inject Previous_Attempts for handoff target steps
-            if (handoffTargets.has(step.id)) {
-                promptParts.push("<Previous_Attempts>\\n" +
-                    "If this is not the first round, the workflow state contains an experience_chain " +
-                    "with previous analysis, what surgeon tried, results, and lessons learned. " +
-                    "Read the experience chain from workflow state before analyzing. " +
-                    "DO NOT repeat approaches that already failed.\\n" +
-                    "</Previous_Attempts>");
-            }
-            // Reflection gate: inject Failed_Approaches for steps with max_attempts + handoff_to
-            if (step.max_attempts && step.handoff_to) {
-                promptParts.push("<Failed_Approaches>\\n" +
-                    "If previous attempts exist in the experience chain, review what was tried " +
-                    "and why it failed. You MUST use a DIFFERENT approach.\\n" +
-                    "</Failed_Approaches>");
-            }
-            promptParts.push(step.prompt || step.description);
-            const agentPrompt = escapePrompt(promptParts.join(" "));
-            lines.push(`${stepNumber}. **${step.id}**${optional}`);
-            lines.push(`   ${step.description}${runIf}`);
-            lines.push(`   Before this step, call \`dna_workflow_write\` with workflow=${workflowId}, current_step=${step.id}, current_role=${step.role}, iteration=<current iteration>, active=true${usesArguments ? ", and inputs.ARGUMENTS" : ""}.`);
-            lines.push("");
-            if (humanOwned) {
-                lines.push("   **Human-owned gate (`model: human`)**");
-                lines.push(`   Ask the user in the main session: ${step.prompt || step.description}`);
-                lines.push("   Do not delegate this decision, infer approval, or continue from silence. Continue only after an explicit human response.");
-            }
-            else if (interactiveOwned) {
-                lines.push("   **Main-session external-agent step (`model: interactive`)**");
-                lines.push(`   Perform directly in the main session: ${step.prompt || step.description}`);
-                lines.push("   This step may interview the user or edit the candidate YAML inside its declared scope. Do not delegate away the conversation context.");
-            }
-            else if (surface === "codex_cli") {
-                lines.push("   Delegate to a Codex native subagent with this role contract; do not discard the role boundaries:");
-                lines.push("   ```text");
-                lines.push(`   role: ${agentType}`);
-                lines.push(`   prompt: ${agentPrompt}`);
-                lines.push("   ```");
-                lines.push("   Wait for the subagent to complete and read its output before proceeding.");
-            }
-            else {
-                lines.push(`   Execute with Agent tool — DO NOT perform this work yourself:`);
-                lines.push(`   \`\`\``);
-                lines.push(`   Agent(`);
-                lines.push(`     subagent_type="${agentType}",`);
-                lines.push(`     prompt="${agentPrompt}"`);
-                lines.push(`   )`);
-                lines.push(`   \`\`\``);
-                lines.push(`   Wait for agent to complete. Read the output before proceeding.`);
-            }
-            if (step.handoff?.produces && step.handoff.produces.length > 0) {
-                const artifacts = step.handoff.produces.map(p => p.description).join(", ");
-                lines.push(`   Verify produced artifacts: ${artifacts}`);
-            }
-            pushWorkflowStepVerifierLines(lines, step, "   ");
-            if (step.completion?.length || step.checkpoints?.length) {
-                lines.push("   If any completion/checkpoint gate fails, preserve the exact verifier diagnostics verbatim: id, check/assert or command, message, evidence, target/artifact, and exit_code when available.");
-                lines.push(`   Feed those exact diagnostics to ${step.on_fail === "retry_with_feedback" ? "this step's on_fail retry" : "the retry_from/on_fail step"} before any retry, reanalysis, or downstream transition.`);
-            }
-            lines.push("");
-            // Reflection gate: inject Reflection_Gate after steps with max_attempts
-            if (step.max_attempts) {
-                const handoffStep = step.handoff_to ?? "previous step";
-                const maxH = step.max_handoffs ?? 3;
-                const blockedPath = step.blocked_items_path ?? "blocked_items.md";
-                lines.push(`<Reflection_Gate>`);
-                lines.push(`max_attempts=${step.max_attempts}, handoff_to=${handoffStep}, max_handoffs=${maxH}`);
-                lines.push(`No declared completion progress after ${step.max_attempts} attempts → handoff to ${handoffStep} for re-analysis.`);
-                lines.push(`When the declared gates are test or no_test_regression gates, preserve the existing test-progress meaning as part of declared completion progress.`);
-                lines.push(`After ${maxH} handoffs with no declared completion progress → SKIP and record to ${blockedPath}.`);
-                lines.push(`</Reflection_Gate>`);
-                lines.push("");
-            }
-        }
-    }
-    lines.push("</Steps>");
-    lines.push("");
-    if (plan.retry.max_retries > 0) {
-        lines.push("<Retry_Policy>");
-        lines.push(`- max_retries: ${plan.retry.max_retries}`);
-        lines.push(`- retry_from: ${plan.retry.retry_from ?? "first_failed_step"}`);
-        lines.push(`- backoff: ${plan.retry.backoff}`);
-        lines.push("- On a blocking completion, checkpoint, or validator failure, preserve the exact diagnostics and return them verbatim to the retry_from/on_fail step.");
-        lines.push("- Exact diagnostics means every available id/result_id, check/assert or command, message, evidence, target/artifact, and exit_code. Do not paraphrase away failed paths, command output, or policy-denied exit codes.");
-        lines.push("- Retry prompts must include the prior failed step id, the declared gates that failed, and the exact verifier diagnostics before asking for another attempt.");
-        lines.push("- Repeat only the retry slice and its dependent steps; do not continue to save, adoption, or sync while validation is red.");
-        lines.push("- Stop and report the remaining diagnostics when the retry budget is exhausted.");
-        lines.push("</Retry_Policy>");
-        lines.push("");
-    }
-    // Execution Policy — force delegation while preserving explicit human gates.
-    lines.push("<Execution_Policy>");
-    if (surface === "codex_cli") {
-        lines.push("- **CRITICAL**: Delegate each delegated-agent step to a Codex native subagent using the specified role contract. Do not collapse distinct roles into an unreviewed single pass.");
-    }
-    else {
-        lines.push(hasHumanSteps || hasInteractiveSteps
-            ? "- **CRITICAL**: Each delegated-agent step MUST be executed by spawning an Agent using the Agent tool with the specified subagent_type. DO NOT perform delegated-agent work directly in the main session."
-            : "- **CRITICAL**: Each step MUST be executed by spawning an Agent using the Agent tool with the specified subagent_type. DO NOT perform any step's work directly in the main session.");
-    }
-    lines.push("- Use the task tracker to track each step only as pending/in_progress/completed; use deleted only for skipped dependent tasks.");
-    lines.push(hasHumanSteps
-        ? "- Proceed automatically between non-human steps, but stop at every `model: human` step and require an explicit user response before continuing."
-        : "- After completing each step, immediately proceed to the next — do not stop, summarize, or wait for confirmation.");
-    if (hasInteractiveSteps) {
-        lines.push("- Execute `model: interactive` steps in the main session so interview answers and candidate edits remain in the user-visible conversation.");
-    }
-    lines.push("- If a step cannot complete, do not use a failed status. Keep the current task in_progress or record the blocker in the task description/output, delete skipped dependent tasks, and continue only to non-dependent steps.");
-    lines.push(hasHumanSteps
-        ? "- Never auto-approve, delegate, or synthesize a human-owned decision."
-        : "- Do not ask the user for permission between steps — the workflow is pre-approved.");
-    lines.push("- Wait for each delegated agent to complete and read its output before proceeding to the next step.");
-    lines.push("</Execution_Policy>");
-    lines.push("");
-    // Tool_Usage — only if roles have permissions or scope
-    const toolUsageLines = [];
-    for (const roleName of usedRoles) {
-        const role = roles[roleName];
-        if (!role)
-            continue;
-        const allowed = role.tool_permissions?.allow?.join(", ") || "all";
-        const denied = role.tool_permissions?.deny?.join(", ") || "none";
-        const writeScope = role.scope?.write?.join(", ") || "none";
-        toolUsageLines.push(`### ${roleName}`);
-        toolUsageLines.push(`- Owner: ${isHumanRole(role) ? "human" : isInteractiveRole(role) ? "main_session_external_agent" : "delegated_agent"}`);
-        toolUsageLines.push(`- Description: ${role.description}`);
-        toolUsageLines.push(`- Allowed: ${allowed}`);
-        toolUsageLines.push(`- Denied: ${denied}`);
-        toolUsageLines.push(`- Write scope: ${writeScope}`);
-        for (const instruction of role.instructions ?? [])
-            toolUsageLines.push(`- Instruction: ${instruction}`);
-        for (const criterion of role.success_criteria ?? [])
-            toolUsageLines.push(`- Success criterion: ${criterion}`);
-    }
-    if (toolUsageLines.length > 0) {
-        lines.push("<Tool_Usage>");
-        lines.push(...toolUsageLines);
-        lines.push("</Tool_Usage>");
-        lines.push("");
-    }
-    // Constraints — IR prompt_directives grouped by priority
-    if (ir && ir.prompt_directives.length > 0) {
-        lines.push("<Constraints>");
-        const high = ir.prompt_directives.filter((d) => d.priority === "high");
-        const medium = ir.prompt_directives.filter((d) => d.priority === "medium");
-        const low = ir.prompt_directives.filter((d) => d.priority !== "high" && d.priority !== "medium");
-        if (high.length > 0) {
-            lines.push("## Critical");
-            for (const d of high) {
-                lines.push(`- **${d.text}**`);
-            }
-        }
-        if (medium.length > 0) {
-            lines.push("## Standard");
-            for (const d of medium) {
-                lines.push(`- ${d.text}`);
-            }
-        }
-        if (low.length > 0) {
-            lines.push("## Other");
-            for (const d of low) {
-                lines.push(`- ${d.text}`);
-            }
-        }
-        lines.push("</Constraints>");
-        lines.push("");
-    }
-    // Checkpoints — steps that have checkpoint conditions
-    const stepsWithCheckpoints = plan.steps.filter((s) => s.checkpoints && s.checkpoints.length > 0);
-    if (stepsWithCheckpoints.length > 0) {
-        lines.push("<Checkpoints>");
-        for (const step of stepsWithCheckpoints) {
-            lines.push(`### ${step.id}`);
-            for (const cp of step.checkpoints) {
-                const action = cp.action || "block";
-                lines.push(`- ${cp.assert}: ${cp.message} (${action})`);
-                if (cp.command)
-                    lines.push(`  command: ${cp.command}`);
-            }
-        }
-        lines.push("</Checkpoints>");
-        lines.push("");
-    }
-    // Handoff — artifact flow between steps
-    const stepsWithHandoff = plan.steps.filter((s) => s.handoff && (s.handoff.consumes?.length || s.handoff.produces?.length));
-    if (stepsWithHandoff.length > 0) {
-        lines.push("<Handoff>");
-        lines.push("Human-readable handoff notes are useful for review, but they do not satisfy machine handoff gates.");
-        lines.push("ArtifactManifest records written by runtime hooks remain the machine source of truth for produced/consumed artifacts.");
-        for (const step of stepsWithHandoff) {
-            const h = step.handoff;
-            if (h.produces && h.produces.length > 0) {
-                for (const p of h.produces) {
-                    lines.push(`  Step ${step.id} produces: ${p.description} (${p.type}${p.path ? `, ${p.path}` : ""})`);
-                }
-            }
-            if (h.consumes && h.consumes.length > 0) {
-                for (const c of h.consumes) {
-                    const fromNote = c.from ? ` from ${c.from}` : "";
-                    lines.push(`  Step ${step.id} consumes: ${c.description}${fromNote} (${c.type}${c.path ? `, ${c.path}` : ""})`);
-                }
-            }
-        }
-        lines.push("</Handoff>");
-        lines.push("");
-    }
-    // Workflow Boundary — prevent cross-workflow execution
-    lines.push("<Workflow_Boundary>");
-    lines.push(`Before reporting final success, terminal failure, or exhaustion, call \`dna_workflow_write\` with workflow=${workflowId}, current_step=workflow_complete, current_role=workflow, active=false.`);
-    lines.push("This workflow is COMPLETE. Do NOT proceed to any other workflow.");
-    lines.push("Report your results and STOP. The user will decide the next step.");
-    lines.push("</Workflow_Boundary>");
-    lines.push("");
-    let content = lines.join("\n") + "\n";
-    // Substitute project variables: {{var_name}} → value
-    if (skillVariables) {
-        for (const [key, value] of Object.entries(skillVariables)) {
-            content = content.replaceAll(`{{${key}}}`, value);
-        }
-    }
+    const acceptsArgument = workflowUsesArguments(plan, skillVariables)
+        || valueUsesArguments(workflowVerifierSpecs, skillVariables)
+        || valueUsesArguments(rolePostChecks, skillVariables);
     const dirName = skillName;
-    const fileName = join(dirName, "SKILL.md");
-    return attachSkillBody({ name: skillName, fileName, dirName, content }, {
-        description: plan.description || plan.name,
+    const content = canonicalSkillBody({
+        skillName,
+        description,
+        request: canonicalSkillRequest("workflow", workflowKey, acceptsArgument, options),
+        acceptsArgument,
+    });
+    return attachSkillBody({ name: skillName, fileName: join(dirName, "SKILL.md"), dirName, content }, {
+        description,
         triggers: [plan.name, `run ${plan.name}`],
         kind: "workflow",
         mapEntry: workflowSkillMapEntry(skillName, dirName, plan),
     });
 }
-// ── File Operations ────────────────────────────────────────
 export async function writeSkillFiles(results, outputDir) {
     const written = [];
     const mapEntries = [];
@@ -884,19 +250,11 @@ export async function removeSkillFiles(outputDir) {
             }
         }
         catch {
-            // Skip
+            // Ignore unmanaged or incomplete entries.
         }
     }
     return removed;
 }
-function escapeYaml(s) {
-    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-/** Escape prompt text for Agent() call template inside markdown code block. */
-function escapePrompt(s) {
-    return s
-        .replace(/\\/g, "\\\\")
-        .replace(/"/g, '\\"')
-        .replace(/`{3,}/g, "` ` `")
-        .replace(/\n/g, "\\n");
+function escapeYaml(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }