agentopology 0.9.2 → 0.10.0

package/dist/bindings/__tests__/bindings.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { parse } from "../../parser/index.js";
-import { bindings, claudeCodeBinding, kiroBinding, cursorBinding, } from "../index.js";
+import { bindings, claudeCodeBinding, cursorBinding, } from "../index.js";
 import { isStubContent, STUB_MARKER } from "../lib/stub.js";
 // ---------------------------------------------------------------------------
 // Minimal but valid .at topology exercising most features
@@ -156,8 +156,8 @@ function assertStructuralInvariants(files) {
 // Registry tests
 // ---------------------------------------------------------------------------
 describe("Binding registry", () => {
-    it("contains all 8 bindings", () => {
-        expect(Object.keys(bindings)).toHaveLength(8);
+    it("contains the 4 bindings: claude-code, and experimental codex, cursor, claude-workflow", () => {
+        expect(Object.keys(bindings).sort()).toEqual(["claude-code", "claude-workflow", "codex", "cursor"]);
     });
     it("all bindings have a name and description", () => {
         for (const [key, binding] of Object.entries(bindings)) {
@@ -875,675 +875,6 @@ describe("codex binding", () => {
         expect(agentsMd.content).toContain("**Model:** opus");
     });
 });
-// ---------------------------------------------------------------------------
-// gemini-cli
-// ---------------------------------------------------------------------------
-describe("gemini-cli binding", () => {
-    const files = scaffoldBinding("gemini-cli");
-    assertStructuralInvariants(files);
-    it("produces .gemini/CONTEXT.md context file (never root GEMINI.md)", () => {
-        const geminiMd = files.find((f) => f.path === ".gemini/CONTEXT.md");
-        expect(geminiMd).toBeDefined();
-        // Must never generate root-level GEMINI.md
-        const rootGeminiMd = files.find((f) => f.path === "GEMINI.md");
-        expect(rootGeminiMd).toBeUndefined();
-    });
-    it("produces .gemini/settings.json", () => {
-        const settings = files.find((f) => f.path === ".gemini/settings.json");
-        expect(settings).toBeDefined();
-        const parsed = JSON.parse(settings.content);
-        expect(parsed).toBeDefined();
-    });
-    it("produces .gemini/instructions.md", () => {
-        const instructions = files.find((f) => f.path === ".gemini/instructions.md");
-        expect(instructions).toBeDefined();
-    });
-    it("produces command files from triggers as .toml", () => {
-        const cmdFile = files.find((f) => f.path === ".gemini/commands/run.toml");
-        expect(cmdFile).toBeDefined();
-        expect(cmdFile.content).toContain('description =');
-        expect(cmdFile.content).toContain('prompt = """');
-    });
-    it("settings.json uses real Gemini CLI structure", () => {
-        const settings = files.find((f) => f.path === ".gemini/settings.json");
-        expect(settings).toBeDefined();
-        const parsed = JSON.parse(settings.content);
-        // general.defaultApprovalMode instead of toolApproval
-        expect(parsed.general).toBeDefined();
-        expect(parsed.general.defaultApprovalMode).toBeDefined();
-        expect(["default", "auto_edit", "plan"]).toContain(parsed.general.defaultApprovalMode);
-        // model.name only set for Gemini-compatible model names
-        // (non-Gemini models like haiku/opus are omitted to avoid crashing the CLI)
-        if (parsed.model) {
-            expect(parsed.model.name).toBeDefined();
-        }
-        // context.fileName points to the context file
-        expect(parsed.context).toBeDefined();
-        expect(parsed.context.fileName).toBe(".gemini/CONTEXT.md");
-        // No fictional keys
-        expect(parsed).not.toHaveProperty("toolApproval");
-        expect(parsed).not.toHaveProperty("allowedTools");
-        expect(parsed).not.toHaveProperty("deniedTools");
-        expect(parsed).not.toHaveProperty("thinkingConfig");
-        expect(parsed).not.toHaveProperty("modelConfig");
-        expect(parsed).not.toHaveProperty("sandbox");
-    });
-    it("includes MCP servers in settings.json (not separate file)", () => {
-        const settings = files.find((f) => f.path === ".gemini/settings.json");
-        const parsed = JSON.parse(settings.content);
-        expect(parsed.mcpServers).toBeDefined();
-        expect(parsed.mcpServers.filesystem).toBeDefined();
-        // No separate MCP file
-        const mcpFile = files.find((f) => f.path === ".gemini/settings/mcp.json");
-        expect(mcpFile).toBeUndefined();
-    });
-    it("includes hooks in settings.json with correct event mapping", () => {
-        const settings = files.find((f) => f.path === ".gemini/settings.json");
-        const parsed = JSON.parse(settings.content);
-        // The test topology has a PostToolUse hook -> should map to AfterTool
-        expect(parsed.hooks).toBeDefined();
-        expect(parsed.hooks.AfterTool).toBeDefined();
-        expect(parsed.hooksConfig).toEqual({ enabled: true });
-    });
-});
-// ---------------------------------------------------------------------------
-// copilot-cli
-// ---------------------------------------------------------------------------
-describe("copilot-cli binding", () => {
-    const files = scaffoldBinding("copilot-cli");
-    assertStructuralInvariants(files);
-    it("produces .github/copilot-instructions.md", () => {
-        const instructions = files.find((f) => f.path === ".github/copilot-instructions.md");
-        expect(instructions).toBeDefined();
-        expect(instructions.content.length).toBeGreaterThan(0);
-    });
-    it("produces .github/instructions/*.instructions.md for each agent", () => {
-        const agentFiles = files.filter((f) => f.path.match(/\.github\/instructions\/.*\.instructions\.md$/));
-        expect(agentFiles.length).toBeGreaterThanOrEqual(2);
-        const paths = agentFiles.map((f) => f.path);
-        expect(paths).toContain(".github/instructions/planner.instructions.md");
-        expect(paths).toContain(".github/instructions/builder.instructions.md");
-    });
-    it("uses applyTo frontmatter derived from reads/writes paths", () => {
-        const planner = files.find((f) => f.path === ".github/instructions/planner.instructions.md");
-        expect(planner).toBeDefined();
-        expect(planner.content).toContain("applyTo:");
-        expect(planner.content).toContain("workspace/input.md");
-        expect(planner.content).toContain("workspace/plan.md");
-    });
-    it("does NOT include fictional frontmatter keys (tools, model, sandbox)", () => {
-        const builder = files.find((f) => f.path === ".github/instructions/builder.instructions.md");
-        expect(builder).toBeDefined();
-        // Frontmatter should only contain applyTo
-        const fmMatch = builder.content.match(/---\n([\s\S]*?)\n---/);
-        expect(fmMatch).toBeDefined();
-        const fmContent = fmMatch[1];
-        expect(fmContent).not.toContain("tools:");
-        expect(fmContent).not.toContain("model:");
-        expect(fmContent).not.toContain("sandbox:");
-        expect(fmContent).not.toContain("name:");
-        expect(fmContent).not.toContain("permissions:");
-    });
-    it("generates gate script for enforced gate", () => {
-        const gateScript = files.find((f) => f.path === "scripts/gate-quality-check.sh");
-        expect(gateScript).toBeDefined();
-        expect(gateScript.content).toContain("lint.sh");
-    });
-    it("does NOT generate gate script for advisory gate", () => {
-        const advisoryScript = files.find((f) => f.path === "scripts/gate-soft-review.sh");
-        expect(advisoryScript).toBeUndefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// openclaw
-// ---------------------------------------------------------------------------
-describe("openclaw binding", () => {
-    const files = scaffoldBinding("openclaw");
-    assertStructuralInvariants(files);
-    it("produces openclaw.json with correct schema", () => {
-        const config = files.find((f) => f.path === "openclaw.json");
-        expect(config).toBeDefined();
-        const parsed = JSON.parse(config.content);
-        expect(parsed).toBeDefined();
-        // agents.defaults exists with workspace and model
-        expect(parsed.agents.defaults).toBeDefined();
-        expect(parsed.agents.defaults.workspace).toBe("~/.openclaw/workspace");
-        expect(parsed.agents.defaults.model.primary).toContain("anthropic/claude-");
-        // Agent models use provider/model-id format
-        const agentList = parsed.agents.list;
-        expect(agentList.length).toBeGreaterThan(0);
-        for (const agent of agentList) {
-            expect(agent.model.primary).toMatch(/^[a-z]+\/claude-/);
-        }
-        // Gateway auth uses mode: "token" format
-        expect(parsed.gateway.auth.mode).toBe("token");
-        expect(parsed.gateway.auth.token).toBeDefined();
-        expect(parsed.gateway.auth).not.toHaveProperty("requireToken");
-        // models.providers instead of top-level providers array
-        expect(parsed.models).toBeDefined();
-        expect(parsed.models.providers).toBeDefined();
-        expect(parsed.models.providers.anthropic).toBeDefined();
-        expect(parsed).not.toHaveProperty("providers");
-        // Tools have flat allow/deny, no "defaults" nesting
-        expect(parsed.tools.allow).toBeDefined();
-        expect(parsed.tools.deny).toBeDefined();
-        expect(parsed.tools.agentToAgent.enabled).toBe(true);
-        expect(parsed.tools).not.toHaveProperty("defaults");
-        // No unknown top-level keys
-        expect(parsed).not.toHaveProperty("modelFallbackChain");
-        expect(parsed).not.toHaveProperty("sandboxDefaults");
-        expect(parsed).not.toHaveProperty("defaults");
-    });
-    it("produces SOUL.md", () => {
-        const soul = files.find((f) => f.path === "SOUL.md");
-        expect(soul).toBeDefined();
-    });
-    it("produces AGENTS.md with tool restrictions and topology overview", () => {
-        const agents = files.find((f) => f.path === "AGENTS.md");
-        expect(agents).toBeDefined();
-        expect(agents.content).toContain("planner");
-        // Tool restrictions in AGENTS.md
-        expect(agents.content).toContain("Tools allowed:");
-        // Topology overview merged from TEAM.md
-        expect(agents.content).toContain("Topology Overview");
-    });
-    it("produces TOOLS.md", () => {
-        const tools = files.find((f) => f.path === "TOOLS.md");
-        expect(tools).toBeDefined();
-    });
-    it("produces MEMORY.md", () => {
-        const memory = files.find((f) => f.path === "MEMORY.md");
-        expect(memory).toBeDefined();
-    });
-    it("produces BOOTSTRAP.md", () => {
-        const bootstrap = files.find((f) => f.path === "BOOTSTRAP.md");
-        expect(bootstrap).toBeDefined();
-    });
-    it("does NOT produce TEAM.md", () => {
-        const team = files.find((f) => f.path === "TEAM.md");
-        expect(team).toBeUndefined();
-    });
-    it("produces USER.md", () => {
-        const user = files.find((f) => f.path === "USER.md");
-        expect(user).toBeDefined();
-        expect(user.content).toContain("User Profile");
-    });
-    it("produces IDENTITY.md", () => {
-        const identity = files.find((f) => f.path === "IDENTITY.md");
-        expect(identity).toBeDefined();
-        expect(identity.content).toContain("Identity");
-        expect(identity.content).toContain("Name:");
-    });
-    it("produces memory/ and skills/ directories", () => {
-        const memoryDir = files.find((f) => f.path === "memory/.gitkeep");
-        const skillsDir = files.find((f) => f.path === "skills/.gitkeep");
-        expect(memoryDir).toBeDefined();
-        expect(skillsDir).toBeDefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// kiro (deep)
-// ---------------------------------------------------------------------------
-describe("kiro binding (deep)", () => {
-    // A richer topology that exercises: multiple agents with tools/prompts,
-    // hooks, triggers, mcp-servers, gates, memory, and different tool mappings.
-    const RICH_TOPOLOGY = `
-topology deep-kiro-test : [pipeline, fan-out] {
-
-  meta {
-    version: "2.0.0"
-    description: "Rich topology for deep Kiro binding tests"
-  }
-
-  orchestrator {
-    model: opus
-    generates: "plans/run.md"
-    handles: [ingest]
-  }
-
-  roles {
-    analyzer: "Analyzes incoming data and produces structured reports"
-    coder: "Writes and modifies source code"
-    reviewer: "Reviews code changes for quality"
-  }
-
-  action ingest {
-    kind: external
-    source: "webhook"
-    description: "Ingest data from webhook"
-  }
-
-  agent analyzer {
-    role: analyzer
-    model: sonnet
-    phase: 1
-    tools: [Read, Grep]
-    reads: ["workspace/raw.md"]
-    writes: ["workspace/analysis.md"]
-    permissions: supervised
-    outputs: {
-      quality: good | bad | unknown
-    }
-    prompt {
-      Carefully analyze all incoming data.
-      Produce a structured report with findings.
-    }
-  }
-
-  agent coder {
-    role: coder
-    model: opus
-    phase: 2
-    tools: [Read, Write, Bash, Edit]
-    reads: ["workspace/analysis.md"]
-    writes: ["workspace/code/"]
-    permissions: autonomous
-    mcp-servers: [filesystem, github]
-    prompt {
-      Implement code changes based on the analysis report.
-      Follow existing patterns in the codebase.
-    }
-    hooks {
-      hook coder-post-write {
-        on: PostToolUse
-        matcher: Write
-        run: "scripts/format.sh"
-        type: command
-      }
-    }
-  }
-
-  agent reviewer {
-    role: reviewer
-    model: haiku
-    phase: 3
-    tools: [Read, Bash]
-    reads: ["workspace/code/"]
-    writes: ["workspace/review.md"]
-    permissions: supervised
-  }
-
-  flow {
-    ingest -> analyzer
-    analyzer -> coder    [when analyzer.quality == good]
-    coder -> reviewer
-    reviewer -> coder    [when reviewer.verdict == revise] [max 3]
-  }
-
-  gates {
-    gate lint-gate {
-      after: coder
-      run: "scripts/lint-check.sh"
-      checks: [lint, types, format]
-      on-fail: halt
-    }
-    gate security-gate {
-      before: reviewer
-      run: "scripts/security-scan.sh"
-      checks: [cve, secrets]
-      on-fail: halt
-    }
-  }
-
-  triggers {
-    command analyze {
-      pattern: "/analyze <INPUT>"
-      argument: INPUT
-    }
-    command deploy {
-      pattern: "/deploy <ENV>"
-      argument: ENV
-    }
-  }
-
-  hooks {
-    hook global-post-write {
-      on: PostToolUse
-      matcher: Write
-      run: "scripts/post-write.sh"
-      type: command
-    }
-    hook pre-bash {
-      on: PreToolUse
-      matcher: Bash
-      run: "scripts/pre-bash.sh"
-      type: command
-    }
-  }
-
-  mcp-servers {
-    filesystem {
-      command: "npx"
-      args: ["-y", "@modelcontextprotocol/server-filesystem"]
-    }
-    github {
-      command: "npx"
-      args: ["-y", "@modelcontextprotocol/server-github"]
-      env: {
-        GITHUB_TOKEN: "\${GITHUB_TOKEN}"
-      }
-    }
-  }
-
-  memory {
-    domains: true
-    references: true
-    metrics: true
-    workspace {
-      path: "workspace/"
-      structure: [raw, analysis, code, review]
-    }
-  }
-
-  settings {
-    allow: ["Read", "Grep", "Glob"]
-    deny: ["Bash"]
-  }
-}
-`;
-    const richAst = parse(RICH_TOPOLOGY);
-    const files = kiroBinding.scaffold(richAst);
-    // 1. Agent JSON validity
-    describe("agent JSON validity", () => {
-        const agentFiles = files.filter((f) => f.path.match(/\.kiro\/agents\/.*\.json$/));
-        it("produces a JSON file for each agent", () => {
-            expect(agentFiles.length).toBe(3);
-            const paths = agentFiles.map((f) => f.path);
-            expect(paths).toContain(".kiro/agents/analyzer.json");
-            expect(paths).toContain(".kiro/agents/coder.json");
-            expect(paths).toContain(".kiro/agents/reviewer.json");
-        });
-        it("each agent JSON has id (name), description, and instructions (prompt) fields", () => {
-            for (const f of agentFiles) {
-                const json = JSON.parse(f.content);
-                expect(json.name, `${f.path} should have a name field`).toBeDefined();
-                expect(typeof json.name).toBe("string");
-                expect(json.name.length).toBeGreaterThan(0);
-                expect(json.description, `${f.path} should have a description field`).toBeDefined();
-                expect(typeof json.description).toBe("string");
-                expect(json.description.length).toBeGreaterThan(0);
-                expect(json.prompt, `${f.path} should have a prompt (instructions) field`).toBeDefined();
-                expect(typeof json.prompt).toBe("string");
-                expect(json.prompt.length).toBeGreaterThan(0);
-            }
-        });
-    });
-    // 2. Steering docs have YAML frontmatter
-    describe("steering docs", () => {
-        const steeringFiles = files.filter((f) => f.path.startsWith(".kiro/steering/"));
-        it("produces at least 3 steering files", () => {
-            expect(steeringFiles.length).toBeGreaterThanOrEqual(3);
-        });
-        it("each steering file starts with YAML frontmatter (---)", () => {
-            for (const f of steeringFiles) {
-                expect(f.content.startsWith("---"), `${f.path} should start with YAML frontmatter (---)`).toBe(true);
-                // Should have closing frontmatter delimiter too
-                const secondDash = f.content.indexOf("---", 3);
-                expect(secondDash, `${f.path} should have closing --- in frontmatter`).toBeGreaterThan(3);
-            }
-        });
-    });
-    // 3. MCP config matches topology's mcp-servers
-    describe("MCP config", () => {
-        const mcpFile = files.find((f) => f.path === ".kiro/settings/mcp.json");
-        it("produces valid JSON for mcp.json", () => {
-            expect(mcpFile).toBeDefined();
-            expect(() => JSON.parse(mcpFile.content)).not.toThrow();
-        });
-        it("contains all declared MCP servers", () => {
-            const mcp = JSON.parse(mcpFile.content);
-            expect(mcp.mcpServers).toBeDefined();
-            expect(mcp.mcpServers.filesystem).toBeDefined();
-            expect(mcp.mcpServers.github).toBeDefined();
-        });
-        it("server entries have command and args fields", () => {
-            const mcp = JSON.parse(mcpFile.content);
-            for (const [name, config] of Object.entries(mcp.mcpServers)) {
-                expect(config.command, `MCP server "${name}" should have a command`).toBeDefined();
-                expect(config.args, `MCP server "${name}" should have args`).toBeDefined();
-            }
-        });
-        it("preserves env field from topology", () => {
-            const mcp = JSON.parse(mcpFile.content);
-            // The parser stores env as-is from the topology; verify it exists on each server
-            for (const [name, config] of Object.entries(mcp.mcpServers)) {
-                expect(config.env, `MCP server "${name}" should have an env field`).toBeDefined();
-            }
-        });
-    });
-    // 4. Hook mapping — verify hook/gate scripts are generated
-    describe("hook mapping", () => {
-        it("generates script stubs for global hooks", () => {
-            const postWriteScript = files.find((f) => f.path === ".kiro/scripts/post-write.sh");
-            expect(postWriteScript, "should generate post-write.sh for global-post-write hook").toBeDefined();
-            expect(postWriteScript.content).toContain("postToolUse");
-            const preBashScript = files.find((f) => f.path === ".kiro/scripts/pre-bash.sh");
-            expect(preBashScript, "should generate pre-bash.sh for pre-bash hook").toBeDefined();
-            expect(preBashScript.content).toContain("preToolUse");
-        });
-        it("generates script stubs for gate scripts", () => {
-            const lintScript = files.find((f) => f.path === ".kiro/scripts/lint-check.sh");
-            expect(lintScript, "should generate lint-check.sh for lint-gate").toBeDefined();
-            expect(lintScript.content).toContain("lint-gate");
-            const securityScript = files.find((f) => f.path === ".kiro/scripts/security-scan.sh");
-            expect(securityScript, "should generate security-scan.sh for security-gate").toBeDefined();
-            expect(securityScript.content).toContain("security-gate");
-        });
-    });
-    // 5. Flow as prose — verify AGENTS.md contains agent names and flow description
-    describe("flow as prose in AGENTS.md", () => {
-        const agentsMd = files.find((f) => f.path === "AGENTS.md");
-        it("AGENTS.md is generated", () => {
-            expect(agentsMd).toBeDefined();
-        });
-        it("contains all agent names", () => {
-            const content = agentsMd.content;
-            expect(content).toContain("analyzer");
-            expect(content).toContain("coder");
-            expect(content).toContain("reviewer");
-        });
-        it("contains a Flow section with edge descriptions", () => {
-            const content = agentsMd.content;
-            expect(content).toContain("## Flow");
-            expect(content).toContain("analyzer -> coder");
-            expect(content).toContain("coder -> reviewer");
-            expect(content).toContain("reviewer -> coder");
-        });
-        it("contains gate descriptions", () => {
-            const content = agentsMd.content;
-            // Gate ids are title-cased in AGENTS.md (lint-gate -> Lint Gate)
-            expect(content).toContain("Lint Gate");
-            expect(content).toContain("Security Gate");
-        });
-        it("contains trigger descriptions", () => {
-            const content = agentsMd.content;
-            expect(content).toContain("/analyze");
-            expect(content).toContain("/deploy");
-        });
-    });
-    // 6. Tool mapping — verify mapped tool names in agent instructions
-    describe("tool mapping", () => {
-        it("maps Read to 'read' in agent tools", () => {
-            const analyzerFile = files.find((f) => f.path === ".kiro/agents/analyzer.json");
-            const json = JSON.parse(analyzerFile.content);
-            expect(json.tools).toContain("read");
-        });
-        it("maps Write to 'write' in agent tools", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            expect(json.tools).toContain("write");
-        });
-        it("maps Bash to 'shell' in agent tools", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            expect(json.tools).toContain("shell");
-        });
-        it("maps Edit to 'write' in agent tools", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            // Edit maps to "write", so coder should have "write" (from both Write and Edit)
-            expect(json.tools).toContain("write");
-        });
-        it("maps Grep to lowercase 'grep' in agent tools", () => {
-            const analyzerFile = files.find((f) => f.path === ".kiro/agents/analyzer.json");
-            const json = JSON.parse(analyzerFile.content);
-            expect(json.tools).toContain("grep");
-        });
-    });
-    // 7. Prompt content — verify prompt text appears in agent JSON instructions
-    describe("prompt content", () => {
-        it("analyzer agent JSON contains its prompt text", () => {
-            const analyzerFile = files.find((f) => f.path === ".kiro/agents/analyzer.json");
-            const json = JSON.parse(analyzerFile.content);
-            expect(json.prompt).toContain("Carefully analyze all incoming data");
-            expect(json.prompt).toContain("structured report with findings");
-        });
-        it("coder agent JSON contains its prompt text", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            expect(json.prompt).toContain("Implement code changes based on the analysis report");
-            expect(json.prompt).toContain("Follow existing patterns in the codebase");
-        });
-        it("reviewer agent JSON has role text but no inline prompt", () => {
-            const reviewerFile = files.find((f) => f.path === ".kiro/agents/reviewer.json");
-            const json = JSON.parse(reviewerFile.content);
-            // reviewer has no prompt block, so only role text should be present
-            expect(json.prompt).toContain("Reviews code changes for quality");
-            expect(json.prompt).not.toContain("## Instructions");
-        });
-    });
-    // 8. Trigger prompts — verify .kiro/prompts/ files are generated
-    describe("trigger prompts", () => {
-        it("generates a prompt file for each trigger", () => {
-            const analyzePrompt = files.find((f) => f.path === ".kiro/prompts/analyze.md");
-            expect(analyzePrompt, "should generate analyze.md prompt").toBeDefined();
-            const deployPrompt = files.find((f) => f.path === ".kiro/prompts/deploy.md");
-            expect(deployPrompt, "should generate deploy.md prompt").toBeDefined();
-        });
-        it("prompt files contain the trigger pattern", () => {
-            const analyzePrompt = files.find((f) => f.path === ".kiro/prompts/analyze.md");
-            expect(analyzePrompt.content).toContain("/analyze <INPUT>");
-            const deployPrompt = files.find((f) => f.path === ".kiro/prompts/deploy.md");
-            expect(deployPrompt.content).toContain("/deploy <ENV>");
-        });
-        it("prompt files contain argument info", () => {
-            const analyzePrompt = files.find((f) => f.path === ".kiro/prompts/analyze.md");
-            expect(analyzePrompt.content).toContain("INPUT");
-            const deployPrompt = files.find((f) => f.path === ".kiro/prompts/deploy.md");
-            expect(deployPrompt.content).toContain("ENV");
-        });
-        it("prompt files contain agent summary table", () => {
-            const analyzePrompt = files.find((f) => f.path === ".kiro/prompts/analyze.md");
-            expect(analyzePrompt.content).toContain("analyzer");
-            expect(analyzePrompt.content).toContain("coder");
-            expect(analyzePrompt.content).toContain("reviewer");
-        });
-    });
-    // Additional: memory directories
-    describe("memory directories", () => {
-        it("generates .kiro/runs/.gitkeep for workspace memory", () => {
-            // The parser resolves the workspace sub-block from memory {}
-            expect(files.find((f) => f.path === ".kiro/runs/.gitkeep")).toBeDefined();
-        });
-        it("structure steering mentions workspace layout", () => {
-            const structureSteering = files.find((f) => f.path === ".kiro/steering/structure.md");
-            expect(structureSteering).toBeDefined();
-            // The workspace structure items appear in the steering doc
-            expect(structureSteering.content).toContain("Workspace");
-        });
-    });
-    // Additional: per-agent hooks and MCP resources
-    describe("per-agent hooks and MCP resources", () => {
-        it("coder agent JSON includes per-agent hooks as object keyed by event", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            expect(json.hooks).toBeDefined();
-            expect(json.hooks.postToolUse).toBeDefined();
-            expect(json.hooks.postToolUse.length).toBeGreaterThanOrEqual(1);
-            expect(json.hooks.postToolUse[0].command).toBe("scripts/format.sh");
-            expect(json.hooks.postToolUse[0].matcher).toBe("fs_write");
-        });
-        it("coder agent JSON includes inline mcpServers config", () => {
-            const coderFile = files.find((f) => f.path === ".kiro/agents/coder.json");
-            const json = JSON.parse(coderFile.content);
-            expect(json.mcpServers).toBeDefined();
-            expect(json.mcpServers.filesystem).toBeDefined();
-            expect(json.mcpServers.filesystem.command).toBe("npx");
-            expect(json.mcpServers.github).toBeDefined();
-            expect(json.mcpServers.github.command).toBe("npx");
-            // type field should be stripped for stdio servers
-            expect(json.mcpServers.filesystem.type).toBeUndefined();
-            expect(json.mcpServers.github.type).toBeUndefined();
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// kiro
-// ---------------------------------------------------------------------------
-describe("kiro binding", () => {
-    const files = scaffoldBinding("kiro");
-    assertStructuralInvariants(files);
-    it("produces .kiro/agents/*.json for each agent", () => {
-        const agentFiles = files.filter((f) => f.path.match(/\.kiro\/agents\/.*\.json$/));
-        expect(agentFiles.length).toBeGreaterThanOrEqual(2);
-        const paths = agentFiles.map((f) => f.path);
-        expect(paths).toContain(".kiro/agents/planner.json");
-        expect(paths).toContain(".kiro/agents/builder.json");
-        // Verify JSON is valid
-        for (const f of agentFiles) {
-            expect(() => JSON.parse(f.content)).not.toThrow();
-        }
-    });
-    it("produces steering documents", () => {
-        const steeringFiles = files.filter((f) => f.path.startsWith(".kiro/steering/"));
-        expect(steeringFiles.length).toBeGreaterThanOrEqual(3);
-        const paths = steeringFiles.map((f) => f.path);
-        expect(paths).toContain(".kiro/steering/product.md");
-        expect(paths).toContain(".kiro/steering/tech.md");
-        expect(paths).toContain(".kiro/steering/structure.md");
-    });
-    it("produces .kiro/settings/mcp.json for MCP servers", () => {
-        const mcpFile = files.find((f) => f.path === ".kiro/settings/mcp.json");
-        expect(mcpFile).toBeDefined();
-        const mcp = JSON.parse(mcpFile.content);
-        expect(mcp.mcpServers.filesystem).toBeDefined();
-    });
-    it("produces AGENTS.md top-level flow narrative", () => {
-        const agentsMd = files.find((f) => f.path === "AGENTS.md");
-        expect(agentsMd).toBeDefined();
-        expect(agentsMd.content).toContain("Flow");
-    });
-    it("produces prompt files from triggers", () => {
-        const promptFile = files.find((f) => f.path === ".kiro/prompts/run.md");
-        expect(promptFile).toBeDefined();
-    });
-    it("produces memory directories", () => {
-        const runsKeep = files.find((f) => f.path === ".kiro/runs/.gitkeep");
-        expect(runsKeep).toBeDefined();
-    });
-    it("generates .kiro/hooks/ JSON file for enforced gate", () => {
-        const hookFile = files.find((f) => f.path === ".kiro/hooks/gate-quality-check.kiro.hook");
-        expect(hookFile).toBeDefined();
-        const hookJson = JSON.parse(hookFile.content);
-        expect(hookJson.enabled).toBe(true);
-        expect(hookJson.when.type).toBe("fileEdited");
-        expect(hookJson.then.type).toBe("runCommand");
-        expect(hookJson.then.command).toContain("lint.sh");
-    });
-    it("does NOT generate hook file for advisory gate", () => {
-        const advisoryHook = files.find((f) => f.path === ".kiro/hooks/gate-soft-review.kiro.hook");
-        expect(advisoryHook).toBeUndefined();
-    });
-});
-// cursor — Ground-truth validation against real-world Cursor IDE configs
-//
-// Reference configs sourced from GitHub:
-//   - maccman/ai-monorepo-scaffold (16 .mdc rules)
-//   - marcoemrich/mad-tdd-mob-ai-driven (TDD rules)
-//   - OthmanAdi/planning-with-files (hooks.json)
-//   - mpaiva/project-starter-template-cursor (mcp.json)
-//   - sanjeed5/awesome-cursor-rules-mdc (3,377 stars, 230+ rules)
-// ---------------------------------------------------------------------------
 describe("cursor binding — ground-truth validation", () => {
     const files = scaffoldBinding("cursor");
     assertStructuralInvariants(files);
@@ -2499,29 +1830,18 @@ topology subagent-test : [pipeline] {
 describe("Stub marker uniformity across bindings (#4)", () => {
     // The baseline TOPOLOGY_SOURCE at the top of this file has gate
     // `quality-check` whose `run: "scripts/lint.sh"` becomes a stub. Bindings
-    // that scaffold gates (5 of 7) must produce a stub for it. The two that
-    // don't (copilot-cli, cursor) have no gate-script generation and are
-    // excluded.
-    const stubProducers = ["claude-code", "codex", "gemini-cli", "kiro", "openclaw"];
+    // that scaffold gates must produce a stub for it; cursor has no gate-script
+    // generation.
+    const stubProducers = ["claude-code", "codex"];
     for (const bindingName of stubProducers) {
         it(`${bindingName} emits at least one stub with the AGENTOPOLOGY_STUB marker`, () => {
             const files = scaffoldBinding(bindingName);
             const stubs = files.filter((f) => isStubContent(f.content));
             expect(stubs.length, `${bindingName} should emit at least one stub`).toBeGreaterThan(0);
-            // Every stub must contain the literal marker string (pinned by the
-            // STUB_MARKER constant — see lib/stub.ts).
             for (const s of stubs) {
                 expect(s.content).toContain(STUB_MARKER);
             }
         });
     }
-    it("copilot-cli produces NO stubs (no shell-script scaffolds)", () => {
-        // Sanity check — confirms the two non-stub-producing bindings stay
-        // in their respective lanes. If this fails, copilot-cli probably
-        // grew a gate-script path and needs the same marker treatment.
-        const files = scaffoldBinding("copilot-cli");
-        const stubs = files.filter((f) => isStubContent(f.content));
-        expect(stubs).toEqual([]);
-    });
 });
 //# sourceMappingURL=bindings.test.js.map