agentopology 0.9.2 → 0.10.0

package/dist/bindings/kiro.js

@@ -1,1615 +0,0 @@
-/**
- * Kiro CLI binding.
- *
- * Generates the `.kiro/` directory structure, `AGENTS.md`, and supporting
- * files from a parsed {@link TopologyAST}.
- *
- * Kiro uses JSON-based agent definitions (`.kiro/agents/<id>.json`),
- * markdown steering documents (`.kiro/steering/`), and MCP configuration
- * (`.kiro/settings/mcp.json`). Unlike Claude Code where agents are markdown
- * files with frontmatter, Kiro agents are plain JSON.
- *
- * @module
- */
-import { deduplicateFiles } from "./types.js";
-import { shellStub } from "./lib/stub.js";
-import { byPhase } from "../resolve/phase.js";
-import { gateAnchors } from "../parser/ast.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Convert a kebab-case id to Title Case. */
-function toTitle(id) {
-    return id
-        .split(/[-_]/)
-        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-        .join(" ");
-}
-/** Generate an empty directory marker (a .gitkeep file). */
-function gitkeep(dirPath) {
-    return { path: `${dirPath}/.gitkeep`, content: "", category: "machine" };
-}
-/**
- * Map topology hook event names to Kiro event names.
- *
- * Kiro uses camelCase event names (preToolUse, postToolUse) instead of
- * PascalCase (PreToolUse, PostToolUse).
- */
-function mapHookEvent(event) {
-    const eventMap = {
-        PreToolUse: "preToolUse",
-        PostToolUse: "postToolUse",
-    };
-    return eventMap[event] ?? event;
-}
-/**
- * Map topology tool names to Kiro tool names.
- *
- * Kiro uses lowercase tool names with fs_ prefixes for file operations.
- */
-function mapToolName(tool) {
-    const toolMap = {
-        Read: "read",
-        Write: "write",
-        Bash: "shell",
-        Edit: "write",
-    };
-    return toolMap[tool] ?? tool.toLowerCase();
-}
-/**
- * Map topology tool names to Kiro hook matcher names.
- *
- * For hook matchers, Kiro uses the fs_read/fs_write/execute_bash convention.
- */
-function mapMatcherName(matcher) {
-    const matcherMap = {
-        Read: "fs_read",
-        Write: "fs_write",
-        Bash: "execute_bash",
-        Edit: "fs_write",
-    };
-    return matcherMap[matcher] ?? matcher;
-}
-/** Format a SchemaType to a human-readable string. */
-function formatSchemaType(t) {
-    switch (t.kind) {
-        case "primitive":
-            return t.value;
-        case "array":
-            return `${formatSchemaType(t.itemType)}[]`;
-        case "enum":
-            return t.values.join(" | ");
-        case "ref":
-            return t.name;
-    }
-}
-/** Format schema fields as a markdown list. */
-function formatSchemaFields(fields) {
-    return fields
-        .map((f) => `- \`${f.name}${f.optional ? "?" : ""}\`: ${formatSchemaType(f.type)}`)
-        .join("\n");
-}
-// ---------------------------------------------------------------------------
-// Agent JSON generation
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/agents/<id>.json` for each agent node.
- *
- * Each agent produces a single JSON file with name, description, prompt,
- * model, tools, hooks, resources, and MCP configuration.
- *
- * NOTE: The `.kiro/agents/` JSON format is not publicly documented by Kiro.
- * This generates a reasonable agent config structure that may need validation
- * against actual Kiro when the format is finalized.
- */
-function generateAgents(ast) {
-    const files = [];
-    for (const node of ast.nodes) {
-        if (node.type !== "agent")
-            continue;
-        const agent = node;
-        const agentJson = {};
-        agentJson.name = agent.id;
-        // Description: prefer agent.description, then role description
-        const desc = agent.description ??
-            ast.roles[agent.role ?? ""] ??
-            ast.roles[agent.id] ??
-            agent.role;
-        if (desc) {
-            agentJson.description = desc;
-        }
-        // Prompt: build from role + inline prompt
-        const promptParts = [];
-        const roleText = ast.roles[agent.role ?? ""] ?? ast.roles[agent.id] ?? agent.role;
-        if (roleText) {
-            promptParts.push(`You are the ${toTitle(agent.id)} agent.\n\n## Role\n${roleText}`);
-        }
-        else {
-            promptParts.push(`You are the ${toTitle(agent.id)} agent.`);
-        }
-        if (agent.prompt) {
-            promptParts.push(`\n## Instructions\n\n${agent.prompt}`);
-        }
-        if (agent.reads && agent.reads.length > 0) {
-            promptParts.push(`\n## Reads\n${agent.reads.map((r) => `- ${r}`).join("\n")}`);
-        }
-        if (agent.writes && agent.writes.length > 0) {
-            promptParts.push(`\n## Writes\n${agent.writes.map((w) => `- ${w}`).join("\n")}`);
-        }
-        if (agent.outputs) {
-            const outputLines = Object.entries(agent.outputs)
-                .map(([field, values]) => `- ${field}: ${values.join(" | ")}`)
-                .join("\n");
-            promptParts.push(`\n## Outputs\n${outputLines}`);
-        }
-        if (agent.skills && agent.skills.length > 0) {
-            promptParts.push(`\nSkills: ${agent.skills.join(", ")}`);
-        }
-        if (agent.behavior) {
-            promptParts.push(`\nBehavior: ${agent.behavior}`);
-        }
-        if (agent.skip) {
-            promptParts.push(`\nSkip when: ${agent.skip}`);
-        }
-        agentJson.prompt = promptParts.join("\n");
-        // Model
-        if (agent.model) {
-            agentJson.model = agent.model;
-        }
-        // Fields not in Kiro's agent JSON schema — embed in prompt instead
-        // (Kiro only supports: name, description, prompt, model, mcpServers,
-        //  tools, toolAliases, allowedTools, resources, hooks, toolsSettings,
-        //  includeMcpJson, keyboardShortcut, welcomeMessage)
-        const constraints = [];
-        if (agent.timeout)
-            constraints.push(`Maximum execution time: ${agent.timeout}`);
-        if (agent.temperature != null)
-            constraints.push(`Temperature: ${agent.temperature}`);
-        if (agent.maxTokens != null)
-            constraints.push(`Max tokens: ${agent.maxTokens}`);
-        if (agent.thinking)
-            constraints.push(`Reasoning level: ${agent.thinking}`);
-        if (agent.maxTurns != null)
-            constraints.push(`Max turns: ${agent.maxTurns}`);
-        if (constraints.length > 0) {
-            agentJson.prompt += "\n\n## Constraints\n" + constraints.map((c) => `- ${c}`).join("\n");
-        }
-        // Tools — map topology tool names to Kiro names
-        if (agent.tools && agent.tools.length > 0) {
-            agentJson.tools = agent.tools.map(mapToolName);
-        }
-        // Allowed tools (subset that don't require confirmation)
-        if (agent.extensions?.kiro?.allowedTools) {
-            agentJson.allowedTools = agent.extensions.kiro.allowedTools;
-        }
-        // MCP servers — inline the full MCP server config from ast.mcpServers
-        if (agent.mcpServers && agent.mcpServers.length > 0) {
-            const mcpServers = {};
-            for (const serverName of agent.mcpServers) {
-                const serverConfig = ast.mcpServers[serverName];
-                if (serverConfig) {
-                    const entry = { ...serverConfig };
-                    // Strip type field for stdio servers (Kiro auto-detects)
-                    if (entry.command) {
-                        delete entry.type;
-                    }
-                    mcpServers[serverName] = entry;
-                }
-            }
-            if (Object.keys(mcpServers).length > 0) {
-                agentJson.mcpServers = mcpServers;
-            }
-        }
-        // Per-agent hooks — object keyed by event name
-        if (agent.hooks && agent.hooks.length > 0) {
-            const hooksObj = {};
-            for (const hook of agent.hooks) {
-                const eventName = mapHookEvent(hook.on);
-                if (!hooksObj[eventName]) {
-                    hooksObj[eventName] = [];
-                }
-                const entry = {
-                    command: hook.run,
-                };
-                if (hook.matcher) {
-                    entry.matcher = mapMatcherName(hook.matcher);
-                }
-                hooksObj[eventName].push(entry);
-            }
-            agentJson.hooks = hooksObj;
-        }
-        // Merge kiro extension fields
-        if (agent.extensions?.kiro) {
-            const handled = new Set(["allowedTools"]);
-            for (const [k, v] of Object.entries(agent.extensions.kiro)) {
-                if (handled.has(k))
-                    continue;
-                agentJson[k] = v;
-            }
-        }
-        files.push({
-            path: `.kiro/agents/${agent.id}.json`,
-            content: JSON.stringify(agentJson, null, 2) + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Per-agent steering docs for Wave 1-7 features
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/steering/agent-<id>.md` for agents with behavioral config
- * that cannot be expressed in JSON (on-fail, retry, circuitBreaker, schemas,
- * rate limits, artifacts, join semantics, output format, log level, variants).
- */
-function generateAgentSteering(ast) {
-    const files = [];
-    for (const node of ast.nodes) {
-        if (node.type !== "agent")
-            continue;
-        const agent = node;
-        const sections = [];
-        let hasContent = false;
-        // on-fail / retry (Wave 1)
-        if (agent.onFail) {
-            sections.push(`## Failure Handling`);
-            sections.push("");
-            sections.push(`On failure: **${agent.onFail}**`);
-            sections.push("");
-            hasContent = true;
-        }
-        if (agent.retry != null) {
-            if (!sections.some((s) => s.includes("Failure Handling"))) {
-                sections.push(`## Failure Handling`);
-                sections.push("");
-            }
-            if (typeof agent.retry === "number") {
-                sections.push(`Retry up to **${agent.retry}** times on failure.`);
-            }
-            else {
-                const r = agent.retry;
-                sections.push(`Retry up to **${r.max}** times.`);
-                if (r.backoff)
-                    sections.push(`- Backoff: ${r.backoff}`);
-                if (r.interval)
-                    sections.push(`- Interval: ${r.interval}`);
-                if (r.maxInterval)
-                    sections.push(`- Max interval: ${r.maxInterval}`);
-                if (r.jitter)
-                    sections.push(`- Jitter: enabled`);
-                if (r.nonRetryable && r.nonRetryable.length > 0) {
-                    sections.push(`- Non-retryable: ${r.nonRetryable.join(", ")}`);
-                }
-            }
-            sections.push("");
-            hasContent = true;
-        }
-        // circuitBreaker (Wave 5)
-        if (agent.circuitBreaker) {
-            const cb = agent.circuitBreaker;
-            sections.push(`## Circuit Breaker`);
-            sections.push("");
-            sections.push(`- Threshold: ${cb.threshold} failures`);
-            sections.push(`- Window: ${cb.window}`);
-            sections.push(`- Cooldown: ${cb.cooldown}`);
-            sections.push("");
-            hasContent = true;
-        }
-        // compensates (Wave 5 — saga)
-        if (agent.compensates) {
-            sections.push(`## Compensation`);
-            sections.push("");
-            sections.push(`This agent compensates (undoes side effects of) **${agent.compensates}**.`);
-            sections.push("");
-            hasContent = true;
-        }
-        // inputSchema / outputSchema (Wave 3)
-        if (agent.inputSchema && agent.inputSchema.length > 0) {
-            sections.push(`## Input Schema`);
-            sections.push("");
-            sections.push(formatSchemaFields(agent.inputSchema));
-            sections.push("");
-            hasContent = true;
-        }
-        if (agent.outputSchema && agent.outputSchema.length > 0) {
-            sections.push(`## Output Schema`);
-            sections.push("");
-            sections.push(formatSchemaFields(agent.outputSchema));
-            sections.push("");
-            hasContent = true;
-        }
-        // rateLimit (Wave 6)
-        if (agent.rateLimit) {
-            sections.push(`## Rate Limit`);
-            sections.push("");
-            sections.push(`Rate limit: **${agent.rateLimit}**`);
-            sections.push("");
-            hasContent = true;
-        }
-        // produces / consumes (Wave 6 — artifacts)
-        if (agent.produces && agent.produces.length > 0) {
-            sections.push(`## Produces`);
-            sections.push("");
-            sections.push(agent.produces.map((a) => `- ${a}`).join("\n"));
-            sections.push("");
-            hasContent = true;
-        }
-        if (agent.consumes && agent.consumes.length > 0) {
-            sections.push(`## Consumes`);
-            sections.push("");
-            sections.push(agent.consumes.map((a) => `- ${a}`).join("\n"));
-            sections.push("");
-            hasContent = true;
-        }
-        // join (Wave 2)
-        if (agent.join) {
-            sections.push(`## Join Strategy`);
-            sections.push("");
-            sections.push(`Wait strategy: **${agent.join}**`);
-            sections.push("");
-            hasContent = true;
-        }
-        // outputFormat (Wave 1)
-        if (agent.outputFormat) {
-            sections.push(`## Output Format`);
-            sections.push("");
-            sections.push(`Expected output format: **${agent.outputFormat}**`);
-            sections.push("");
-            hasContent = true;
-        }
-        // logLevel (Wave 3)
-        if (agent.logLevel) {
-            sections.push(`## Log Level`);
-            sections.push("");
-            sections.push(`Log level: **${agent.logLevel}**`);
-            sections.push("");
-            hasContent = true;
-        }
-        // variants (Wave 7 — A/B testing)
-        if (agent.variants && agent.variants.length > 0) {
-            sections.push(`## Prompt Variants`);
-            sections.push("");
-            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(`  > ${v.prompt.replace(/\n/g, "\n  > ")}`);
-                }
-            }
-            sections.push("");
-            hasContent = true;
-        }
-        if (!hasContent)
-            continue;
-        // Determine inclusion mode: fileMatch if agent has reads/writes paths,
-        // otherwise always.
-        const allPaths = [
-            ...(agent.reads ?? []),
-            ...(agent.writes ?? []),
-        ];
-        const headerLines = ["---"];
-        if (allPaths.length > 0) {
-            headerLines.push("inclusion: fileMatch");
-            // Combine all read/write paths into a glob pattern
-            const pattern = allPaths.length === 1
-                ? allPaths[0].replace(/\/$/, "/**")
-                : `{${allPaths.map((p) => p.replace(/\/$/, "/**")).join(",")}}`;
-            headerLines.push(`fileMatchPattern: "${pattern}"`);
-        }
-        else {
-            headerLines.push("inclusion: always");
-        }
-        headerLines.push("---");
-        headerLines.push("");
-        headerLines.push(`# ${toTitle(agent.id)} — Behavioral Config`);
-        headerLines.push("");
-        const header = headerLines;
-        files.push({
-            path: `.kiro/steering/agent-${agent.id}.md`,
-            content: header.join("\n") + sections.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Human node steering docs
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/steering/human-<id>.md` for human-in-the-loop pause points.
- */
-function generateHumanSteering(ast) {
-    const files = [];
-    for (const node of ast.nodes) {
-        if (node.type !== "human")
-            continue;
-        const human = node;
-        const sections = [
-            "---",
-            "inclusion: always",
-            "---",
-            "",
-            `# ${toTitle(human.id)} — Human Pause Point`,
-            "",
-        ];
-        if (human.description) {
-            sections.push(human.description);
-            sections.push("");
-        }
-        sections.push("## Behavior");
-        sections.push("");
-        sections.push("This is a human-in-the-loop pause point. Stop and wait for human input before continuing.");
-        sections.push("");
-        if (human.timeout) {
-            sections.push(`- Timeout: ${human.timeout}`);
-        }
-        if (human.onTimeout) {
-            sections.push(`- On timeout: ${human.onTimeout}`);
-        }
-        if (human.timeout || human.onTimeout) {
-            sections.push("");
-        }
-        files.push({
-            path: `.kiro/steering/human-${human.id}.md`,
-            content: sections.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Group node steering docs
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/steering/group-<id>.md` for group chat coordination nodes.
- */
-function generateGroupSteering(ast) {
-    const files = [];
-    for (const node of ast.nodes) {
-        if (node.type !== "group")
-            continue;
-        const group = node;
-        const sections = [
-            "---",
-            "inclusion: always",
-            "---",
-            "",
-            `# ${toTitle(group.id)} — Group Chat`,
-            "",
-        ];
-        if (group.description) {
-            sections.push(group.description);
-            sections.push("");
-        }
-        sections.push("## Coordination");
-        sections.push("");
-        sections.push(`Members: ${group.members.join(", ")}`);
-        if (group.speakerSelection) {
-            sections.push(`Speaker selection: ${group.speakerSelection}`);
-        }
-        if (group.maxRounds != null) {
-            sections.push(`Max rounds: ${group.maxRounds}`);
-        }
-        if (group.termination) {
-            sections.push(`Termination: ${group.termination}`);
-        }
-        if (group.timeout) {
-            sections.push(`Timeout: ${group.timeout}`);
-        }
-        sections.push("");
-        files.push({
-            path: `.kiro/steering/group-${group.id}.md`,
-            content: sections.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Steering documents
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/steering/product.md` — product context with topology
- * description, version, and patterns.
- */
-function generateProductSteering(ast) {
-    const sections = [];
-    sections.push("---");
-    sections.push("inclusion: always");
-    sections.push("---");
-    sections.push("");
-    sections.push("# Product Context");
-    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("");
-    // Schedules
-    if (ast.schedules && 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
-    if (ast.interfaces && 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("");
-    }
-    // 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("");
-    }
-    // Defaults
-    if (ast.defaults) {
-        const d = ast.defaults;
-        const items = [];
-        if (d.thinking)
-            items.push(`thinking: ${d.thinking}`);
-        if (d.thinkingBudget)
-            items.push(`thinking-budget: ${d.thinkingBudget}`);
-        if (d.temperature != null)
-            items.push(`temperature: ${d.temperature}`);
-        if (d.maxTokens != null)
-            items.push(`max-tokens: ${d.maxTokens}`);
-        if (d.topP != null)
-            items.push(`top-p: ${d.topP}`);
-        if (d.topK != null)
-            items.push(`top-k: ${d.topK}`);
-        if (d.seed != null)
-            items.push(`seed: ${d.seed}`);
-        if (d.timeout)
-            items.push(`timeout: ${d.timeout}`);
-        if (d.outputFormat)
-            items.push(`output-format: ${d.outputFormat}`);
-        if (d.logLevel)
-            items.push(`log-level: ${d.logLevel}`);
-        if (d.stop && d.stop.length > 0)
-            items.push(`stop: ${d.stop.join(", ")}`);
-        if (items.length > 0) {
-            sections.push("## Defaults");
-            sections.push("");
-            for (const item of items)
-                sections.push(`- ${item}`);
-            sections.push("");
-        }
-    }
-    // Artifacts
-    if (ast.artifacts && ast.artifacts.length > 0) {
-        sections.push("## Artifacts");
-        sections.push("");
-        for (const art of ast.artifacts) {
-            let line = `- **${art.id}** (${art.type})`;
-            if (art.path)
-                line += ` — path: ${art.path}`;
-            if (art.retention)
-                line += `, retention: ${art.retention}`;
-            if (art.dependsOn && art.dependsOn.length > 0)
-                line += `, depends on: ${art.dependsOn.join(", ")}`;
-            sections.push(line);
-        }
-        sections.push("");
-    }
-    // Observability
-    if (ast.observability && ast.observability.enabled) {
-        sections.push("## Observability");
-        sections.push("");
-        sections.push(`- Level: ${ast.observability.level}`);
-        sections.push(`- Exporter: ${ast.observability.exporter}`);
-        if (ast.observability.endpoint)
-            sections.push(`- Endpoint: ${ast.observability.endpoint}`);
-        if (ast.observability.service)
-            sections.push(`- Service: ${ast.observability.service}`);
-        sections.push(`- Sample rate: ${ast.observability.sampleRate}`);
-        const cap = ast.observability.capture;
-        if (cap) {
-            sections.push(`- Capture: prompts=${cap.prompts}, completions=${cap.completions}, tool-args=${cap.toolArgs}, tool-results=${cap.toolResults}`);
-        }
-        const sp = ast.observability.spans;
-        if (sp) {
-            sections.push(`- Spans: agents=${sp.agents}, tools=${sp.tools}, gates=${sp.gates}, memory=${sp.memory}`);
-        }
-        sections.push("");
-    }
-    // Checkpoint
-    if (ast.checkpoint) {
-        sections.push("## Checkpoint");
-        sections.push("");
-        sections.push(`- Backend: ${ast.checkpoint.backend}`);
-        sections.push(`- Strategy: ${ast.checkpoint.strategy}`);
-        if (ast.checkpoint.connection)
-            sections.push(`- Connection: ${ast.checkpoint.connection}`);
-        if (ast.checkpoint.ttl)
-            sections.push(`- TTL: ${ast.checkpoint.ttl}`);
-        if (ast.checkpoint.replay) {
-            sections.push(`- Replay: enabled=${ast.checkpoint.replay.enabled}${ast.checkpoint.replay.maxHistory ? `, maxHistory=${ast.checkpoint.replay.maxHistory}` : ""}${ast.checkpoint.replay.branch ? ", branching enabled" : ""}`);
-        }
-        sections.push("");
-    }
-    return {
-        path: ".kiro/steering/product.md",
-        content: sections.join("\n") + "\n",
-        category: "machine",
-    };
-}
-/**
- * Generate `.kiro/steering/tech.md` — technology context with models,
- * tool configuration, and provider settings.
- */
-function generateTechSteering(ast) {
-    const sections = [];
-    sections.push("---");
-    sections.push("inclusion: always");
-    sections.push("---");
-    sections.push("");
-    sections.push("# Technology");
-    sections.push("");
-    // Models used
-    const models = new Set();
-    for (const node of ast.nodes) {
-        if (node.type === "orchestrator") {
-            models.add(node.model);
-        }
-        else if (node.type === "agent" && node.model) {
-            models.add(node.model);
-        }
-    }
-    if (models.size > 0) {
-        sections.push("## Models");
-        sections.push("");
-        for (const model of models) {
-            sections.push(`- ${model}`);
-        }
-        sections.push("");
-    }
-    // Providers
-    if (ast.providers && ast.providers.length > 0) {
-        sections.push("## Providers");
-        sections.push("");
-        for (const p of ast.providers) {
-            const parts = [p.name];
-            if (p.baseUrl)
-                parts.push(`base: ${p.baseUrl}`);
-            if (p.default)
-                parts.push("(default)");
-            sections.push(`- ${parts.join(" — ")}`);
-        }
-        sections.push("");
-    }
-    // Tools
-    if (ast.toolDefs.length > 0) {
-        sections.push("## Tools");
-        sections.push("");
-        for (const tool of ast.toolDefs) {
-            sections.push(`- **${tool.id}**: ${tool.description}`);
-        }
-        sections.push("");
-    }
-    // Skills summary
-    if (ast.skills.length > 0) {
-        sections.push("## Skills");
-        sections.push("");
-        for (const skill of ast.skills) {
-            const desc = skill.description ? ` — ${skill.description}` : "";
-            sections.push(`- **${skill.id}**${desc}`);
-        }
-        sections.push("");
-    }
-    // Environment variables
-    if (Object.keys(ast.env).length > 0) {
-        sections.push("## Environment");
-        sections.push("");
-        for (const [key, val] of Object.entries(ast.env)) {
-            const value = typeof val === "string" ? val : val.value;
-            sections.push(`- \`${key}\`: ${value}`);
-        }
-        sections.push("");
-    }
-    return {
-        path: ".kiro/steering/tech.md",
-        content: sections.join("\n") + "\n",
-        category: "machine",
-    };
-}
-/**
- * Generate `.kiro/steering/structure.md` — file organization with
- * memory layout and read/write patterns.
- */
-function generateStructureSteering(ast) {
-    const sections = [];
-    sections.push("---");
-    sections.push("inclusion: always");
-    sections.push("---");
-    sections.push("");
-    sections.push("# Structure");
-    sections.push("");
-    // Memory layout
-    if (Object.keys(ast.memory).length > 0) {
-        sections.push("## Memory Layout");
-        sections.push("");
-        if (ast.memory.domains) {
-            sections.push("- **Domains:** .kiro/domains/");
-        }
-        if (ast.memory.references) {
-            sections.push("- **References:** .kiro/references/");
-        }
-        if (ast.memory.metrics) {
-            sections.push("- **Metrics:** .kiro/metrics.jsonl");
-        }
-        if (ast.memory.workspace) {
-            sections.push("- **Workspace:** .kiro/runs/");
-        }
-        sections.push("");
-    }
-    // Read/Write patterns
-    const agents = ast.nodes.filter((n) => n.type === "agent");
-    const agentsWithAccess = agents.filter((a) => (a.reads && a.reads.length > 0) || (a.writes && a.writes.length > 0));
-    if (agentsWithAccess.length > 0) {
-        sections.push("## Read/Write Patterns");
-        sections.push("");
-        for (const agent of agentsWithAccess) {
-            sections.push(`### ${toTitle(agent.id)}`);
-            if (agent.reads && agent.reads.length > 0) {
-                sections.push(`- Reads: ${agent.reads.join(", ")}`);
-            }
-            if (agent.writes && agent.writes.length > 0) {
-                sections.push(`- Writes: ${agent.writes.join(", ")}`);
-            }
-            sections.push("");
-        }
-    }
-    // Workspace protocol
-    const workspace = ast.memory.workspace;
-    if (workspace?.structure && Array.isArray(workspace.structure)) {
-        sections.push("## Workspace Structure");
-        sections.push("");
-        for (const item of workspace.structure) {
-            sections.push(`- ${item}`);
-        }
-        sections.push("");
-    }
-    return {
-        path: ".kiro/steering/structure.md",
-        content: sections.join("\n") + "\n",
-        category: "machine",
-    };
-}
-// ---------------------------------------------------------------------------
-// MCP configuration
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/settings/mcp.json` — MCP server configuration.
- *
- * Nearly identical to Claude Code's .mcp.json format: an object with a
- * `mcpServers` key mapping server names to their configuration.
- */
-function generateMcpJson(ast) {
-    if (Object.keys(ast.mcpServers).length === 0)
-        return null;
-    // Collect per-server autonomous status from agent declarations
-    // If ANY agent using this server has permissions: autonomous, use ["*"]
-    const serverHasAutonomousAgent = new Map();
-    const serverDisabledTools = new Map();
-    for (const node of ast.nodes) {
-        if (node.type !== "agent")
-            continue;
-        const agent = node;
-        if (!agent.mcpServers || agent.mcpServers.length === 0)
-            continue;
-        for (const serverName of agent.mcpServers) {
-            if (agent.permissions === "autonomous") {
-                serverHasAutonomousAgent.set(serverName, true);
-            }
-            // Agent disallowedTools -> disabledTools (only plain names, no patterns)
-            if (agent.disallowedTools && agent.disallowedTools.length > 0) {
-                if (!serverDisabledTools.has(serverName)) {
-                    serverDisabledTools.set(serverName, new Set());
-                }
-                for (const tool of agent.disallowedTools) {
-                    // Only include plain tool names (no parentheses = no patterns)
-                    if (!tool.includes("(")) {
-                        serverDisabledTools.get(serverName).add(tool);
-                    }
-                }
-            }
-        }
-    }
-    // Collect topology-level settings deny, filtering out patterns
-    const settingsDeny = ast.settings?.deny;
-    const mcpConfig = { mcpServers: {} };
-    const servers = mcpConfig.mcpServers;
-    for (const [name, config] of Object.entries(ast.mcpServers)) {
-        const entry = {};
-        let hasEnv = false;
-        for (const [key, value] of Object.entries(config)) {
-            if (key === "args" && Array.isArray(value)) {
-                entry.args = value;
-            }
-            else {
-                entry[key] = value;
-            }
-            if (key === "env")
-                hasEnv = true;
-        }
-        // Strip type field for stdio servers (Kiro auto-detects)
-        if (entry.command) {
-            delete entry.type;
-        }
-        // Always include env field
-        if (!hasEnv) {
-            entry.env = {};
-        }
-        // disabled: false by default
-        entry.disabled = false;
-        // autoApprove: ["*"] for autonomous agents, omit for supervised
-        if (serverHasAutonomousAgent.get(name)) {
-            entry.autoApprove = ["*"];
-        }
-        // disabledTools: merge agent-level disallowedTools + settings deny (plain names only)
-        const disableSet = new Set(serverDisabledTools.get(name) ?? []);
-        if (settingsDeny) {
-            for (const tool of settingsDeny) {
-                // Only include plain tool names (no parentheses = no patterns)
-                if (!tool.includes("(")) {
-                    disableSet.add(tool);
-                }
-            }
-        }
-        if (disableSet.size > 0) {
-            entry.disabledTools = [...disableSet];
-        }
-        servers[name] = entry;
-    }
-    return {
-        path: ".kiro/settings/mcp.json",
-        content: JSON.stringify(mcpConfig, null, 2) + "\n",
-        category: "machine",
-    };
-}
-// ---------------------------------------------------------------------------
-// Trigger / prompt files
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/prompts/<trigger-name>.md` — one file per trigger.
- */
-function generatePromptFiles(ast) {
-    const files = [];
-    for (const trigger of ast.triggers) {
-        const sections = [];
-        sections.push(`# /${trigger.name}`);
-        sections.push("");
-        sections.push(trigger.pattern);
-        sections.push("");
-        if (trigger.argument) {
-            sections.push("## Arguments");
-            sections.push(`- ${trigger.argument}: extracted from the command pattern`);
-            sections.push("");
-        }
-        // Pipeline (from edges)
-        if (ast.edges.length > 0) {
-            sections.push("## Pipeline");
-            for (const edge of ast.edges) {
-                let line = `${edge.from} -> ${edge.to}`;
-                if (edge.condition)
-                    line += ` [when ${edge.condition}]`;
-                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: `.kiro/prompts/${trigger.name}.md`,
-            content: sections.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// AGENTS.md — top-level project context with flow narrative
-// ---------------------------------------------------------------------------
-/**
- * Generate `AGENTS.md` — top-level project context.
- *
- * Kiro has no native orchestration, so the flow graph is expressed as
- * prose in AGENTS.md to give the AI context about the multi-agent workflow.
- */
-function generateAgentsMd(ast) {
-    const sections = [];
-    const name = ast.topology.name;
-    sections.push(`# ${toTitle(name)} — Agent Topology`);
-    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("");
-    // Orchestrator
-    const orch = ast.nodes.find((n) => n.type === "orchestrator");
-    if (orch) {
-        sections.push("## Orchestrator");
-        sections.push("");
-        sections.push(`Model: ${orch.model}`);
-        if (orch.handles?.length > 0) {
-            sections.push(`Handles: ${orch.handles.join(", ")}`);
-        }
-        if (orch.generates) {
-            sections.push(`Generates: ${orch.generates}`);
-        }
-        sections.push("");
-    }
-    // Flow (enhanced with Wave 2+ edge attributes)
-    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)
-                line += ` [when ${edge.condition}]`;
-            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("");
-    }
-    // Agent summary table
-    const agents = ast.nodes.filter((n) => n.type === "agent");
-    if (agents.length > 0) {
-        sections.push("## Agents");
-        sections.push("");
-        for (const agent of agents) {
-            sections.push(`### ${toTitle(agent.id)}`);
-            sections.push("");
-            const roleText = ast.roles[agent.role ?? ""] ?? ast.roles[agent.id] ?? agent.role;
-            if (roleText) {
-                sections.push(`**Role:** ${roleText}`);
-                sections.push("");
-            }
-            if (agent.description) {
-                sections.push(agent.description);
-                sections.push("");
-            }
-            if (agent.model) {
-                sections.push(`- **Model:** ${agent.model}`);
-            }
-            if (agent.phase != null) {
-                sections.push(`- **Phase:** ${agent.phase}`);
-            }
-            if (agent.tools && agent.tools.length > 0) {
-                sections.push(`- **Tools:** ${agent.tools.join(", ")}`);
-            }
-            if (agent.reads && agent.reads.length > 0) {
-                sections.push(`- **Reads:** ${agent.reads.join(", ")}`);
-            }
-            if (agent.writes && agent.writes.length > 0) {
-                sections.push(`- **Writes:** ${agent.writes.join(", ")}`);
-            }
-            if (agent.behavior) {
-                sections.push(`- **Behavior:** ${agent.behavior}`);
-            }
-            sections.push("");
-        }
-    }
-    // Gates
-    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: ${gateAnchors(gate, "after").join(", ")}`);
-            if (gate.before)
-                sections.push(`Before: ${gateAnchors(gate, "before").join(", ")}`);
-            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}`);
-            sections.push("");
-        }
-    }
-    // Human nodes
-    const humans = ast.nodes.filter((n) => n.type === "human");
-    if (humans.length > 0) {
-        sections.push("## Human Pause Points");
-        sections.push("");
-        for (const human of humans) {
-            sections.push(`### ${toTitle(human.id)}`);
-            if (human.description)
-                sections.push(human.description);
-            if (human.timeout)
-                sections.push(`- **Timeout:** ${human.timeout}`);
-            if (human.onTimeout)
-                sections.push(`- **On timeout:** ${human.onTimeout}`);
-            sections.push("");
-        }
-    }
-    // Group nodes
-    const groups = ast.nodes.filter((n) => n.type === "group");
-    if (groups.length > 0) {
-        sections.push("## Group Chats");
-        sections.push("");
-        for (const group of groups) {
-            sections.push(`### ${toTitle(group.id)}`);
-            if (group.description)
-                sections.push(group.description);
-            sections.push(`- **Members:** ${group.members.join(", ")}`);
-            if (group.speakerSelection)
-                sections.push(`- **Speaker selection:** ${group.speakerSelection}`);
-            if (group.maxRounds != null)
-                sections.push(`- **Max rounds:** ${group.maxRounds}`);
-            if (group.termination)
-                sections.push(`- **Termination:** ${group.termination}`);
-            if (group.timeout)
-                sections.push(`- **Timeout:** ${group.timeout}`);
-            sections.push("");
-        }
-    }
-    // Triggers
-    if (ast.triggers.length > 0) {
-        sections.push("## Triggers");
-        sections.push("");
-        for (const trigger of ast.triggers) {
-            sections.push(`### /${trigger.name}`);
-            sections.push(`Pattern: \`${trigger.pattern}\``);
-            if (trigger.argument)
-                sections.push(`Argument: ${trigger.argument}`);
-            sections.push("");
-        }
-    }
-    return {
-        path: "AGENTS.md",
-        content: sections.join("\n") + "\n",
-        category: "agent",
-    };
-}
-// ---------------------------------------------------------------------------
-// Hook scripts
-// ---------------------------------------------------------------------------
-/** Generate hook script stubs under .kiro/scripts/. */
-function generateHookScripts(ast) {
-    const files = [];
-    for (const hook of ast.hooks) {
-        if (!hook.run)
-            continue;
-        const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
-        files.push({
-            path: `.kiro/scripts/${scriptName}`,
-            content: [
-                "#!/usr/bin/env bash",
-                `# Hook: ${hook.name} — fires on ${mapHookEvent(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;
-}
-// ---------------------------------------------------------------------------
-// Gate scripts
-// ---------------------------------------------------------------------------
-/** Generate gate script stubs under .kiro/scripts/. */
-function generateGateScripts(ast) {
-    const files = [];
-    for (const node of ast.nodes) {
-        if (node.type !== "gate")
-            continue;
-        const gate = node;
-        if (gate.run) {
-            const scriptName = gate.run.replace(/^.*\//, "").replace(/\s.*$/, "");
-            files.push({
-                path: `.kiro/scripts/${scriptName}`,
-                content: shellStub(`Gate: ${gate.id} — ${gate.run}`),
-                category: "script",
-            });
-        }
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Tool scripts
-// ---------------------------------------------------------------------------
-/** Generate tool script stubs under .kiro/scripts/. */
-function generateToolScripts(ast) {
-    const files = [];
-    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: `.kiro/scripts/${tool.id}.${ext}`,
-            content: lines.join("\n"),
-            category: "script",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Memory directories
-// ---------------------------------------------------------------------------
-/** Generate memory structure directories under .kiro/. */
-function generateMemory(ast) {
-    const files = [];
-    if (ast.memory.domains) {
-        files.push(gitkeep(".kiro/domains"));
-    }
-    if (ast.memory.references) {
-        files.push(gitkeep(".kiro/references"));
-    }
-    if (ast.memory.metrics) {
-        files.push({
-            path: ".kiro/metrics.jsonl",
-            content: "",
-            category: "machine",
-        });
-    }
-    if (ast.memory.workspace) {
-        files.push(gitkeep(".kiro/runs"));
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Metering script
-// ---------------------------------------------------------------------------
-/** 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",
-    };
-}
-// ---------------------------------------------------------------------------
-// Gate hooks
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/hooks/gate-{id}.kiro.hook` JSON files for each enforced gate.
- *
- * Kiro hooks are individual JSON files in `.kiro/hooks/` with trigger metadata.
- * Each gate with `run:` and non-advisory behavior gets a hook file that
- * fires when files in the gate's `after` agent's writes paths are edited.
- */
-function generateGateHooks(ast) {
-    const files = [];
-    // Build a map of agent writes paths for file pattern matching
-    const agentWrites = new Map();
-    for (const node of ast.nodes) {
-        if (node.type !== "agent")
-            continue;
-        const agent = node;
-        if (agent.writes && agent.writes.length > 0) {
-            agentWrites.set(agent.id, agent.writes);
-        }
-    }
-    for (const node of ast.nodes) {
-        if (node.type !== "gate")
-            continue;
-        const gate = node;
-        if (!gate.run)
-            continue;
-        if (gate.behavior === "advisory")
-            continue;
-        const scriptName = gate.run.replace(/^.*\//, "").replace(/\s.*$/, "");
-        // Derive file patterns from the `after` agent's writes paths
-        const afterWrites = gate.after ? gateAnchors(gate, "after").flatMap((a) => agentWrites.get(a) ?? []) : undefined;
-        const filePatterns = afterWrites
-            ? afterWrites.map((p) => p.replace(/\/$/, "/**"))
-            : ["workspace/**"];
-        const hookJson = {
-            enabled: true,
-            name: `${toTitle(gate.id)} Gate`,
-            description: `Quality gate that runs after ${gateAnchors(gate, "after").join(", ") || "any agent"}${gate.before ? ` and before ${gateAnchors(gate, "before").join(", ")}` : ""}.${gate.checks && gate.checks.length > 0 ? ` Checks: ${gate.checks.join(", ")}.` : ""}`,
-            version: "1",
-            when: {
-                type: "fileEdited",
-                patterns: filePatterns,
-            },
-            then: {
-                type: "runCommand",
-                command: `.kiro/scripts/${scriptName}`,
-            },
-        };
-        files.push({
-            path: `.kiro/hooks/gate-${gate.id}.kiro.hook`,
-            content: JSON.stringify(hookJson, null, 2) + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Specs directory
-// ---------------------------------------------------------------------------
-/**
- * Generate `.kiro/specs/` directory with Kiro-standard spec files.
- *
- * Only generates files when the topology has sufficient content to populate
- * them meaningfully (description, agents, flow, etc.).
- *
- * - `requirements.md` — populated from topology description + agent roles
- * - `design.md` — populated from flow and architecture
- * - `tasks.md` — populated from agents and their phases
- */
-function generateSpecs(ast) {
-    const files = [];
-    const agents = ast.nodes.filter((n) => n.type === "agent");
-    // Only generate specs if there is meaningful content
-    const hasDescription = !!ast.topology.description;
-    const hasAgents = agents.length > 0;
-    const hasEdges = ast.edges.length > 0;
-    if (!hasDescription && !hasAgents)
-        return files;
-    // --- requirements.md ---
-    if (hasDescription || hasAgents) {
-        const req = [];
-        req.push(`# Requirements — ${toTitle(ast.topology.name)}`);
-        req.push("");
-        if (ast.topology.description) {
-            req.push("## Overview");
-            req.push("");
-            req.push(ast.topology.description);
-            req.push("");
-        }
-        if (Object.keys(ast.roles).length > 0) {
-            req.push("## Agent Roles");
-            req.push("");
-            for (const [role, desc] of Object.entries(ast.roles)) {
-                req.push(`- **${toTitle(role)}**: ${desc}`);
-            }
-            req.push("");
-        }
-        if (agents.length > 0) {
-            req.push("## Functional Requirements");
-            req.push("");
-            for (const agent of agents) {
-                const desc = agent.description ??
-                    ast.roles[agent.role ?? ""] ??
-                    ast.roles[agent.id] ??
-                    "";
-                if (desc) {
-                    req.push(`- **${toTitle(agent.id)}**: ${desc}`);
-                }
-            }
-            req.push("");
-        }
-        // Gates as quality requirements
-        const gates = ast.nodes.filter((n) => n.type === "gate");
-        if (gates.length > 0) {
-            req.push("## Quality Gates");
-            req.push("");
-            for (const gate of gates) {
-                let line = `- **${toTitle(gate.id)}**`;
-                if (gate.checks && gate.checks.length > 0) {
-                    line += `: checks ${gate.checks.join(", ")}`;
-                }
-                if (gate.onFail)
-                    line += ` (on fail: ${gate.onFail})`;
-                req.push(line);
-            }
-            req.push("");
-        }
-        files.push({
-            path: `.kiro/specs/${ast.topology.name}/requirements.md`,
-            content: req.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    // --- design.md ---
-    if (hasEdges || hasAgents) {
-        const design = [];
-        design.push(`# Design — ${toTitle(ast.topology.name)}`);
-        design.push("");
-        if (ast.topology.patterns.length > 0) {
-            design.push("## Architecture Patterns");
-            design.push("");
-            design.push(ast.topology.patterns.map((p) => `- ${p}`).join("\n"));
-            design.push("");
-        }
-        // Orchestrator
-        const orch = ast.nodes.find((n) => n.type === "orchestrator");
-        if (orch) {
-            design.push("## Orchestrator");
-            design.push("");
-            design.push(`Model: ${orch.model}`);
-            if (orch.handles?.length > 0) {
-                design.push(`Handles: ${orch.handles.join(", ")}`);
-            }
-            design.push("");
-        }
-        if (hasEdges) {
-            design.push("## Flow Graph");
-            design.push("");
-            for (const edge of ast.edges) {
-                const arrow = edge.isError ? `-x->` : "->";
-                let line = `- ${edge.from} ${arrow} ${edge.to}`;
-                if (edge.condition)
-                    line += ` [when ${edge.condition}]`;
-                if (edge.maxIterations)
-                    line += ` [max ${edge.maxIterations}]`;
-                design.push(line);
-            }
-            design.push("");
-        }
-        // MCP servers as integration points
-        if (Object.keys(ast.mcpServers).length > 0) {
-            design.push("## Integration Points (MCP Servers)");
-            design.push("");
-            for (const [name, config] of Object.entries(ast.mcpServers)) {
-                const stype = config.type ?? "stdio";
-                design.push(`- **${name}** (${stype})`);
-            }
-            design.push("");
-        }
-        files.push({
-            path: `.kiro/specs/${ast.topology.name}/design.md`,
-            content: design.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    // --- tasks.md ---
-    if (hasAgents) {
-        const tasks = [];
-        tasks.push(`# Tasks — ${toTitle(ast.topology.name)}`);
-        tasks.push("");
-        // Group agents by phase
-        const phased = agents
-            .filter((a) => a.phase != null)
-            .sort(byPhase);
-        const unphased = agents.filter((a) => a.phase == null);
-        if (phased.length > 0) {
-            let currentPhase = -1;
-            for (const agent of phased) {
-                if (agent.phase !== currentPhase) {
-                    currentPhase = agent.phase;
-                    tasks.push(`## Phase ${currentPhase}`);
-                    tasks.push("");
-                }
-                const desc = agent.description ??
-                    ast.roles[agent.role ?? ""] ??
-                    "";
-                tasks.push(`- [ ] **${toTitle(agent.id)}**${desc ? `: ${desc}` : ""}`);
-                if (agent.tools && agent.tools.length > 0) {
-                    tasks.push(`  - Tools: ${agent.tools.join(", ")}`);
-                }
-                if (agent.mcpServers && agent.mcpServers.length > 0) {
-                    tasks.push(`  - MCP: ${agent.mcpServers.join(", ")}`);
-                }
-            }
-            tasks.push("");
-        }
-        if (unphased.length > 0) {
-            tasks.push("## Unphased");
-            tasks.push("");
-            for (const agent of unphased) {
-                const desc = agent.description ??
-                    ast.roles[agent.role ?? ""] ??
-                    "";
-                tasks.push(`- [ ] **${toTitle(agent.id)}**${desc ? `: ${desc}` : ""}`);
-            }
-            tasks.push("");
-        }
-        files.push({
-            path: `.kiro/specs/${ast.topology.name}/tasks.md`,
-            content: tasks.join("\n") + "\n",
-            category: "machine",
-        });
-    }
-    return files;
-}
-// ---------------------------------------------------------------------------
-// Binding export
-// ---------------------------------------------------------------------------
-/** Kiro CLI binding — generates .kiro/ directory structure and AGENTS.md. */
-export const kiroBinding = {
-    name: "kiro",
-    description: "AWS Kiro CLI — generates .kiro/ directory with JSON agents, steering docs, MCP config, and prompts.",
-    scaffold(ast) {
-        const files = [];
-        // 1. Agent JSON files
-        files.push(...generateAgents(ast));
-        // 2. Steering documents
-        files.push(generateProductSteering(ast));
-        files.push(generateTechSteering(ast));
-        files.push(generateStructureSteering(ast));
-        // 2b. Per-agent behavioral steering docs (Wave 1-7)
-        files.push(...generateAgentSteering(ast));
-        // 2c. Human node steering docs (Wave 5)
-        files.push(...generateHumanSteering(ast));
-        // 2d. Group node steering docs (Wave 5)
-        files.push(...generateGroupSteering(ast));
-        // 3. MCP configuration
-        const mcpFile = generateMcpJson(ast);
-        if (mcpFile)
-            files.push(mcpFile);
-        // 4. Prompt files (triggers)
-        files.push(...generatePromptFiles(ast));
-        // 5. AGENTS.md (top-level flow narrative)
-        files.push(generateAgentsMd(ast));
-        // 6. Hook scripts
-        files.push(...generateHookScripts(ast));
-        // 7. Gate scripts
-        files.push(...generateGateScripts(ast));
-        // 8. Gate hook files
-        files.push(...generateGateHooks(ast));
-        // 9. Tool scripts
-        files.push(...generateToolScripts(ast));
-        // 10. Memory directories
-        files.push(...generateMemory(ast));
-        // 11. Metering
-        const meteringFile = generateMetering(ast);
-        if (meteringFile)
-            files.push(meteringFile);
-        // 12. Specs directory (.kiro/specs/)
-        files.push(...generateSpecs(ast));
-        return deduplicateFiles(files);
-    },
-};
-//# sourceMappingURL=kiro.js.map