onto-mcp 0.3.0

package/dist/core-runtime/cli/inline-http-review-unit-executor.test.js

@@ -0,0 +1,567 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { runInlineHttpReviewUnitExecutorCli } from "./inline-http-review-unit-executor.js";
+let scratchDir;
+let projectRoot;
+let sessionRoot;
+let ontoHome;
+let savedHome;
+let savedMock;
+let consoleLogSpy;
+function captureConsoleLog() {
+    const original = console.log;
+    const captured = [];
+    console.log = (...args) => {
+        captured.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
+    };
+    return {
+        restore: () => {
+            console.log = original;
+        },
+        getOutput: () => captured,
+    };
+}
+beforeEach(() => {
+    scratchDir = mkdtempSync(path.join(tmpdir(), "inline-http-exec-test-"));
+    projectRoot = path.join(scratchDir, "project");
+    sessionRoot = path.join(scratchDir, "session");
+    ontoHome = path.join(scratchDir, ".onto");
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(sessionRoot, { recursive: true });
+    mkdirSync(ontoHome, { recursive: true });
+    savedHome = process.env.HOME;
+    process.env.HOME = scratchDir;
+    savedMock = process.env.ONTO_LLM_MOCK;
+    process.env.ONTO_LLM_MOCK = "1";
+    consoleLogSpy = captureConsoleLog();
+});
+afterEach(() => {
+    consoleLogSpy.restore();
+    if (savedHome === undefined) {
+        delete process.env.HOME;
+    }
+    else {
+        process.env.HOME = savedHome;
+    }
+    if (savedMock === undefined) {
+        delete process.env.ONTO_LLM_MOCK;
+    }
+    else {
+        process.env.ONTO_LLM_MOCK = savedMock;
+    }
+    rmSync(scratchDir, { recursive: true, force: true });
+});
+function writePacket(filename, content) {
+    const packetPath = path.join(sessionRoot, filename);
+    writeFileSync(packetPath, content, "utf8");
+    return packetPath;
+}
+const PANEL_REVIEW_PACKET = `# Panel Review Prompt Packet
+
+You are a review lens. Inspect the target and produce findings.
+
+## Materialized Input
+\`\`\`
+function add(a: number, b: number): number {
+  return a + b;
+}
+\`\`\`
+
+## Boundary Policy
+- Filesystem: read-only
+- Network: denied
+
+## Required Output Sections
+- Structural Inspection
+- Findings
+- Newly Learned
+- Applied Learnings
+- Domain Constraints Used
+- Domain Context Assumptions
+`;
+describe("runInlineHttpReviewUnitExecutorCli — basic execution", () => {
+    it("reads packet, calls mock LLM, writes output, prints JSON result", async () => {
+        const packetPath = writePacket("lens-logic.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "round1", "logic.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+        ]);
+        expect(exitCode).toBe(0);
+        const outputText = readFileSync(outputPath, "utf8");
+        expect(outputText.length).toBeGreaterThan(0);
+        const logs = consoleLogSpy.getOutput();
+        expect(logs.length).toBeGreaterThan(0);
+        const result = JSON.parse(logs.join(""));
+        expect(result.unit_id).toBe("logic");
+        expect(result.unit_kind).toBe("lens");
+        expect(result.realization).toBe("ts_inline_http");
+        expect(result.output_path).toBe(outputPath);
+    });
+    it("creates output directory if missing", async () => {
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "deeply", "nested", "round1", "logic.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+        ]);
+        expect(exitCode).toBe(0);
+        const outputText = readFileSync(outputPath, "utf8");
+        expect(outputText.length).toBeGreaterThan(0);
+    });
+    it("respects --provider flag (anthropic explicit override)", async () => {
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "logic.md");
+        // --tool-mode inline: these tests exercise provider override via the mock
+        // provider, which doesn't exercise the tool-calling loop. Under the Phase
+        // 3-2 default (--tool-mode auto) the executor would try native first and
+        // require a resolved model id; inline keeps the test focused on host_runtime
+        // propagation.
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--provider", "anthropic",
+            "--tool-mode", "inline",
+        ]);
+        expect(exitCode).toBe(0);
+        const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+        expect(result.host_runtime).toBe("anthropic");
+    });
+    it("respects --provider flag (litellm explicit override)", async () => {
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "logic.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--provider", "litellm",
+            "--tool-mode", "inline",
+        ]);
+        // Note: with mock, host_runtime reports per --provider flag, not actual mock target
+        expect(exitCode).toBe(0);
+        const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+        expect(result.host_runtime).toBe("litellm");
+    });
+});
+describe("runInlineHttpReviewUnitExecutorCli — error cases", () => {
+    it("rejects missing required flag --unit-id", async () => {
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        await expect(runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", path.join(sessionRoot, "out.md"),
+        ])).rejects.toThrow(/--unit-id/);
+    });
+    it("rejects missing --packet-path", async () => {
+        await expect(runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--output-path", path.join(sessionRoot, "out.md"),
+        ])).rejects.toThrow(/--packet-path/);
+    });
+});
+describe("runInlineHttpReviewUnitExecutorCli — synthesize code-fence strip (Phase 3-4 A2)", () => {
+    const SYNTHESIZE_PACKET = `# Synthesize Prompt Packet
+
+You are the synthesize actor. Consolidate lens outputs.
+
+## Participating Lens Outputs
+(none for mock test)
+
+## Boundary Policy
+- Filesystem: read-only
+- Network: denied
+
+## Required Output Sections
+- Consensus
+- Conditional Consensus
+- Disagreement
+- Deliberation Decision
+- Unique Finding Tagging
+- Axiology Integration
+- Newly Learned
+- Degraded Lens Failures
+`;
+    it("baseline: synthesize output has no wrapping code fence", async () => {
+        const packetPath = writePacket("synthesize.packet.md", SYNTHESIZE_PACKET);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "inline",
+        ]);
+        expect(exitCode).toBe(0);
+        const output = readFileSync(outputPath, "utf8");
+        expect(output.startsWith("---\ndeliberation_status:")).toBe(true);
+        expect(output.includes("```yaml")).toBe(false);
+        expect(output.trimEnd().endsWith("```")).toBe(false);
+    });
+    it("strips ```yaml wrapping fence when the mock returns a wrapped synthesize response", async () => {
+        const savedWrapHook = process.env.ONTO_LLM_MOCK_SYNTHESIZE_WRAP_FENCE;
+        process.env.ONTO_LLM_MOCK_SYNTHESIZE_WRAP_FENCE = "1";
+        try {
+            const packetPath = writePacket("synthesize.packet.md", SYNTHESIZE_PACKET);
+            const outputPath = path.join(sessionRoot, "synthesize.md");
+            const exitCode = await runInlineHttpReviewUnitExecutorCli([
+                "--project-root", projectRoot,
+                "--session-root", sessionRoot,
+                "--onto-home", ontoHome,
+                "--unit-id", "synthesize",
+                "--unit-kind", "synthesize",
+                "--packet-path", packetPath,
+                "--output-path", outputPath,
+                "--tool-mode", "inline",
+            ]);
+            expect(exitCode).toBe(0);
+            const output = readFileSync(outputPath, "utf8");
+            // Even though the mock wrapped the body in ```yaml ... ```, the executor
+            // must have stripped the outer fence before writing the canonical file.
+            expect(output.startsWith("---\ndeliberation_status:")).toBe(true);
+            expect(output.includes("```yaml")).toBe(false);
+            expect(output.trimEnd().endsWith("```")).toBe(false);
+            // The required section headings must still be present — strip must not
+            // have damaged the markdown body.
+            expect(output).toContain("## Consensus");
+            expect(output).toContain("## Degraded Lens Failures");
+        }
+        finally {
+            if (savedWrapHook === undefined) {
+                delete process.env.ONTO_LLM_MOCK_SYNTHESIZE_WRAP_FENCE;
+            }
+            else {
+                process.env.ONTO_LLM_MOCK_SYNTHESIZE_WRAP_FENCE = savedWrapHook;
+            }
+        }
+    });
+});
+describe("runInlineHttpReviewUnitExecutorCli — embed flag", () => {
+    it("--embed-domain-docs expands domain doc references in packet", async () => {
+        const domainsDir = path.join(ontoHome, "domains", "test-domain");
+        mkdirSync(domainsDir, { recursive: true });
+        writeFileSync(path.join(domainsDir, "logic_rules.md"), "## Inline Test Logic\nRule: test rule\n", "utf8");
+        const packetWithRef = `${PANEL_REVIEW_PACKET}
+
+## Domain Documents
+- Primary: ~/.onto/domains/test-domain/logic_rules.md
+`;
+        const packetPath = writePacket("lens.packet.md", packetWithRef);
+        const outputPath = path.join(sessionRoot, "logic.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--embed-domain-docs",
+        ]);
+        expect(exitCode).toBe(0);
+        // Mock provider doesn't echo prompt, but successful exit + output written
+        // confirms the embedding pipeline ran without error.
+        const output = readFileSync(outputPath, "utf8");
+        expect(output.length).toBeGreaterThan(0);
+    });
+});
+describe("runInlineHttpReviewUnitExecutorCli — citation audit (Phase 3-4 A5)", () => {
+    function writeLensPool(files) {
+        const round1 = path.join(sessionRoot, "round1");
+        mkdirSync(round1, { recursive: true });
+        for (const [name, body] of Object.entries(files)) {
+            writeFileSync(path.join(round1, name), body, "utf8");
+        }
+        return round1;
+    }
+    function buildSynthesizePacket(lensPaths) {
+        return [
+            "# Synthesize Prompt Packet (A5 audit test)",
+            "",
+            "You are the synthesize actor.",
+            "",
+            "## Boundary Policy",
+            "- Filesystem: read-only",
+            "- Network: denied",
+            "",
+            "## Participating Lens Outputs",
+            ...lensPaths.map((p, i) => `- lens${i}: ${p}`),
+            "",
+            "## Required Output Sections",
+            "- Consensus",
+            "- Conditional Consensus",
+            "- Disagreement",
+            "- Deliberation Decision",
+            "- Unique Finding Tagging",
+            "- Axiology Integration",
+            "- Newly Learned",
+            "- Degraded Lens Failures",
+            "",
+        ].join("\n");
+    }
+    it("attaches citation_audit with 0 unmatched when synthesize quotes match lens pool", async () => {
+        const round1 = writeLensPool({
+            "axiology.md": "axiology content with the phrase (none — mock executor) inline.",
+        });
+        const packet = buildSynthesizePacket([path.join(round1, "axiology.md")]);
+        const packetPath = writePacket("synthesize.packet.md", packet);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "inline",
+        ]);
+        expect(exitCode).toBe(0);
+        const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+        expect(result.citation_audit).toBeDefined();
+        expect(result.citation_audit.quotes_unmatched).toEqual([]);
+        expect(result.citation_audit.min_quote_length).toBe(20);
+    });
+    it("flags fabricated quote via ONTO_LLM_MOCK_SYNTHESIZE_FABRICATE=1", async () => {
+        const savedHook = process.env.ONTO_LLM_MOCK_SYNTHESIZE_FABRICATE;
+        process.env.ONTO_LLM_MOCK_SYNTHESIZE_FABRICATE = "1";
+        const originalWrite = process.stderr.write.bind(process.stderr);
+        const stderrChunks = [];
+        process.stderr.write = ((chunk) => {
+            stderrChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+            return true;
+        });
+        try {
+            const round1 = writeLensPool({
+                "axiology.md": "axiology content with legitimate findings about value alignment.",
+            });
+            const packet = buildSynthesizePacket([path.join(round1, "axiology.md")]);
+            const packetPath = writePacket("synthesize.packet.md", packet);
+            const outputPath = path.join(sessionRoot, "synthesize.md");
+            const exitCode = await runInlineHttpReviewUnitExecutorCli([
+                "--project-root", projectRoot,
+                "--session-root", sessionRoot,
+                "--onto-home", ontoHome,
+                "--unit-id", "synthesize",
+                "--unit-kind", "synthesize",
+                "--packet-path", packetPath,
+                "--output-path", outputPath,
+                "--tool-mode", "inline",
+            ]);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+            expect(result.citation_audit.quotes_unmatched).toContain("A fabricated quote that is definitely nowhere in the lens pool for this mock test run");
+            const stderrText = stderrChunks.join("");
+            expect(stderrText).toMatch(/citation audit WARNING/);
+            expect(stderrText).toMatch(/may indicate fabrication/);
+        }
+        finally {
+            process.stderr.write = originalWrite;
+            if (savedHook === undefined) {
+                delete process.env.ONTO_LLM_MOCK_SYNTHESIZE_FABRICATE;
+            }
+            else {
+                process.env.ONTO_LLM_MOCK_SYNTHESIZE_FABRICATE = savedHook;
+            }
+        }
+    });
+    it("skips audit (no citation_audit field) when packet has no Participating Lens Outputs", async () => {
+        // Use the basic panel-review packet which has no Participating Lens Outputs.
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "inline",
+        ]);
+        expect(exitCode).toBe(0);
+        const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+        expect(result.citation_audit).toBeUndefined();
+    });
+    it("skips audit (with STDERR notice) when every referenced lens file is unreadable", async () => {
+        const originalWrite = process.stderr.write.bind(process.stderr);
+        const stderrChunks = [];
+        process.stderr.write = ((chunk) => {
+            stderrChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+            return true;
+        });
+        try {
+            const packet = buildSynthesizePacket([
+                path.join(sessionRoot, "round1", "does-not-exist.md"),
+            ]);
+            const packetPath = writePacket("synthesize.packet.md", packet);
+            const outputPath = path.join(sessionRoot, "synthesize.md");
+            const exitCode = await runInlineHttpReviewUnitExecutorCli([
+                "--project-root", projectRoot,
+                "--session-root", sessionRoot,
+                "--onto-home", ontoHome,
+                "--unit-id", "synthesize",
+                "--unit-kind", "synthesize",
+                "--packet-path", packetPath,
+                "--output-path", outputPath,
+                "--tool-mode", "inline",
+            ]);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+            expect(result.citation_audit).toBeUndefined();
+            expect(stderrChunks.join("")).toMatch(/citation audit skipped/);
+        }
+        finally {
+            process.stderr.write = originalWrite;
+        }
+    });
+    it("does not audit lens-kind units", async () => {
+        const packetPath = writePacket("lens.packet.md", PANEL_REVIEW_PACKET);
+        const outputPath = path.join(sessionRoot, "logic.md");
+        const exitCode = await runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "logic",
+            "--unit-kind", "lens",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "inline",
+        ]);
+        expect(exitCode).toBe(0);
+        const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+        expect(result.citation_audit).toBeUndefined();
+    });
+});
+describe("runInlineHttpReviewUnitExecutorCli — Tools: required precedence (Phase 3-4 A4)", () => {
+    const TOOLS_REQUIRED_PACKET = `# Synthesize Prompt Packet (path-only)
+
+You are the synthesize actor. Lens outputs live on disk.
+
+## Boundary Policy
+- Filesystem: read-only inside round1/
+- Network: denied
+- Tools: required
+
+## Participating Lens Outputs
+- axiology: .onto/review/session/round1/axiology.md
+
+## Required Output Sections
+- Consensus
+- Conditional Consensus
+- Disagreement
+- Deliberation Decision
+- Unique Finding Tagging
+- Axiology Integration
+- Newly Learned
+- Degraded Lens Failures
+`;
+    it("rejects --tool-mode=inline with a clear fail-fast message", async () => {
+        const packetPath = writePacket("synthesize.packet.md", TOOLS_REQUIRED_PACKET);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        await expect(runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "inline",
+        ])).rejects.toThrow(/Tools: required|fabricated citations/);
+    });
+    it("auto-promotes --tool-mode=auto to native when a tool-loop provider is available", async () => {
+        const packetPath = writePacket("synthesize.packet.md", TOOLS_REQUIRED_PACKET);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        // Capture STDERR to verify the promotion notice is emitted.
+        const originalWrite = process.stderr.write.bind(process.stderr);
+        const stderrChunks = [];
+        process.stderr.write = ((chunk) => {
+            stderrChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+            return true;
+        });
+        try {
+            const exitCode = await runInlineHttpReviewUnitExecutorCli([
+                "--project-root", projectRoot,
+                "--session-root", sessionRoot,
+                "--onto-home", ontoHome,
+                "--unit-id", "synthesize",
+                "--unit-kind", "synthesize",
+                "--packet-path", packetPath,
+                "--output-path", outputPath,
+                "--provider", "litellm",
+                "--llm-base-url", "http://localhost:8080",
+                "--model", "mock-model",
+                "--tool-mode", "auto",
+            ]);
+            expect(exitCode).toBe(0);
+            const stderrText = stderrChunks.join("");
+            expect(stderrText).toMatch(/auto-promoted to tool-native/);
+            expect(stderrText).toMatch(/Tools: required/);
+            const result = JSON.parse(consoleLogSpy.getOutput().join(""));
+            expect(result.packet_policy_promotion).toBe(true);
+            expect(result.tool_mode).toBe("native");
+        }
+        finally {
+            process.stderr.write = originalWrite;
+        }
+    });
+    it("rejects --tool-mode=auto when the resolved provider has no tool-loop support", async () => {
+        const packetPath = writePacket("synthesize.packet.md", TOOLS_REQUIRED_PACKET);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        await expect(runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--provider", "codex",
+            "--tool-mode", "auto",
+        ])).rejects.toThrow(/Tools: required|function-calling tool loop/);
+    });
+    it("rejects a packet that simultaneously denies filesystem and requires tools", async () => {
+        const conflictingPacket = TOOLS_REQUIRED_PACKET.replace("- Filesystem: read-only inside round1/", "- Filesystem: denied");
+        const packetPath = writePacket("synthesize.packet.md", conflictingPacket);
+        const outputPath = path.join(sessionRoot, "synthesize.md");
+        await expect(runInlineHttpReviewUnitExecutorCli([
+            "--project-root", projectRoot,
+            "--session-root", sessionRoot,
+            "--onto-home", ontoHome,
+            "--unit-id", "synthesize",
+            "--unit-kind", "synthesize",
+            "--packet-path", packetPath,
+            "--output-path", outputPath,
+            "--tool-mode", "auto",
+        ])).rejects.toThrow(/internally inconsistent/);
+    });
+});

package/dist/core-runtime/cli/materialize-review-execution-preparation.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { materializeReviewExecutionPreparationArtifacts } from "../review/materializers.js";
+import { DEFAULT_DIRECTORY_LISTING_OPTIONS } from "../review/review-artifact-utils.js";
+import { printOntoReleaseChannelNotice } from "../release-channel/release-channel.js";
+function requireString(value, optionName) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Missing required option --${optionName}`);
+    }
+    return value;
+}
+function requireTargetScopeKind(value) {
+    if (value === "file" || value === "directory" || value === "bundle") {
+        return value;
+    }
+    throw new Error(`Invalid --scope-kind: ${value}`);
+}
+function requireMaterializedInputKind(value) {
+    if (value === "single_text" ||
+        value === "directory_listing" ||
+        value === "bundle_member_texts") {
+        return value;
+    }
+    throw new Error(`Invalid --materialized-kind: ${value}`);
+}
+async function main() {
+    await printOntoReleaseChannelNotice();
+    const { values } = parseArgs({
+        options: {
+            "session-root": { type: "string" },
+            "scope-kind": { type: "string" },
+            "resolved-target-ref": { type: "string", multiple: true, default: [] },
+            "materialized-kind": { type: "string" },
+            "requested-target": { type: "string" },
+            "intent-summary": { type: "string" },
+            "session-domain": { type: "string" },
+            "bundle-kind": { type: "string" },
+            "filesystem-allowed-root": { type: "string", multiple: true, default: [] },
+            "materialized-ref": { type: "string", multiple: true, default: [] },
+            "system-purpose-ref": { type: "string", multiple: true, default: [] },
+            "domain-context-ref": { type: "string", multiple: true, default: [] },
+            "learning-context-ref": { type: "string", multiple: true, default: [] },
+            "role-definition-ref": { type: "string", multiple: true, default: [] },
+            "execution-rule-ref": { type: "string", multiple: true, default: [] },
+            "excluded-name": { type: "string", multiple: true, default: [] },
+            "max-listing-depth": { type: "string" },
+            "max-listing-entries": { type: "string" },
+        },
+        strict: true,
+        allowPositionals: false,
+    });
+    const resolvedTargetRefs = values["resolved-target-ref"].map((ref) => path.resolve(ref));
+    if (resolvedTargetRefs.length === 0) {
+        throw new Error("At least one --resolved-target-ref is required.");
+    }
+    const directoryListingOptions = {
+        excluded_names: values["excluded-name"].length > 0
+            ? values["excluded-name"]
+            : DEFAULT_DIRECTORY_LISTING_OPTIONS.excluded_names,
+        max_depth: typeof values["max-listing-depth"] === "string"
+            ? Number.parseInt(values["max-listing-depth"], 10)
+            : DEFAULT_DIRECTORY_LISTING_OPTIONS.max_depth,
+        max_entries: typeof values["max-listing-entries"] === "string"
+            ? Number.parseInt(values["max-listing-entries"], 10)
+            : DEFAULT_DIRECTORY_LISTING_OPTIONS.max_entries,
+    };
+    const executionPreparationRoot = await materializeReviewExecutionPreparationArtifacts({
+        sessionRoot: requireString(values["session-root"], "session-root"),
+        scopeKind: requireTargetScopeKind(requireString(values["scope-kind"], "scope-kind")),
+        resolvedTargetRefs,
+        materializedKind: requireMaterializedInputKind(requireString(values["materialized-kind"], "materialized-kind")),
+        ...(typeof values["requested-target"] === "string" &&
+            values["requested-target"].length > 0
+            ? { requestedTarget: values["requested-target"] }
+            : {}),
+        ...(typeof values["intent-summary"] === "string" &&
+            values["intent-summary"].length > 0
+            ? { reviewIntentSummary: values["intent-summary"] }
+            : {}),
+        ...(typeof values["session-domain"] === "string" &&
+            values["session-domain"].length > 0
+            ? { sessionDomain: values["session-domain"] }
+            : {}),
+        ...(typeof values["bundle-kind"] === "string" &&
+            values["bundle-kind"].length > 0
+            ? { bundleKind: values["bundle-kind"] }
+            : {}),
+        filesystemAllowedRoots: values["filesystem-allowed-root"],
+        materializedRefs: values["materialized-ref"],
+        systemPurposeRefs: values["system-purpose-ref"],
+        domainContextRefs: values["domain-context-ref"],
+        learningContextRefs: values["learning-context-ref"],
+        roleDefinitionRefs: values["role-definition-ref"],
+        executionRuleRefs: values["execution-rule-ref"],
+        directoryListingOptions,
+    });
+    console.log(executionPreparationRoot);
+    return 0;
+}
+main().then((exitCode) => process.exit(exitCode), (error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});