agentopology 0.1.0

package/dist/bindings/claude-code.js

@@ -0,0 +1,2063 @@
+/**
+ * Claude Code binding — reference implementation.
+ *
+ * Generates the `.claude/` directory structure, `.mcp.json`, and supporting
+ * scripts from a parsed {@link TopologyAST}.
+ *
+ * @module
+ */
+import { deduplicateFiles } from "./types.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert .at MCP tool notation (mcp.server.method) to Claude Code format (mcp__server__method).
+ * Non-MCP tool names pass through unchanged.
+ */
+function convertMcpToolName(tool) {
+    if (!tool.startsWith("mcp."))
+        return tool;
+    // mcp.server-name.method_name → mcp__server-name__method_name
+    // Only replace the first two dots (mcp + server separator)
+    const parts = tool.split(".");
+    if (parts.length >= 3) {
+        return `mcp__${parts[1]}__${parts.slice(2).join(".")}`;
+    }
+    return tool;
+}
+/**
+ * Downshift all markdown headings by one level so they nest properly
+ * inside ## Instructions. ## → ###, ### → ####, etc.
+ */
+function downshiftHeadings(text) {
+    return text.replace(/^(#{2,6})\s/gm, (_, hashes) => `#${hashes} `);
+}
+/** Convert a kebab-case id to Title Case. */
+function toTitle(id) {
+    return id
+        .split(/[-_]/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+/**
+ * Wrap content in a YAML frontmatter block.
+ *
+ * Supports scalar values, booleans, and arrays.
+ * Arrays are rendered as multi-line YAML lists:
+ *   key:
+ *     - item1
+ *     - item2
+ */
+function frontmatter(fields) {
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                continue;
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`  - ${item}`);
+            }
+        }
+        else if (typeof value === "boolean") {
+            lines.push(`${key}: ${value}`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    lines.push("---");
+    return lines.join("\n");
+}
+/** Generate a shell script stub with a header comment. */
+function shellStub(description) {
+    return [
+        "#!/usr/bin/env bash",
+        `# ${description}`,
+        "# Auto-generated by agentopology scaffold — edit as needed.",
+        'set -euo pipefail',
+        "",
+        'echo "TODO: implement this script"',
+        "",
+    ].join("\n");
+}
+/** Generate an empty directory marker (a .gitkeep file). */
+function gitkeep(dirPath) {
+    return { path: `${dirPath}/.gitkeep`, content: "", category: "machine" };
+}
+/**
+ * Map topology permission strings to Claude Code permissionMode values.
+ * Returns undefined when the permission mode should be omitted (default/autonomous).
+ */
+function mapPermissionMode(perm) {
+    // Claude Code native values — pass through
+    const nativeValues = ["plan", "auto", "confirm", "bypassPermissions"];
+    if (nativeValues.includes(perm)) {
+        // "auto" is the default, omit it
+        if (perm === "auto")
+            return undefined;
+        return perm;
+    }
+    // Topology-level semantic values
+    switch (perm) {
+        case "supervised":
+            return "plan";
+        case "autonomous":
+            return undefined; // default, omit
+        case "interactive":
+            return "default";
+        case "unrestricted":
+            return "bypassPermissions";
+        default:
+            return perm; // unknown — pass through as-is
+    }
+}
+/** Format a SchemaType to a human-readable string. Optionally resolves refs. */
+function formatSchemaType(t, schemas) {
+    switch (t.kind) {
+        case "primitive":
+            return t.value;
+        case "array":
+            return `${formatSchemaType(t.itemType, schemas)}[]`;
+        case "enum":
+            return t.values.join(" | ");
+        case "ref": {
+            if (schemas) {
+                const resolved = schemas.find((s) => s.id === t.name);
+                if (resolved) {
+                    const fields = resolved.fields.map((f) => `${f.name}${f.optional ? "?" : ""}: ${formatSchemaType(f.type, schemas)}`);
+                    return `${t.name} { ${fields.join(", ")} }`;
+                }
+            }
+            return t.name;
+        }
+    }
+}
+/** Format a SchemaFieldDef to a readable line. */
+function formatSchemaField(f) {
+    const opt = f.optional ? "?" : "";
+    return `- ${f.name}${opt}: ${formatSchemaType(f.type)}`;
+}
+// ---------------------------------------------------------------------------
+// Section generators
+// ---------------------------------------------------------------------------
+/** Generate script stubs for each ActionNode. */
+function generateActionNodes(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const node of ast.nodes) {
+        if (node.type !== "action")
+            continue;
+        const action = node;
+        const lines = ["#!/usr/bin/env bash"];
+        lines.push(`# Action: ${action.id} — ${action.description ?? action.label}`);
+        lines.push("# Auto-generated by agentopology scaffold — edit as needed.");
+        lines.push('set -euo pipefail');
+        lines.push("");
+        if (action.timeout) {
+            lines.push(`# Timeout: ${action.timeout}`);
+        }
+        if (action.onFail) {
+            lines.push(`# On failure: ${action.onFail}`);
+        }
+        if (action.join) {
+            lines.push(`# Join semantics: ${action.join}`);
+        }
+        switch (action.kind) {
+            case "external":
+                lines.push(`# External source: ${action.source ?? "unknown"}`);
+                lines.push("");
+                lines.push(`echo "TODO: implement external action — fetch from ${action.source ?? "source"}"`);
+                break;
+            case "inline":
+                if (action.commands && action.commands.length > 0) {
+                    lines.push("");
+                    for (const cmd of action.commands) {
+                        lines.push(cmd);
+                    }
+                }
+                else {
+                    lines.push("");
+                    lines.push('echo "TODO: implement inline action"');
+                }
+                break;
+            case "git":
+                lines.push("");
+                lines.push("# Git operation");
+                if (action.commands && action.commands.length > 0) {
+                    for (const cmd of action.commands) {
+                        lines.push(cmd);
+                    }
+                }
+                else {
+                    lines.push('echo "TODO: implement git action"');
+                }
+                break;
+            case "report":
+                lines.push("");
+                lines.push("# Report generation");
+                lines.push('echo "TODO: implement report action"');
+                break;
+            default:
+                lines.push("");
+                lines.push(`echo "TODO: implement ${action.kind ?? "unknown"} action"`);
+                break;
+        }
+        lines.push("");
+        files.push({
+            path: `.claude/skills/${name}/scripts/action-${action.id}.sh`,
+            content: lines.join("\n"),
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate AGENT.md files for each agent node. */
+function generateAgents(ast) {
+    const files = [];
+    for (const node of ast.nodes) {
+        if (node.type !== "agent")
+            continue;
+        const agent = node;
+        // Build frontmatter fields
+        const fm = {};
+        fm.name = agent.id;
+        // Description: prefer agent.description, then role description from roles block.
+        // For manual agents, omit description to prevent Claude Code auto-delegation.
+        if (agent.invocation !== "manual") {
+            const desc = agent.description ?? ast.roles[agent.role ?? ""] ?? ast.roles[agent.id] ?? agent.role;
+            if (desc) {
+                fm.description = `"${desc}"`;
+            }
+        }
+        if (agent.model)
+            fm.model = agent.model;
+        if (agent.maxTurns != null)
+            fm.maxTurns = String(agent.maxTurns);
+        if (agent.tools && agent.tools.length > 0)
+            fm.tools = agent.tools.map(convertMcpToolName);
+        if (agent.disallowedTools && agent.disallowedTools.length > 0)
+            fm.disallowedTools = agent.disallowedTools.map(convertMcpToolName);
+        if (agent.mcpServers && agent.mcpServers.length > 0)
+            fm.mcpServers = agent.mcpServers;
+        if (agent.background === true)
+            fm.background = true;
+        if (agent.permissions) {
+            const mapped = mapPermissionMode(agent.permissions);
+            if (mapped)
+                fm.permissionMode = mapped;
+        }
+        if (agent.isolation)
+            fm.isolation = agent.isolation;
+        // Note: sandbox and fallback-chain are not recognized by Claude Code frontmatter
+        // but are included as informational metadata for other tooling.
+        if (agent.sandbox != null) {
+            fm.sandbox = typeof agent.sandbox === "boolean" ? agent.sandbox : agent.sandbox;
+        }
+        if (agent.fallbackChain && agent.fallbackChain.length > 0) {
+            fm["fallback-chain"] = agent.fallbackChain.join(", ");
+        }
+        // invocation: manual — Claude Code doesn't parse this field. Instead, omit
+        // description to prevent auto-delegation for manual agents.
+        if (agent.skills && agent.skills.length > 0)
+            fm.skills = agent.skills;
+        // scale is NOT a Claude Code frontmatter field — rendered only in body as prompt text
+        // Merge claude-code extension fields into frontmatter
+        if (agent.extensions?.["claude-code"]) {
+            for (const [k, v] of Object.entries(agent.extensions["claude-code"])) {
+                if (typeof v === "string")
+                    fm[k] = v;
+                else if (typeof v === "boolean")
+                    fm[k] = v;
+                else if (Array.isArray(v))
+                    fm[k] = v;
+            }
+        }
+        // Build frontmatter string — may include hooks YAML block
+        let fmStr = frontmatter(fm);
+        // Per-agent hooks → Claude Code AGENT.md frontmatter hooks
+        if (agent.hooks && agent.hooks.length > 0) {
+            const topologyName = ast.topology.name;
+            const hooksByEvent = {};
+            for (const hook of agent.hooks) {
+                if (!hooksByEvent[hook.on])
+                    hooksByEvent[hook.on] = [];
+                hooksByEvent[hook.on].push(hook);
+            }
+            const hookLines = ["hooks:"];
+            for (const [eventName, hooks] of Object.entries(hooksByEvent)) {
+                hookLines.push(`  ${eventName}:`);
+                for (const hook of hooks) {
+                    const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+                    const command = `bash .claude/skills/${topologyName}/scripts/${agent.id}-${scriptName}`;
+                    if (hook.matcher) {
+                        hookLines.push(`    - matcher: "${hook.matcher}"`);
+                    }
+                    else {
+                        hookLines.push(`    -`);
+                    }
+                    hookLines.push(`      hooks:`);
+                    hookLines.push(`        - type: ${hook.type ?? "command"}`);
+                    hookLines.push(`          command: "${command}"`);
+                    if (hook.timeout) {
+                        hookLines.push(`          timeout: ${hook.timeout}`);
+                    }
+                }
+            }
+            // Insert hooks before the closing ---
+            fmStr = fmStr.replace(/\n---$/, "\n" + hookLines.join("\n") + "\n---");
+        }
+        // Build body
+        const sections = [fmStr, ""];
+        const displayName = agent.label || toTitle(agent.id);
+        // Role section — only when role text adds info beyond the prompt
+        const roleText = ast.roles[agent.role ?? ""] ?? ast.roles[agent.id] ?? agent.role;
+        if (roleText && !agent.prompt) {
+            sections.push("## Role");
+            sections.push(roleText);
+            sections.push("");
+        }
+        sections.push("## Instructions");
+        sections.push("");
+        if (agent.prompt) {
+            sections.push(downshiftHeadings(agent.prompt));
+        }
+        else if (agent.description) {
+            sections.push(agent.description);
+            if (roleText)
+                sections.push(`\n${roleText}`);
+        }
+        else if (roleText) {
+            sections.push(roleText);
+        }
+        else {
+            sections.push("Complete the assigned task.");
+        }
+        sections.push("");
+        // Reads section
+        if (agent.reads && agent.reads.length > 0) {
+            sections.push("## Reads");
+            for (const r of agent.reads) {
+                sections.push(`- ${r}`);
+            }
+            sections.push("");
+        }
+        // Writes section
+        if (agent.writes && agent.writes.length > 0) {
+            sections.push("## Writes");
+            for (const w of agent.writes) {
+                sections.push(`- ${w}`);
+            }
+            sections.push("");
+        }
+        // Outputs section
+        if (agent.outputs) {
+            sections.push("## Outputs");
+            for (const [field, values] of Object.entries(agent.outputs)) {
+                sections.push(`- ${field}: ${values.join(" | ")}`);
+            }
+            sections.push("");
+        }
+        // Timeout instruction
+        if (agent.timeout) {
+            sections.push(`You have a maximum of ${agent.timeout} to complete your work.`);
+            sections.push("");
+        }
+        // On-fail instruction
+        if (agent.onFail) {
+            sections.push(`If you fail: ${agent.onFail}`);
+            sections.push("");
+        }
+        // Retry configuration
+        if (agent.retry != null) {
+            if (typeof agent.retry === "number") {
+                sections.push(`Retry up to ${agent.retry} times on failure.`);
+            }
+            else {
+                const r = agent.retry;
+                const parts = [`max ${r.max} attempts`];
+                if (r.backoff)
+                    parts.push(`${r.backoff} backoff`);
+                if (r.interval)
+                    parts.push(`interval ${r.interval}`);
+                if (r.maxInterval)
+                    parts.push(`max interval ${r.maxInterval}`);
+                if (r.jitter)
+                    parts.push(`with jitter`);
+                if (r.nonRetryable && r.nonRetryable.length > 0) {
+                    parts.push(`non-retryable: ${r.nonRetryable.join(", ")}`);
+                }
+                sections.push(`Retry strategy: ${parts.join(", ")}.`);
+            }
+            sections.push("");
+        }
+        // Model Configuration section
+        const hasModelConfig = agent.temperature != null ||
+            agent.maxTokens != null ||
+            agent.topP != null ||
+            agent.topK != null ||
+            agent.stop != null ||
+            agent.seed != null;
+        if (hasModelConfig) {
+            sections.push("## Model Configuration");
+            if (agent.temperature != null)
+                sections.push(`- Temperature: ${agent.temperature}`);
+            if (agent.maxTokens != null)
+                sections.push(`- Max tokens: ${agent.maxTokens}`);
+            if (agent.topP != null)
+                sections.push(`- Top-p: ${agent.topP}`);
+            if (agent.topK != null)
+                sections.push(`- Top-k: ${agent.topK}`);
+            if (agent.stop)
+                sections.push(`- Stop sequences: ${agent.stop.join(", ")}`);
+            if (agent.seed != null)
+                sections.push(`- Seed: ${agent.seed}`);
+            sections.push("");
+        }
+        // Thinking
+        if (agent.thinking) {
+            let thinkingLine = `Use ${agent.thinking} level reasoning.`;
+            if (agent.thinkingBudget != null) {
+                thinkingLine = `Use ${agent.thinking} level reasoning (budget: ${agent.thinkingBudget} tokens).`;
+            }
+            sections.push(thinkingLine);
+            sections.push("");
+        }
+        // Output format
+        if (agent.outputFormat) {
+            sections.push(`Output format: ${agent.outputFormat}`);
+            sections.push("");
+        }
+        // Log level
+        if (agent.logLevel) {
+            sections.push(`Log level: ${agent.logLevel}`);
+            sections.push("");
+        }
+        // Join semantics
+        if (agent.join) {
+            sections.push(`Wait strategy: ${agent.join} (wait for upstream agents)`);
+            sections.push("");
+        }
+        // Circuit breaker
+        if (agent.circuitBreaker) {
+            const cb = agent.circuitBreaker;
+            sections.push("## Circuit Breaker");
+            sections.push(`- Failure threshold: ${cb.threshold}`);
+            sections.push(`- Window: ${cb.window}`);
+            sections.push(`- Cooldown: ${cb.cooldown}`);
+            sections.push("");
+        }
+        // Compensates
+        if (agent.compensates) {
+            sections.push(`This agent compensates (can undo) the work of: ${agent.compensates}`);
+            sections.push("");
+        }
+        // Input Schema
+        if (agent.inputSchema && agent.inputSchema.length > 0) {
+            sections.push("## Input Schema");
+            for (const field of agent.inputSchema) {
+                sections.push(formatSchemaField(field));
+            }
+            sections.push("");
+        }
+        // Output Schema
+        if (agent.outputSchema && agent.outputSchema.length > 0) {
+            sections.push("## Output Schema");
+            for (const field of agent.outputSchema) {
+                sections.push(formatSchemaField(field));
+            }
+            sections.push("");
+        }
+        // Rate limit
+        if (agent.rateLimit) {
+            sections.push(`Rate limit: ${agent.rateLimit}`);
+            sections.push("");
+        }
+        // Artifacts: produces/consumes
+        if ((agent.produces && agent.produces.length > 0) || (agent.consumes && agent.consumes.length > 0)) {
+            sections.push("## Artifacts");
+            if (agent.produces && agent.produces.length > 0) {
+                sections.push(`Produces: ${agent.produces.join(", ")}`);
+            }
+            if (agent.consumes && agent.consumes.length > 0) {
+                sections.push(`Consumes: ${agent.consumes.join(", ")}`);
+            }
+            sections.push("");
+        }
+        // Variants
+        if (agent.variants && agent.variants.length > 0) {
+            sections.push("## Variants");
+            for (const v of agent.variants) {
+                const parts = [`**${v.id}** (weight: ${v.weight})`];
+                if (v.model)
+                    parts.push(`model: ${v.model}`);
+                if (v.temperature != null)
+                    parts.push(`temperature: ${v.temperature}`);
+                sections.push(`- ${parts.join(", ")}`);
+                if (v.prompt) {
+                    sections.push(`  Prompt: ${v.prompt}`);
+                }
+            }
+            sections.push("");
+        }
+        // Scale
+        if (agent.scale) {
+            const s = agent.scale;
+            sections.push("## Scale");
+            sections.push(`- Mode: ${s.mode}`);
+            sections.push(`- By: ${s.by}`);
+            sections.push(`- Min: ${s.min}`);
+            sections.push(`- Max: ${s.max}`);
+            if (s.batchSize != null)
+                sections.push(`- Batch size: ${s.batchSize}`);
+            sections.push("");
+        }
+        if (agent.behavior) {
+            sections.push(`Behavior: ${agent.behavior}`);
+        }
+        if (agent.skip) {
+            sections.push(`Skip when: ${agent.skip}`);
+        }
+        // Inject group conversation protocol if this agent is a group member
+        const groupProto = groupProtocols.get(agent.id);
+        if (groupProto) {
+            sections.push(groupProto);
+        }
+        // Inject group transcript note if this agent receives group output
+        const downstreamNote = groupDownstream.get(agent.id);
+        if (downstreamNote) {
+            sections.push(downstreamNote);
+        }
+        files.push({
+            path: `.claude/agents/${agent.id}/AGENT.md`,
+            content: sections.join("\n") + "\n",
+            category: "agent",
+        });
+    }
+    return files;
+}
+/** Generate AGENT.md files for each human node. */
+function generateHumanNodes(ast) {
+    const files = [];
+    for (const node of ast.nodes) {
+        if (node.type !== "human")
+            continue;
+        const human = node;
+        const sections = [];
+        sections.push(`# ${toTitle(human.id)} (Human-in-the-Loop)`);
+        sections.push("");
+        if (human.description) {
+            sections.push(human.description);
+            sections.push("");
+        }
+        if (human.timeout) {
+            sections.push(`Timeout: ${human.timeout}`);
+        }
+        if (human.onTimeout) {
+            sections.push(`On timeout: ${human.onTimeout}`);
+        }
+        sections.push("");
+        files.push({
+            path: `.claude/agents/${human.id}/AGENT.md`,
+            content: sections.join("\n") + "\n",
+            category: "machine",
+        });
+    }
+    return files;
+}
+/**
+ * Generate group chat artifacts:
+ *   - Orchestrator AGENT.md — spawns members sequentially
+ *   - Shared transcript file — the communication channel
+ *   - Group config JSON — metadata for reference
+ *   - Group protocol section injected into each member's AGENT.md (via groupProtocols map)
+ *
+ * Architecture: file-based group chat.
+ * Instead of passing context through prompts, agents communicate via a shared
+ * transcript file (`.claude/groups/<id>/transcript.md`). Each agent:
+ *   1. Reads the transcript to see all previous messages
+ *   2. Appends its response under the current round heading
+ * The orchestrator spawns agents sequentially — execution order IS the lock.
+ */
+/** Map of agent-id → group protocol instructions to inject into their AGENT.md. */
+const groupProtocols = new Map();
+/** Map of agent-id → group transcript note for downstream agents (receivers of group output). */
+const groupDownstream = new Map();
+function generateGroupNodes(ast) {
+    const files = [];
+    for (const node of ast.nodes) {
+        if (node.type !== "group")
+            continue;
+        const group = node;
+        const selectionMode = (group.speakerSelection ?? "sequential").replace(/^"|"$/g, "");
+        const rounds = group.maxRounds ?? 1;
+        const transcriptPath = `.claude/groups/${group.id}/transcript.md`;
+        // --- 1. Group config JSON ---
+        const config = {
+            id: group.id,
+            members: group.members,
+            speakerSelection: selectionMode,
+            maxRounds: rounds,
+            transcriptPath,
+        };
+        if (group.termination)
+            config.termination = group.termination;
+        if (group.timeout)
+            config.timeout = group.timeout;
+        files.push({
+            path: `.claude/groups/${group.id}/config.json`,
+            content: JSON.stringify(config, null, 2) + "\n",
+            category: "machine",
+        });
+        // --- 2. Transcript template ---
+        const transcriptLines = [];
+        transcriptLines.push(`# ${group.label || toTitle(group.id)}`);
+        transcriptLines.push("");
+        if (group.description) {
+            transcriptLines.push(group.description);
+            transcriptLines.push("");
+        }
+        transcriptLines.push(`**Participants:** ${group.members.join(", ")}`);
+        transcriptLines.push(`**Rounds:** ${rounds}`);
+        if (selectionMode !== "sequential") {
+            transcriptLines.push(`**Speaker order:** ${selectionMode}`);
+        }
+        transcriptLines.push("");
+        transcriptLines.push("---");
+        transcriptLines.push("");
+        transcriptLines.push("<!-- Topic will be written here by the orchestrator -->");
+        transcriptLines.push("");
+        files.push({
+            path: transcriptPath,
+            content: transcriptLines.join("\n"),
+            category: "agent",
+        });
+        // --- 3. Register protocol for each member agent ---
+        for (const member of group.members) {
+            const protocol = [
+                "",
+                "## Group Conversation Protocol",
+                "",
+                `You are participating in a group conversation via a shared transcript file: \`${transcriptPath}\``,
+                "",
+                "**Before responding:**",
+                `1. Read \`${transcriptPath}\` to see the full conversation so far`,
+                "2. Review what other participants have said",
+                "",
+                "**Your response:**",
+                `1. Append your response to \`${transcriptPath}\` under the current round heading`,
+                `2. Start with a \`### ${member}\` heading on its own line, then write your response below it`,
+                "3. Respond directly to what previous speakers said — engage with their arguments",
+                "4. Keep your response focused and concise",
+                "",
+                `**Do NOT** overwrite or replace the file contents. Only append to the end.`,
+                "",
+            ].join("\n");
+            groupProtocols.set(member, protocol);
+        }
+        // --- 3b. Register downstream agents (agents receiving group output via flow edges) ---
+        for (const edge of ast.edges) {
+            if (edge.from === group.id && !group.members.includes(edge.to)) {
+                const note = [
+                    "",
+                    "## Group Conversation Input",
+                    "",
+                    `This agent receives the output of a group conversation. The full debate/discussion transcript is available at: \`${transcriptPath}\``,
+                    "",
+                    `**Read \`${transcriptPath}\` first** to see the complete conversation before making your evaluation or response.`,
+                    "",
+                ].join("\n");
+                groupDownstream.set(edge.to, note);
+            }
+        }
+        // --- 4. Build the orchestration body (shared between skill and agent) ---
+        const bodyLines = [];
+        if (group.description) {
+            bodyLines.push(group.description);
+            bodyLines.push("");
+        }
+        bodyLines.push("You orchestrate a group conversation using a shared transcript file. Each participant reads the transcript, sees what others wrote, and appends their response.");
+        bodyLines.push("");
+        bodyLines.push(`**Transcript file:** \`${transcriptPath}\``);
+        bodyLines.push("");
+        // Participant table
+        bodyLines.push("### Participants");
+        bodyLines.push("");
+        for (const member of group.members) {
+            const memberNode = ast.nodes.find((n) => n.id === member);
+            const memberDesc = memberNode?.type === "agent"
+                ? memberNode.description ?? memberNode.label
+                : memberNode?.label ?? member;
+            const memberModel = memberNode?.type === "agent"
+                ? memberNode.model : undefined;
+            const modelNote = memberModel ? ` (model: ${memberModel})` : "";
+            bodyLines.push(`- **${member}**${modelNote}: ${memberDesc}`);
+        }
+        bodyLines.push("");
+        // Step-by-step orchestration
+        bodyLines.push("### Step-by-step process");
+        bodyLines.push("");
+        bodyLines.push(`1. Write the topic/prompt at the top of \`${transcriptPath}\` (replace the placeholder comment)`);
+        bodyLines.push("");
+        const totalTurns = rounds * group.members.length;
+        let step = 2;
+        for (let round = 1; round <= rounds; round++) {
+            bodyLines.push(`**Round ${round}:**`);
+            bodyLines.push("");
+            bodyLines.push(`${step}. Append \`## Round ${round}\` to the transcript`);
+            step++;
+            for (const member of group.members) {
+                const memberNode = ast.nodes.find((n) => n.id === member);
+                const memberModel = memberNode?.type === "agent"
+                    ? memberNode.model : undefined;
+                const modelParam = memberModel ? `, model: ${memberModel}` : "";
+                bodyLines.push(`${step}. Spawn **${member}** (subagent_type: "${member}"${modelParam}). The agent will read the transcript, see what others wrote, and append its response.`);
+                step++;
+            }
+            bodyLines.push("");
+        }
+        bodyLines.push(`${step}. After all ${totalTurns} turns, read the final transcript and return it as your output.`);
+        bodyLines.push("");
+        if (group.termination) {
+            bodyLines.push(`**Termination condition:** ${group.termination} (but always complete the configured ${rounds} round(s) unless this condition is met earlier)`);
+        }
+        if (group.timeout) {
+            bodyLines.push(`**Timeout:** ${group.timeout}`);
+        }
+        bodyLines.push("");
+        bodyLines.push("### Important");
+        bodyLines.push("");
+        bodyLines.push("- Spawn agents **one at a time, sequentially** — never in parallel");
+        bodyLines.push("- Each agent reads the transcript BEFORE responding, so it sees all previous messages");
+        bodyLines.push("- The transcript file is the shared state — do not pass conversation history in prompts");
+        bodyLines.push("- Wait for each agent to finish before spawning the next one");
+        bodyLines.push("");
+        const orchestrationBody = bodyLines.join("\n");
+        // --- 5. Skill (primary — runs in main session, has Agent tool access) ---
+        const skillFm = {};
+        skillFm.name = group.id;
+        if (group.description)
+            skillFm.description = `"${group.description}"`;
+        skillFm["user-invocable"] = true;
+        const skillSections = [];
+        skillSections.push(frontmatter(skillFm));
+        skillSections.push("");
+        skillSections.push(`# ${group.label || toTitle(group.id)}`);
+        skillSections.push("");
+        skillSections.push(orchestrationBody);
+        files.push({
+            path: `.claude/skills/${group.id}/SKILL.md`,
+            content: skillSections.join("\n") + "\n",
+            category: "agent",
+        });
+        // --- 6. Agent (fallback — for when spawned as subagent, may not have Agent tool) ---
+        const agentFm = {};
+        agentFm.name = group.id;
+        if (group.description)
+            agentFm.description = `"${group.description}"`;
+        const agentSections = [];
+        agentSections.push(frontmatter(agentFm));
+        agentSections.push("");
+        agentSections.push("## Instructions");
+        agentSections.push("");
+        agentSections.push(orchestrationBody);
+        agentSections.push("");
+        agentSections.push("> **Note:** If the Agent tool is not available, simulate the group conversation by writing each participant's response yourself, following the round structure above. Write all responses to the transcript file.");
+        agentSections.push("");
+        files.push({
+            path: `.claude/agents/${group.id}/AGENT.md`,
+            content: agentSections.join("\n") + "\n",
+            category: "agent",
+        });
+    }
+    return files;
+}
+/** Generate the main SKILL.md for the topology (orchestrator + flow + gates). */
+function generateTopologySkill(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    // Build frontmatter
+    const fm = {};
+    fm.name = name;
+    if (ast.topology.description) {
+        fm.description = `"${ast.topology.description}"`;
+    }
+    fm.version = `"${ast.topology.version}"`;
+    fm.topology = name;
+    if (ast.topology.patterns.length > 0) {
+        fm.patterns = ast.topology.patterns;
+    }
+    // Entry: first trigger's command file
+    if (ast.triggers.length > 0) {
+        fm.entry = `commands/${ast.triggers[0].name}.md`;
+    }
+    // Add skill-level fields from the first matching skill (if skills exist)
+    // For the main topology skill, look for a skill with the same name as the topology
+    const mainSkill = ast.skills.find((s) => s.id === name);
+    if (mainSkill) {
+        if (mainSkill.disableModelInvocation != null) {
+            fm["disable-model-invocation"] = mainSkill.disableModelInvocation;
+        }
+        if (mainSkill.userInvocable != null) {
+            fm["user-invocable"] = mainSkill.userInvocable;
+        }
+        if (mainSkill.context)
+            fm.context = mainSkill.context;
+        if (mainSkill.agent)
+            fm.agent = mainSkill.agent;
+        if (mainSkill.allowedTools && mainSkill.allowedTools.length > 0) {
+            fm["allowed-tools"] = mainSkill.allowedTools.map(convertMcpToolName);
+        }
+    }
+    const sections = [];
+    sections.push(frontmatter(fm));
+    sections.push("");
+    sections.push(`# ${toTitle(name)} Topology Skill`);
+    sections.push("");
+    if (ast.topology.description) {
+        sections.push(ast.topology.description);
+        sections.push("");
+    }
+    sections.push(`Version: ${ast.topology.version}`);
+    if (ast.topology.patterns.length > 0) {
+        sections.push(`Patterns: ${ast.topology.patterns.join(", ")}`);
+    }
+    sections.push("");
+    // Topology metadata
+    if (ast.topology.foundations && ast.topology.foundations.length > 0) {
+        sections.push(`Foundations: ${ast.topology.foundations.join(", ")}`);
+    }
+    if (ast.topology.advanced && ast.topology.advanced.length > 0) {
+        sections.push(`Advanced: ${ast.topology.advanced.join(", ")}`);
+    }
+    if (ast.topology.domain) {
+        sections.push(`Domain: ${ast.topology.domain}`);
+    }
+    if (ast.topology.timeout) {
+        sections.push(`Timeout: ${ast.topology.timeout}`);
+    }
+    if (ast.topology.durable) {
+        sections.push(`Durable: yes`);
+    }
+    if (ast.topology.foundations || ast.topology.advanced || ast.topology.domain || ast.topology.timeout || ast.topology.durable) {
+        sections.push("");
+    }
+    // Fragment check — skip main skill generation for fragments
+    if (ast.isFragment) {
+        sections.push("*This is a fragment topology — it is meant to be included, not run standalone.*");
+        sections.push("");
+    }
+    // Composition: params
+    if (ast.params && ast.params.length > 0) {
+        sections.push("## Parameters");
+        sections.push("");
+        for (const p of ast.params) {
+            const req = p.required ? " (required)" : "";
+            const def = p.default != null ? ` = ${p.default}` : "";
+            sections.push(`- **${p.name}**: ${p.type}${req}${def}`);
+        }
+        sections.push("");
+    }
+    // Composition: interface endpoints
+    if (ast.interfaceEndpoints) {
+        sections.push("## Interface");
+        sections.push("");
+        sections.push(`- Entry: ${ast.interfaceEndpoints.entry}`);
+        sections.push(`- Exit: ${ast.interfaceEndpoints.exit}`);
+        sections.push("");
+    }
+    // Composition: imports
+    if (ast.imports && ast.imports.length > 0) {
+        sections.push("## Imports");
+        sections.push("");
+        for (const imp of ast.imports) {
+            let line = `- **${imp.alias}** from \`${imp.source}\``;
+            if (imp.sha256)
+                line += ` (sha256: ${imp.sha256})`;
+            if (imp.registry)
+                line += ` [registry: ${imp.registryPackage}@${imp.registryVersion}]`;
+            sections.push(line);
+            if (Object.keys(imp.params).length > 0) {
+                for (const [k, v] of Object.entries(imp.params)) {
+                    sections.push(`  - ${k}: ${v}`);
+                }
+            }
+        }
+        sections.push("");
+    }
+    // Composition: includes
+    if (ast.includes && ast.includes.length > 0) {
+        sections.push("## Includes");
+        sections.push("");
+        for (const inc of ast.includes) {
+            sections.push(`- ${inc.source}`);
+        }
+        sections.push("");
+    }
+    // Error handler
+    if (ast.topology.errorHandler) {
+        sections.push("## Error Handling");
+        sections.push("");
+        sections.push(`Uncaught errors are handled by: **${ast.topology.errorHandler}**`);
+        sections.push("");
+    }
+    // Orchestrator section
+    const orch = ast.nodes.find((n) => n.type === "orchestrator");
+    if (orch) {
+        const orchNode = orch;
+        sections.push("## Orchestrator");
+        sections.push("");
+        sections.push(`Model: ${orchNode.model}`);
+        if (orchNode.handles?.length > 0) {
+            sections.push(`Handles: ${orchNode.handles.join(", ")}`);
+        }
+        if (orchNode.generates) {
+            sections.push(`Generates: ${orchNode.generates}`);
+        }
+        if (orchNode.outputs) {
+            sections.push("");
+            sections.push("### Outputs");
+            for (const [field, values] of Object.entries(orchNode.outputs)) {
+                sections.push(`- ${field}: ${values.join(" | ")}`);
+            }
+        }
+        sections.push("");
+    }
+    // Flow section (enhanced with error edges, join, weight, race, tolerance, reflection)
+    if (ast.edges.length > 0) {
+        sections.push("## Flow");
+        sections.push("");
+        for (const edge of ast.edges) {
+            const arrow = edge.isError ? `-x${edge.errorType ? `[${edge.errorType}]` : ""}>` : "->";
+            let line = `${edge.from} ${arrow} ${edge.to}`;
+            if (edge.condition) {
+                // Clean up condition: parser may include trailing "] [max N" artifacts
+                const cleanCond = edge.condition
+                    .replace(/\]\s*\[max\s+\d+\s*$/i, "")
+                    .replace(/\]\s*$/, "")
+                    .trim();
+                line += ` [when ${cleanCond}]`;
+            }
+            if (edge.maxIterations)
+                line += ` [max ${edge.maxIterations}]`;
+            if (edge.per)
+                line += ` [per ${edge.per}]`;
+            if (edge.weight != null)
+                line += ` [weight ${edge.weight}]`;
+            if (edge.race)
+                line += ` [race]`;
+            if (edge.tolerance != null)
+                line += ` [tolerance: ${edge.tolerance}]`;
+            if (edge.wait)
+                line += ` [wait ${edge.wait}]`;
+            if (edge.reflection)
+                line += ` [reflection]`;
+            sections.push(`- ${line}`);
+        }
+        sections.push("");
+    }
+    // Gates section
+    const gates = ast.nodes.filter((n) => n.type === "gate");
+    if (gates.length > 0) {
+        sections.push("## Gates");
+        sections.push("");
+        for (const gate of gates) {
+            sections.push(`### ${toTitle(gate.id)}`);
+            if (gate.after)
+                sections.push(`After: ${gate.after}`);
+            if (gate.before)
+                sections.push(`Before: ${gate.before}`);
+            if (gate.run)
+                sections.push(`Run: ${gate.run}`);
+            if (gate.checks && gate.checks.length > 0) {
+                sections.push(`Checks: ${gate.checks.join(", ")}`);
+            }
+            if (gate.onFail)
+                sections.push(`On fail: ${gate.onFail}`);
+            if (gate.retry)
+                sections.push(`Retry: ${gate.retry}`);
+            if (gate.timeout)
+                sections.push(`Timeout: ${gate.timeout}`);
+            sections.push("");
+        }
+    }
+    // Schedules section
+    if (ast.schedules.length > 0) {
+        sections.push("## Schedules");
+        sections.push("");
+        for (const job of ast.schedules) {
+            const expr = job.cron ? `cron: ${job.cron}` : job.every ? `every: ${job.every}` : "";
+            const target = job.agent ? `agent: ${job.agent}` : job.action ? `action: ${job.action}` : "";
+            sections.push(`- **${job.id}**: ${expr}${target ? ` -> ${target}` : ""}${job.enabled === false ? " (disabled)" : ""}`);
+        }
+        sections.push("");
+    }
+    // Interfaces section
+    if (ast.interfaces.length > 0) {
+        sections.push("## Interfaces");
+        sections.push("");
+        for (const iface of ast.interfaces) {
+            const typePart = iface.type ? ` (${iface.type})` : "";
+            const configKeys = Object.keys(iface.config);
+            const configPart = configKeys.length > 0 ? ` — ${configKeys.map((k) => `${k}: ${iface.config[k]}`).join(", ")}` : "";
+            sections.push(`- **${iface.id}**${typePart}${configPart}`);
+        }
+        sections.push("");
+    }
+    // Depth levels
+    if (ast.depth && ast.depth.levels && ast.depth.levels.length > 0) {
+        sections.push("## Depth Levels");
+        sections.push("");
+        if (ast.depth.factors.length > 0) {
+            sections.push(`Factors: ${ast.depth.factors.join(", ")}`);
+        }
+        for (const level of ast.depth.levels) {
+            let line = `- **Level ${level.level}**: ${level.label}`;
+            if (level.omit.length > 0)
+                line += ` (omit: ${level.omit.join(", ")})`;
+            sections.push(line);
+        }
+        sections.push("");
+    }
+    // Batch settings
+    if (ast.batch && Object.keys(ast.batch).length > 0) {
+        sections.push("## Batch");
+        sections.push("");
+        for (const [key, value] of Object.entries(ast.batch)) {
+            sections.push(`- ${key}: ${JSON.stringify(value)}`);
+        }
+        sections.push("");
+    }
+    // Environments
+    if (ast.environments && Object.keys(ast.environments).length > 0) {
+        sections.push("## Environments");
+        sections.push("");
+        for (const [envName, envConfig] of Object.entries(ast.environments)) {
+            sections.push(`### ${envName}`);
+            for (const [key, value] of Object.entries(envConfig)) {
+                sections.push(`- ${key}: ${JSON.stringify(value)}`);
+            }
+            sections.push("");
+        }
+    }
+    // Fallback chain from settings
+    const fallbackChain = ast.settings?.["fallback-chain"];
+    if (fallbackChain) {
+        sections.push("## Fallback Chain");
+        sections.push("");
+        if (Array.isArray(fallbackChain)) {
+            sections.push(`Models: ${fallbackChain.join(" -> ")}`);
+        }
+        else {
+            sections.push(`Fallback chain: ${fallbackChain}`);
+        }
+        sections.push("");
+    }
+    // Metering
+    if (ast.metering) {
+        sections.push("## Metering");
+        sections.push("");
+        sections.push(`- Track: ${ast.metering.track.join(", ")}`);
+        sections.push(`- Per: ${ast.metering.per.join(", ")}`);
+        sections.push(`- Output: ${ast.metering.output}`);
+        sections.push(`- Format: ${ast.metering.format}`);
+        sections.push(`- Pricing: ${ast.metering.pricing}`);
+        sections.push("");
+    }
+    // Memory
+    const memKeys = Object.keys(ast.memory);
+    if (memKeys.length > 0) {
+        sections.push("## Memory");
+        sections.push("");
+        for (const key of memKeys) {
+            const mem = ast.memory[key];
+            sections.push(`### ${key}`);
+            for (const [k, v] of Object.entries(mem)) {
+                if (Array.isArray(v)) {
+                    sections.push(`- ${k}: ${v.join(", ")}`);
+                }
+                else {
+                    sections.push(`- ${k}: ${v}`);
+                }
+            }
+            sections.push("");
+        }
+    }
+    files.push({
+        path: `.claude/skills/${name}/SKILL.md`,
+        content: sections.join("\n") + "\n",
+        category: "agent",
+    });
+    return files;
+}
+/** Generate skill-level files from the skills block. */
+function generateSkills(ast) {
+    const files = [];
+    for (const skill of ast.skills) {
+        const sections = [];
+        // Build skill frontmatter
+        const sfm = {};
+        sfm.name = skill.id;
+        if (skill.description)
+            sfm.description = `"${skill.description}"`;
+        if (skill.disableModelInvocation != null) {
+            sfm["disable-model-invocation"] = skill.disableModelInvocation;
+        }
+        if (skill.userInvocable != null) {
+            sfm["user-invocable"] = skill.userInvocable;
+        }
+        if (skill.context)
+            sfm.context = skill.context;
+        if (skill.agent)
+            sfm.agent = skill.agent;
+        if (skill.allowedTools && skill.allowedTools.length > 0) {
+            sfm["allowed-tools"] = skill.allowedTools.map(convertMcpToolName);
+        }
+        // Only emit frontmatter if there are fields beyond just the name
+        if (Object.keys(sfm).length > 1) {
+            sections.push(frontmatter(sfm));
+            sections.push("");
+        }
+        sections.push(`# ${toTitle(skill.id)} Skill`);
+        sections.push("");
+        if (skill.description) {
+            sections.push(skill.description);
+            sections.push("");
+        }
+        if (skill.scripts && skill.scripts.length > 0) {
+            sections.push("## Scripts");
+            for (const s of skill.scripts) {
+                sections.push(`- ${s}`);
+            }
+            sections.push("");
+        }
+        if (skill.domains && skill.domains.length > 0) {
+            sections.push("## Domains");
+            for (const d of skill.domains) {
+                sections.push(`- ${d}`);
+            }
+            sections.push("");
+        }
+        if (skill.references && skill.references.length > 0) {
+            sections.push("## References");
+            for (const r of skill.references) {
+                sections.push(`- ${r}`);
+            }
+            sections.push("");
+        }
+        if (skill.prompt) {
+            sections.push("## Prompt");
+            sections.push(`See: ${skill.prompt}`);
+            sections.push("");
+        }
+        files.push({
+            path: `.claude/skills/${skill.id}/SKILL.md`,
+            content: sections.join("\n") + "\n",
+            category: "agent",
+        });
+        // Domain and reference directory markers
+        if (skill.domains && skill.domains.length > 0) {
+            files.push(gitkeep(`.claude/skills/${skill.id}/domains`));
+        }
+        if (skill.references && skill.references.length > 0) {
+            files.push(gitkeep(`.claude/skills/${skill.id}/references`));
+        }
+    }
+    return files;
+}
+/** Generate memory structure files (domains, references, metrics, workspace). */
+function generateMemory(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    const memory = ast.memory;
+    if (memory.domains) {
+        files.push(gitkeep(`.claude/skills/${name}/domains`));
+    }
+    if (memory.references) {
+        files.push(gitkeep(`.claude/skills/${name}/references`));
+    }
+    if (memory.metrics) {
+        files.push({
+            path: `.claude/skills/${name}/metrics.jsonl`,
+            content: "",
+            category: "machine",
+        });
+    }
+    if (memory.workspace) {
+        files.push(gitkeep(`.claude/skills/${name}/runs`));
+    }
+    return files;
+}
+/** Generate gate script stubs. */
+function generateGateScripts(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const node of ast.nodes) {
+        if (node.type !== "gate")
+            continue;
+        const gate = node;
+        if (gate.run) {
+            // Extract script name from the run command
+            const scriptName = gate.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+            files.push({
+                path: `.claude/skills/${name}/scripts/${scriptName}`,
+                content: shellStub(`Gate: ${gate.id} — ${gate.run}`),
+                category: "script",
+            });
+        }
+    }
+    return files;
+}
+/** Generate gate wrapper scripts that filter Task calls to the correct agent. */
+function generateGateWrapperScripts(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const node of ast.nodes) {
+        if (node.type !== "gate")
+            continue;
+        const gate = node;
+        if (!gate.run)
+            continue;
+        if (gate.behavior === "advisory")
+            continue;
+        const gateScriptName = gate.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+        const onFailExit = gate.onFail === "halt" ? 'exit 1' : 'echo "Gate failed — bounce-back requested (advisory)"';
+        const contentLines = [
+            "#!/usr/bin/env bash",
+            `# Gate wrapper: ${gate.id}`,
+            `# Enforces gate "${gate.id}" on Task tool calls.`,
+            `# Auto-generated by agentopology scaffold — edit as needed.`,
+            "set -euo pipefail",
+            "",
+            "# Gate runs after: " + (gate.after || "any"),
+            "# Gate runs before: " + (gate.before || "any"),
+            `# On failure: ${gate.onFail || "halt"}`,
+        ];
+        if (gate.timeout) {
+            contentLines.push(`# Timeout: ${gate.timeout}`);
+        }
+        if (gate.retry != null && gate.retry > 0) {
+            contentLines.push("");
+            contentLines.push(`MAX_RETRIES=${gate.retry}`);
+            contentLines.push("ATTEMPT=0");
+            contentLines.push("GATE_RESULT=1");
+            contentLines.push("");
+            contentLines.push("while [ $ATTEMPT -le $MAX_RETRIES ] && [ $GATE_RESULT -ne 0 ]; do");
+            contentLines.push("  ATTEMPT=$((ATTEMPT + 1))");
+            if (gate.timeout) {
+                contentLines.push(`  timeout ${gate.timeout} bash .claude/skills/${name}/scripts/${gateScriptName} && GATE_RESULT=0 || GATE_RESULT=$?`);
+            }
+            else {
+                contentLines.push(`  bash .claude/skills/${name}/scripts/${gateScriptName} && GATE_RESULT=0 || GATE_RESULT=$?`);
+            }
+            contentLines.push('  if [ $GATE_RESULT -ne 0 ] && [ $ATTEMPT -le $MAX_RETRIES ]; then');
+            contentLines.push(`    echo "Gate '${gate.id}' attempt $ATTEMPT failed, retrying..."`);
+            contentLines.push("    sleep 1");
+            contentLines.push("  fi");
+            contentLines.push("done");
+        }
+        else {
+            contentLines.push("");
+            contentLines.push("# Run the gate check script");
+            contentLines.push(`GATE_RESULT=0`);
+            if (gate.timeout) {
+                contentLines.push(`timeout ${gate.timeout} bash .claude/skills/${name}/scripts/${gateScriptName} || GATE_RESULT=$?`);
+            }
+            else {
+                contentLines.push(`bash .claude/skills/${name}/scripts/${gateScriptName} || GATE_RESULT=$?`);
+            }
+        }
+        contentLines.push("");
+        contentLines.push(`if [ "$GATE_RESULT" -ne 0 ]; then`);
+        contentLines.push(`  echo "Gate '${gate.id}' FAILED (exit code $GATE_RESULT)"`);
+        contentLines.push(`  ${onFailExit}`);
+        contentLines.push("fi");
+        contentLines.push("");
+        const content = contentLines.join("\n");
+        files.push({
+            path: `.claude/skills/${name}/scripts/gate-${gate.id}.sh`,
+            content,
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate hook script stubs for every hook's `run` field. */
+function generateHookScripts(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const hook of ast.hooks) {
+        if (!hook.run)
+            continue;
+        // Extract script filename from the run command
+        const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+        files.push({
+            path: `.claude/skills/${name}/scripts/${scriptName}`,
+            content: [
+                "#!/usr/bin/env bash",
+                `# Hook: ${hook.name} — fires on ${hook.on}`,
+                "# Auto-generated by agentopology scaffold — edit as needed.",
+                'set -euo pipefail',
+                "",
+                `echo "TODO: implement ${hook.name} hook"`,
+                "",
+            ].join("\n"),
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate per-agent hook script stubs. */
+function generateAgentHookScripts(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const node of ast.nodes) {
+        if (node.type !== "agent")
+            continue;
+        const agent = node;
+        if (!agent.hooks || agent.hooks.length === 0)
+            continue;
+        for (const hook of agent.hooks) {
+            if (!hook.run)
+                continue;
+            const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+            files.push({
+                path: `.claude/skills/${name}/scripts/${agent.id}-${scriptName}`,
+                content: [
+                    "#!/usr/bin/env bash",
+                    `# Hook: ${hook.name} — fires on ${hook.on} (scoped to agent: ${agent.id})`,
+                    "# Auto-generated by agentopology scaffold — edit as needed.",
+                    'set -euo pipefail',
+                    "",
+                    `echo "TODO: implement ${hook.name} hook for ${agent.id}"`,
+                    "",
+                ].join("\n"),
+                category: "script",
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Generate hook configuration in .claude/settings.json.
+ *
+ * Hooks are grouped by event name as an object:
+ *   { "hooks": { "PostToolUse": [ { hooks: [...], matcher? } ], ... } }
+ */
+function generateSettings(ast) {
+    const settings = {};
+    const topologyName = ast.topology.name;
+    // Hooks section — grouped by event name
+    const hooksByEvent = {};
+    for (const hook of ast.hooks) {
+        const eventName = hook.on;
+        if (!hooksByEvent[eventName]) {
+            hooksByEvent[eventName] = [];
+        }
+        // Build the script command with proper path prefix
+        const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+        const command = `bash .claude/skills/${topologyName}/scripts/${scriptName}`;
+        const hookEntry = {
+            hooks: [
+                {
+                    type: hook.type ?? "command",
+                    command,
+                    ...(hook.timeout ? { timeout: hook.timeout } : {}),
+                },
+            ],
+        };
+        // Only add matcher when it has a value
+        if (hook.matcher) {
+            hookEntry.matcher = hook.matcher;
+        }
+        hooksByEvent[eventName].push(hookEntry);
+    }
+    // Per-agent hooks are now rendered in AGENT.md frontmatter (not in settings.json).
+    // This is the Claude Code native approach: hooks in the agent file are scoped
+    // to that agent automatically.
+    // Gate enforcement — compile gates with run: to PreToolUse hooks
+    const gates = ast.nodes.filter((n) => n.type === "gate");
+    for (const gate of gates) {
+        if (!gate.run)
+            continue;
+        if (gate.behavior === "advisory")
+            continue; // advisory gates stay in markdown only
+        const eventName = "PreToolUse";
+        if (!hooksByEvent[eventName])
+            hooksByEvent[eventName] = [];
+        const scriptName = `gate-${gate.id}.sh`;
+        const command = `bash .claude/skills/${topologyName}/scripts/${scriptName}`;
+        const hookEntry = {
+            hooks: [
+                {
+                    type: "command",
+                    command,
+                },
+            ],
+            matcher: "Task", // Gates fire on Task tool (agent spawning)
+        };
+        hooksByEvent[eventName].push(hookEntry);
+    }
+    // Write hooksByEvent to settings if any hooks or gates were registered
+    if (Object.keys(hooksByEvent).length > 0) {
+        settings.hooks = hooksByEvent;
+    }
+    // Environment variables
+    const envSettings = generateEnvToSettings(ast);
+    if (envSettings) {
+        settings.env = envSettings;
+    }
+    // Permissions section from settings block
+    const perms = ast.settings;
+    if (perms) {
+        const allow = perms.allow;
+        const deny = perms.deny;
+        const ask = perms.ask;
+        if (allow && allow.length > 0)
+            settings.allow = allow;
+        if (deny && deny.length > 0)
+            settings.deny = deny;
+        if (ask && ask.length > 0)
+            settings.ask = ask;
+    }
+    // Defaults documentation
+    if (ast.defaults) {
+        const d = ast.defaults;
+        const defaultsDoc = {};
+        if (d.temperature != null)
+            defaultsDoc.temperature = d.temperature;
+        if (d.maxTokens != null)
+            defaultsDoc.maxTokens = d.maxTokens;
+        if (d.topP != null)
+            defaultsDoc.topP = d.topP;
+        if (d.topK != null)
+            defaultsDoc.topK = d.topK;
+        if (d.stop)
+            defaultsDoc.stop = d.stop;
+        if (d.seed != null)
+            defaultsDoc.seed = d.seed;
+        if (d.thinking)
+            defaultsDoc.thinking = d.thinking;
+        if (d.thinkingBudget != null)
+            defaultsDoc.thinkingBudget = d.thinkingBudget;
+        if (d.outputFormat)
+            defaultsDoc.outputFormat = d.outputFormat;
+        if (d.timeout)
+            defaultsDoc.timeout = d.timeout;
+        if (d.logLevel)
+            defaultsDoc.logLevel = d.logLevel;
+        if (Object.keys(defaultsDoc).length > 0) {
+            settings._defaults = defaultsDoc;
+        }
+    }
+    // Observability documentation
+    if (ast.observability) {
+        const o = ast.observability;
+        const obsDoc = {
+            enabled: o.enabled,
+            level: o.level,
+            exporter: o.exporter,
+            sampleRate: o.sampleRate,
+        };
+        if (o.endpoint)
+            obsDoc.endpoint = o.endpoint;
+        if (o.service)
+            obsDoc.service = o.service;
+        obsDoc.capture = o.capture;
+        obsDoc.spans = o.spans;
+        settings._observability = obsDoc;
+    }
+    // Top-level extensions for claude-code
+    if (ast.extensions?.["claude-code"]) {
+        for (const [k, v] of Object.entries(ast.extensions["claude-code"])) {
+            settings[k] = v;
+        }
+    }
+    if (Object.keys(settings).length === 0)
+        return null;
+    return {
+        path: ".claude/settings.json",
+        content: JSON.stringify(settings, null, 2) + "\n",
+        category: "shared-config",
+    };
+}
+/** Generate .mcp.json from mcp-servers block. Always includes env field. */
+function generateMcpJson(ast) {
+    if (Object.keys(ast.mcpServers).length === 0)
+        return null;
+    const mcpConfig = { mcpServers: {} };
+    const servers = mcpConfig.mcpServers;
+    for (const [name, config] of Object.entries(ast.mcpServers)) {
+        const entry = {};
+        for (const [key, value] of Object.entries(config)) {
+            if (key === "command" || key === "url") {
+                entry[key] = value;
+            }
+            else if (key === "args" && Array.isArray(value)) {
+                entry.args = value;
+            }
+            else if (key === "env" && typeof value === "object" && value !== null) {
+                entry.env = value;
+            }
+            // Skip unknown fields — parser may leak env vars to top level
+        }
+        // Only include servers that have a command or url (filter parser artifacts)
+        if (!("command" in entry) && !("url" in entry))
+            continue;
+        // Always include env field for Claude Code .mcp.json
+        if (!("env" in entry)) {
+            entry.env = {};
+        }
+        servers[name] = entry;
+    }
+    return {
+        path: ".mcp.json",
+        content: JSON.stringify(mcpConfig, null, 2) + "\n",
+        category: "shared-config",
+    };
+}
+/** Generate metering script stub. */
+function generateMetering(ast) {
+    if (!ast.metering)
+        return null;
+    const m = ast.metering;
+    const lines = [
+        "#!/usr/bin/env bash",
+        "# Metering / cost tracking script",
+        "# Auto-generated by agentopology scaffold — edit as needed.",
+        'set -euo pipefail',
+        "",
+        `# Track: ${m.track.join(", ")}`,
+        `# Per: ${m.per.join(", ")}`,
+        `# Output: ${m.output} (${m.format})`,
+        `# Pricing: ${m.pricing}`,
+        "",
+        'echo "TODO: implement metrics collection"',
+        "",
+    ];
+    return {
+        path: "scripts/collect-metrics.sh",
+        content: lines.join("\n"),
+        category: "script",
+    };
+}
+/** Generate tool script stubs. */
+function generateToolScripts(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    for (const tool of ast.toolDefs) {
+        const ext = tool.lang === "python" ? "py" : tool.lang === "node" ? "js" : "sh";
+        const shebang = tool.lang === "python"
+            ? "#!/usr/bin/env python3"
+            : tool.lang === "node"
+                ? "#!/usr/bin/env node"
+                : "#!/usr/bin/env bash";
+        const lines = [
+            shebang,
+            `# Tool: ${tool.id} — ${tool.description}`,
+            "# Auto-generated by agentopology scaffold — edit as needed.",
+            "",
+        ];
+        if (tool.lang === "bash" || !tool.lang) {
+            lines.push('set -euo pipefail');
+            lines.push("");
+        }
+        if (tool.args && tool.args.length > 0) {
+            lines.push(`# Args: ${tool.args.join(", ")}`);
+            lines.push("");
+        }
+        if (tool.lang === "python") {
+            lines.push(`print("TODO: implement ${tool.id}")`);
+        }
+        else if (tool.lang === "node") {
+            lines.push(`console.log("TODO: implement ${tool.id}");`);
+        }
+        else {
+            lines.push(`echo "TODO: implement ${tool.id}"`);
+        }
+        lines.push("");
+        files.push({
+            path: `.claude/skills/${name}/scripts/${tool.id}.${ext}`,
+            content: lines.join("\n"),
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate schema documentation files. */
+function generateSchemas(ast) {
+    const files = [];
+    const name = ast.topology.name;
+    if (!ast.schemas || ast.schemas.length === 0)
+        return files;
+    for (const schema of ast.schemas) {
+        const sections = [];
+        sections.push(`# Schema: ${schema.id}`);
+        sections.push("");
+        sections.push("## Fields");
+        sections.push("");
+        for (const field of schema.fields) {
+            const opt = field.optional ? " (optional)" : "";
+            sections.push(`- **${field.name}**${opt}: ${formatSchemaType(field.type, ast.schemas)}`);
+        }
+        sections.push("");
+        files.push({
+            path: `.claude/skills/${name}/schemas/${schema.id}.md`,
+            content: sections.join("\n") + "\n",
+            category: "machine",
+        });
+    }
+    return files;
+}
+/** Generate schedule scripts and crontab fragment. */
+function generateScheduleScripts(ast) {
+    const files = [];
+    if (!ast.schedules || ast.schedules.length === 0)
+        return files;
+    const cronLines = [
+        "# Crontab fragment — auto-generated by agentopology scaffold",
+        "# Install with: crontab -l | cat - crontab.fragment | crontab -",
+        "",
+    ];
+    for (const job of ast.schedules) {
+        const target = job.agent ? `agent ${job.agent}` : job.action ? `action ${job.action}` : "unknown";
+        const scriptPath = `scripts/schedule-${job.id}.sh`;
+        // Generate the shell script
+        const lines = [
+            "#!/usr/bin/env bash",
+            `# Schedule: ${job.id} — invokes ${target}`,
+            "# Auto-generated by agentopology scaffold — edit as needed.",
+            'set -euo pipefail',
+            "",
+        ];
+        if (job.agent) {
+            lines.push(`# Invoke agent: ${job.agent}`);
+            lines.push(`claude --agent ${job.agent}`);
+        }
+        else if (job.action) {
+            lines.push(`# Invoke action: ${job.action}`);
+            lines.push(`bash scripts/action-${job.action}.sh`);
+        }
+        if (job.enabled === false) {
+            lines.unshift("# DISABLED — this schedule is not enabled");
+        }
+        lines.push("");
+        files.push({ path: scriptPath, content: lines.join("\n"), category: "script" });
+        // Add crontab entry
+        let cronExpr = job.cron ?? "# every: " + (job.every ?? "unknown");
+        if (!job.cron && job.every) {
+            // Convert common "every" expressions to cron
+            const everyMap = {
+                "1h": "0 * * * *",
+                "1 hour": "0 * * * *",
+                "hourly": "0 * * * *",
+                "1d": "0 0 * * *",
+                "1 day": "0 0 * * *",
+                "daily": "0 0 * * *",
+                "1w": "0 0 * * 0",
+                "weekly": "0 0 * * 0",
+            };
+            cronExpr = everyMap[job.every.toLowerCase()] ?? `# every: ${job.every}`;
+        }
+        const enabledPrefix = job.enabled === false ? "# DISABLED: " : "";
+        cronLines.push(`${enabledPrefix}${cronExpr} bash ${scriptPath}  # ${job.id}`);
+    }
+    cronLines.push("");
+    files.push({ path: "crontab.fragment", content: cronLines.join("\n"), category: "machine" });
+    return files;
+}
+/** Generate .claude/commands/X.md for each trigger. */
+function generateCommandFiles(ast) {
+    const files = [];
+    for (const trigger of ast.triggers) {
+        const sections = [];
+        // Frontmatter
+        const fm = {};
+        if (ast.topology.description) {
+            fm.description = `"${ast.topology.description}"`;
+        }
+        sections.push(frontmatter(fm));
+        sections.push("");
+        // Header
+        sections.push(`# /${trigger.name}`);
+        sections.push("");
+        sections.push(trigger.pattern);
+        sections.push("");
+        // Arguments
+        if (trigger.argument) {
+            sections.push("## Arguments");
+            sections.push(`- ${trigger.argument}: extracted from the command pattern`);
+            sections.push("");
+        }
+        // Pipeline (from edges, enhanced)
+        if (ast.edges.length > 0) {
+            sections.push("## Pipeline");
+            for (const edge of ast.edges) {
+                const arrow = edge.isError ? `-x${edge.errorType ? `[${edge.errorType}]` : ""}>` : "->";
+                let line = `${edge.from} ${arrow} ${edge.to}`;
+                if (edge.condition) {
+                    const cleanCond = edge.condition
+                        .replace(/\]\s*\[max\s+\d+\s*$/i, "")
+                        .replace(/\]\s*$/, "")
+                        .trim();
+                    line += ` [when ${cleanCond}]`;
+                }
+                if (edge.maxIterations)
+                    line += ` [max ${edge.maxIterations}]`;
+                if (edge.weight != null)
+                    line += ` [weight ${edge.weight}]`;
+                if (edge.race)
+                    line += ` [race]`;
+                if (edge.tolerance != null)
+                    line += ` [tolerance: ${edge.tolerance}]`;
+                if (edge.wait)
+                    line += ` [wait ${edge.wait}]`;
+                if (edge.reflection)
+                    line += ` [reflection]`;
+                sections.push(`- ${line}`);
+            }
+            sections.push("");
+        }
+        // Agents table
+        const agents = ast.nodes.filter((n) => n.type === "agent");
+        if (agents.length > 0) {
+            sections.push("## Agents");
+            sections.push("| Agent | Phase | Model | Role |");
+            sections.push("|-------|-------|-------|------|");
+            for (const agent of agents) {
+                const phase = agent.phase != null ? String(agent.phase) : "-";
+                const model = agent.model ?? "-";
+                const role = agent.role ?? "-";
+                sections.push(`| ${agent.id} | ${phase} | ${model} | ${role} |`);
+            }
+            sections.push("");
+        }
+        files.push({
+            path: `.claude/commands/${trigger.name}.md`,
+            content: sections.join("\n") + "\n",
+            category: "machine",
+        });
+    }
+    return files;
+}
+/** Generate workspace-protocol.md if workspace memory has a protocol field. */
+function generateWorkspaceProtocol(ast) {
+    const name = ast.topology.name;
+    const workspace = ast.memory.workspace;
+    if (!workspace || !workspace.protocol)
+        return null;
+    const protocol = workspace.protocol;
+    const sections = [];
+    sections.push("# Workspace Protocol");
+    sections.push("");
+    // Directory structure from workspace.structure
+    const structure = workspace.structure;
+    if (structure && Array.isArray(structure)) {
+        sections.push("## Directory Structure");
+        for (const item of structure) {
+            sections.push(`- ${item}`);
+        }
+        sections.push("");
+    }
+    // Read/Write rules from agent nodes
+    const agents = ast.nodes.filter((n) => n.type === "agent");
+    if (agents.length > 0) {
+        sections.push("## Read/Write Rules");
+        for (const agent of agents) {
+            const reads = agent.reads ?? [];
+            const writes = agent.writes ?? [];
+            if (reads.length > 0 || writes.length > 0) {
+                sections.push(`### ${toTitle(agent.id)}`);
+                if (reads.length > 0) {
+                    sections.push(`- Reads: ${reads.join(", ")}`);
+                }
+                if (writes.length > 0) {
+                    sections.push(`- Writes: ${writes.join(", ")}`);
+                }
+                sections.push("");
+            }
+        }
+    }
+    return {
+        path: `.claude/skills/${name}/${protocol}`,
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/**
+ * Generate context/instructions file inside `.claude/`.
+ *
+ * If `ast.context.file` is set and points inside `.claude/`, that path is
+ * used.  Otherwise the file is written to `.claude/CONTEXT.md`.
+ *
+ * **Important**: We never generate a file at the project-root `CLAUDE.md`
+ * because that is the user's own instructions file and overwriting it would
+ * destroy their content.
+ */
+function generateContextFile(ast) {
+    const DEFAULT_PATH = ".claude/CONTEXT.md";
+    let fileName = ast.context.file ?? DEFAULT_PATH;
+    // Safety: never overwrite the user's root-level CLAUDE.md
+    if (fileName === "CLAUDE.md" || fileName === "./CLAUDE.md") {
+        fileName = DEFAULT_PATH;
+    }
+    const sections = [];
+    sections.push(`# ${toTitle(ast.topology.name)}`);
+    sections.push("");
+    if (ast.topology.description) {
+        sections.push(ast.topology.description);
+        sections.push("");
+    }
+    sections.push(`Version: ${ast.topology.version}`);
+    if (ast.topology.patterns.length > 0) {
+        sections.push(`Patterns: ${ast.topology.patterns.join(", ")}`);
+    }
+    sections.push("");
+    // Include references
+    if (ast.context.includes && ast.context.includes.length > 0) {
+        sections.push("## Includes");
+        sections.push("");
+        for (const inc of ast.context.includes) {
+            sections.push(`- ${inc}`);
+        }
+        sections.push("");
+    }
+    // Defaults block
+    if (ast.defaults) {
+        const d = ast.defaults;
+        sections.push("## Defaults");
+        sections.push("");
+        if (d.temperature != null)
+            sections.push(`- Temperature: ${d.temperature}`);
+        if (d.maxTokens != null)
+            sections.push(`- Max tokens: ${d.maxTokens}`);
+        if (d.topP != null)
+            sections.push(`- Top-p: ${d.topP}`);
+        if (d.topK != null)
+            sections.push(`- Top-k: ${d.topK}`);
+        if (d.stop)
+            sections.push(`- Stop sequences: ${d.stop.join(", ")}`);
+        if (d.seed != null)
+            sections.push(`- Seed: ${d.seed}`);
+        if (d.thinking)
+            sections.push(`- Thinking: ${d.thinking}`);
+        if (d.thinkingBudget != null)
+            sections.push(`- Thinking budget: ${d.thinkingBudget}`);
+        if (d.outputFormat)
+            sections.push(`- Output format: ${d.outputFormat}`);
+        if (d.timeout)
+            sections.push(`- Timeout: ${d.timeout}`);
+        if (d.logLevel)
+            sections.push(`- Log level: ${d.logLevel}`);
+        sections.push("");
+    }
+    // Providers
+    if (ast.providers && ast.providers.length > 0) {
+        sections.push("## Providers");
+        sections.push("");
+        for (const provider of ast.providers) {
+            let line = `- **${provider.name}**`;
+            if (provider.default)
+                line += " (default)";
+            if (provider.models.length > 0)
+                line += ` — models: ${provider.models.join(", ")}`;
+            sections.push(line);
+            if (provider.baseUrl)
+                sections.push(`  - Base URL: ${provider.baseUrl}`);
+            if (provider.apiKey)
+                sections.push(`  - API key: ${provider.apiKey}`);
+            if (provider.auth) {
+                sections.push(`  - Auth: ${provider.auth.type}`);
+                if (provider.auth.issuer)
+                    sections.push(`    - Issuer: ${provider.auth.issuer}`);
+                if (provider.auth.audience)
+                    sections.push(`    - Audience: ${provider.auth.audience}`);
+                if (provider.auth.scopes)
+                    sections.push(`    - Scopes: ${provider.auth.scopes.join(", ")}`);
+            }
+        }
+        sections.push("");
+    }
+    // Checkpoint config
+    if (ast.checkpoint) {
+        const cp = ast.checkpoint;
+        sections.push("## Checkpoint");
+        sections.push("");
+        sections.push(`- Backend: ${cp.backend}`);
+        sections.push(`- Strategy: ${cp.strategy}`);
+        if (cp.connection)
+            sections.push(`- Connection: ${cp.connection}`);
+        if (cp.ttl)
+            sections.push(`- TTL: ${cp.ttl}`);
+        if (cp.replay) {
+            sections.push(`- Replay: ${cp.replay.enabled ? "enabled" : "disabled"}`);
+            if (cp.replay.maxHistory != null)
+                sections.push(`  - Max history: ${cp.replay.maxHistory}`);
+            if (cp.replay.branch != null)
+                sections.push(`  - Branching: ${cp.replay.branch}`);
+        }
+        sections.push("");
+    }
+    // Artifacts registry
+    if (ast.artifacts && ast.artifacts.length > 0) {
+        sections.push("## Artifacts");
+        sections.push("");
+        for (const a of ast.artifacts) {
+            let line = `- **${a.id}** (${a.type})`;
+            if (a.path)
+                line += ` — path: ${a.path}`;
+            if (a.retention)
+                line += `, retention: ${a.retention}`;
+            if (a.dependsOn && a.dependsOn.length > 0)
+                line += `, depends on: ${a.dependsOn.join(", ")}`;
+            sections.push(line);
+        }
+        sections.push("");
+    }
+    return {
+        path: fileName,
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/**
+ * Merge `ast.env` into the settings.json output under an `env` key.
+ *
+ * When `ast.providers` includes an "anthropic" provider with an api-key,
+ * that env var is included automatically (enabling API-key mode instead
+ * of subscription mode).
+ *
+ * Returns the env record if non-empty, otherwise null.
+ */
+function generateEnvToSettings(ast) {
+    const env = {};
+    for (const [key, val] of Object.entries(ast.env)) {
+        if (typeof val === "string") {
+            env[key] = val;
+        }
+        else {
+            const sv = val;
+            if (sv.secretRef) {
+                // Secret reference — emit placeholder with comment-style URI
+                env[key] = `\${${key}}`; // placeholder
+                env[`# ${key}_SECRET`] = sv.secretRef.uri;
+            }
+            else if (sv.sensitive) {
+                // Sensitive value — never emit the actual value
+                env[key] = `\${${key}}`;
+            }
+            else if (sv.encrypted) {
+                // Encrypted value — emit placeholder with warning
+                env[key] = `\${${key}}`;
+                env[`# ${key}_ENCRYPTED`] = "WARNING: value is SOPS-encrypted, decrypt before use";
+            }
+            else {
+                env[key] = sv.value;
+            }
+        }
+    }
+    // If an anthropic provider exists, scaffold the API key env var
+    if (ast.providers && ast.providers.length > 0) {
+        const anthropicProvider = ast.providers.find((p) => p.name === "anthropic");
+        if (anthropicProvider?.apiKey) {
+            // Extract env var name from ${ENV_VAR} format
+            const envVarMatch = anthropicProvider.apiKey.match(/^\$\{(.+)\}$/);
+            if (envVarMatch) {
+                env[envVarMatch[1]] = anthropicProvider.apiKey;
+            }
+        }
+    }
+    if (Object.keys(env).length === 0)
+        return null;
+    return env;
+}
+/** Generate trigger documentation in the skill. */
+function generateTriggers(ast) {
+    if (ast.triggers.length === 0)
+        return "";
+    const lines = ["## Triggers", ""];
+    for (const trigger of ast.triggers) {
+        lines.push(`### /${trigger.name}`);
+        lines.push(`Pattern: \`${trigger.pattern}\``);
+        if (trigger.argument)
+            lines.push(`Argument: ${trigger.argument}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Binding export
+// ---------------------------------------------------------------------------
+/** Claude Code binding — the reference binding implementation. */
+export const claudeCodeBinding = {
+    name: "claude-code",
+    description: "Anthropic Claude Code CLI — generates .claude/ directory structure, .mcp.json, and scripts.",
+    scaffold(ast) {
+        // Fragment check — skip main skill generation for fragments
+        if (ast.isFragment) {
+            const files = [];
+            // For fragments, only generate the topology skill doc (which notes it's a fragment)
+            files.push(...generateTopologySkill(ast));
+            files.push(...generateAgents(ast));
+            files.push(...generateSchemas(ast));
+            return deduplicateFiles(files);
+        }
+        const files = [];
+        // Action nodes
+        files.push(...generateActionNodes(ast));
+        // Group nodes — MUST run before agents so group protocols are registered
+        files.push(...generateGroupNodes(ast));
+        // Agent files — may include group conversation protocol sections
+        files.push(...generateAgents(ast));
+        // Human nodes
+        files.push(...generateHumanNodes(ast));
+        // Main topology skill (with frontmatter)
+        const skillFiles = generateTopologySkill(ast);
+        // Append trigger info to the main skill
+        if (ast.triggers.length > 0 && skillFiles.length > 0) {
+            skillFiles[0].content += generateTriggers(ast);
+        }
+        files.push(...skillFiles);
+        // Named skills
+        files.push(...generateSkills(ast));
+        // Schemas
+        files.push(...generateSchemas(ast));
+        // Memory directories
+        files.push(...generateMemory(ast));
+        // Gate scripts
+        files.push(...generateGateScripts(ast));
+        files.push(...generateGateWrapperScripts(ast));
+        // Hook scripts (global)
+        files.push(...generateHookScripts(ast));
+        // Hook scripts (per-agent)
+        files.push(...generateAgentHookScripts(ast));
+        // Tool scripts
+        files.push(...generateToolScripts(ast));
+        // Schedule scripts
+        files.push(...generateScheduleScripts(ast));
+        // Command files
+        files.push(...generateCommandFiles(ast));
+        // Workspace protocol
+        const wsProtocol = generateWorkspaceProtocol(ast);
+        if (wsProtocol)
+            files.push(wsProtocol);
+        // Settings (hooks + permissions + extensions)
+        const settingsFile = generateSettings(ast);
+        if (settingsFile)
+            files.push(settingsFile);
+        // MCP servers (with env field)
+        const mcpFile = generateMcpJson(ast);
+        if (mcpFile)
+            files.push(mcpFile);
+        // Metering
+        const meteringFile = generateMetering(ast);
+        if (meteringFile)
+            files.push(meteringFile);
+        // Context file (.claude/CONTEXT.md or custom — never root CLAUDE.md)
+        files.push(generateContextFile(ast));
+        return deduplicateFiles(files);
+    },
+};
+//# sourceMappingURL=claude-code.js.map