muonroi-cli 1.7.2 → 1.8.1

package/dist/src/orchestrator/__tests__/stream-runner.test.js

@@ -169,5 +169,34 @@ describe("StreamRunner — DI surface", () => {
         const b = new StreamRunner(makeDeps());
         expect(a).not.toBe(b);
     });
+    describe("StreamRunner — maxSteps custom overrides", () => {
+        it("respects default maxSteps logic when request.maxToolRounds is undefined", async () => {
+            const deps = makeDeps({ getMaxToolRounds: () => 50 });
+            const runner = new StreamRunner(deps);
+            const outcome = await runner.setup({
+                agent: "explore",
+                description: "test",
+                prompt: "test",
+            });
+            expect(outcome.kind).toBe("prepared");
+            if (outcome.kind === "prepared") {
+                expect(outcome.prepared.maxSteps).toBe(100); // deps.getMaxToolRounds() * 2
+            }
+        });
+        it("uses request.maxToolRounds when it is explicitly defined", async () => {
+            const deps = makeDeps({ getMaxToolRounds: () => 50 });
+            const runner = new StreamRunner(deps);
+            const outcome = await runner.setup({
+                agent: "explore",
+                description: "test",
+                prompt: "test",
+                maxToolRounds: 75,
+            });
+            expect(outcome.kind).toBe("prepared");
+            if (outcome.kind === "prepared") {
+                expect(outcome.prepared.maxSteps).toBe(75);
+            }
+        });
+    });
 });
 //# sourceMappingURL=stream-runner.test.js.map

package/dist/src/orchestrator/__tests__/sub-session-delegation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrator/__tests__/sub-session-delegation.test.js

@@ -0,0 +1,507 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { installMockModel, textOnlyStream } from "../../agent-harness/mock-model.js";
+import { loadCatalog } from "../../models/registry.js";
+import { Agent } from "../orchestrator.js";
+// Mock generateText from 'ai'
+const mockGenerateText = vi.fn().mockResolvedValue({ text: "Mocked parent advice response" });
+vi.mock("ai", () => {
+    return {
+        generateText: (...args) => mockGenerateText(...args),
+    };
+});
+// 1. Mock classifySubSessionAction
+const mockClassifySubSessionAction = vi.fn();
+vi.mock("../../pil/llm-classify.js", () => {
+    return {
+        classifySubSessionAction: (...args) => mockClassifySubSessionAction.apply(null, args),
+    };
+});
+// Mock deliberateCompact
+const mockDeliberateCompact = vi.fn().mockResolvedValue({
+    summary: "Compact summary",
+    tokensBeforeCompress: 100,
+});
+vi.mock("../../flow/compaction/index.js", () => {
+    return {
+        deliberateCompact: (...args) => mockDeliberateCompact.apply(null, args),
+    };
+});
+// 2. Mock DB
+const mockDb = {
+    prepare: vi.fn().mockReturnValue({
+        run: vi.fn().mockReturnValue({ changes: 1 }),
+        get: vi.fn(),
+        all: vi.fn().mockReturnValue([]),
+    }),
+};
+vi.mock("../../storage/db.js", () => {
+    return {
+        getDatabase: () => mockDb,
+    };
+});
+// 3. Mock Storage/Transcript module functions
+const mockLoadLatestCompaction = vi.fn();
+const mockGetNextMessageSequence = vi.fn(() => 1);
+const mockAppendCompaction = vi.fn();
+const mockLoadTranscriptState = vi.fn();
+const mockAppendMessages = vi.fn((sessId, msgs) => msgs.map((_, idx) => idx + 100));
+const mockMarkMessageCompleted = vi.fn();
+vi.mock("../../storage/transcript.js", () => {
+    return {
+        loadLatestCompaction: (...args) => mockLoadLatestCompaction.apply(null, args),
+        getNextMessageSequence: (...args) => mockGetNextMessageSequence.apply(null, args),
+        appendCompaction: (...args) => mockAppendCompaction.apply(null, args),
+        loadTranscriptState: (...args) => mockLoadTranscriptState.apply(null, args),
+        appendMessages: (...args) => mockAppendMessages.apply(null, args),
+        markMessageCompleted: (...args) => mockMarkMessageCompleted.apply(null, args),
+        buildChatEntries: vi.fn(() => []),
+        getLastTodoWriteArgs: vi.fn(() => null),
+        loadTranscript: vi.fn(() => []),
+    };
+});
+// 4. Mock the main storage index barrel file
+const parentSessionState = {
+    messages: [{ role: "user", content: "Hello parent" }],
+    seqs: [1],
+};
+vi.mock("../../storage/index.js", () => {
+    return {
+        appendCompaction: (...args) => mockAppendCompaction.apply(null, args),
+        appendMessages: (...args) => mockAppendMessages.apply(null, args),
+        getNextMessageSequence: (...args) => mockGetNextMessageSequence.apply(null, args),
+        loadTranscriptState: (...args) => mockLoadTranscriptState.apply(null, args),
+        loadTranscript: vi.fn(() => []),
+        buildChatEntries: vi.fn(() => []),
+        getLastTodoWriteArgs: vi.fn(() => null),
+        markMessageCompleted: (...args) => mockMarkMessageCompleted.apply(null, args),
+        appendSystemMessage: vi.fn(() => 0),
+        getSessionTotalTokens: vi.fn(() => ({ inputTokens: 0, outputTokens: 0 })),
+        logInteraction: vi.fn(),
+        recordUsageEvent: vi.fn(),
+        SessionStore: class {
+            getWorkspace() {
+                return { id: "workspace-1", rootPath: "/dummy" };
+            }
+            openSession(selector, model, mode, cwd) {
+                return {
+                    id: "session-parent",
+                    workspaceId: "workspace-1",
+                    model,
+                    mode,
+                    cwdAtStart: cwd,
+                    cwdLast: cwd,
+                    status: "active",
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                };
+            }
+            createSession(model, mode, cwd) {
+                return {
+                    id: "session-child",
+                    workspaceId: "workspace-1",
+                    model,
+                    mode,
+                    cwdAtStart: cwd,
+                    cwdLast: cwd,
+                    status: "active",
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                };
+            }
+            getRequiredSession(id) {
+                return {
+                    id,
+                    workspaceId: "workspace-1",
+                    model: "dummy-model",
+                    mode: "agent",
+                    cwdAtStart: "/dummy",
+                    cwdLast: "/dummy",
+                    status: "active",
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                };
+            }
+            touchSession() { }
+            setMode() { }
+            setStatus() { }
+            setModel() { }
+            setTitle() { }
+            getLatestSession() {
+                return null;
+            }
+            getSessionById() {
+                return null;
+            }
+        },
+    };
+});
+// 5. Mock MessageProcessor so we can simulate the messages it writes
+vi.mock("../message-processor.js", () => {
+    return {
+        MessageProcessor: class {
+            deps;
+            constructor(deps) {
+                this.deps = deps;
+            }
+            async *run(userMessage) {
+                if (userMessage === "trigger error") {
+                    throw new Error("Simulated MessageProcessor crash");
+                }
+                if (userMessage === "trigger transient error") {
+                    globalThis.__transientAttempts = (globalThis.__transientAttempts || 0) + 1;
+                    if (globalThis.__transientAttempts < 3) {
+                        throw new Error("fetch failed");
+                    }
+                    this.deps.messages.push({ role: "assistant", content: "Sub-session final structured response after retry" }, { role: "tool", content: "Final tool outcome (should be copied)" });
+                    yield { type: "content", content: "processing after retry..." };
+                    return;
+                }
+                if (userMessage === "test consult") {
+                    if (this.deps.consultParentSession) {
+                        const advice = await this.deps.consultParentSession("How to handle this error?");
+                        this.deps.messages.push({ role: "assistant", content: `Advice: ${advice}` }, { role: "tool", content: "Final tool outcome (should be copied)" });
+                    }
+                    yield { type: "content", content: "consulting..." };
+                    return;
+                }
+                // Simulating writing messages during turn execution
+                // Under a sub-session, we want to write intermediate clutter,
+                // and check that only final assistant response gets absorbed.
+                this.deps.messages.push({ role: "assistant", content: "Intermediate assistant prompt analysis" }, { role: "tool", content: "Intermediate tool result that should be ignored" }, { role: "assistant", content: "Sub-session final structured response" }, { role: "tool", content: "Final tool outcome (should be copied)" });
+                yield { type: "content", content: "processing..." };
+            }
+        },
+    };
+});
+describe("Agent - Sub-Session Delegation & Absorption", () => {
+    let cleanup = null;
+    beforeAll(async () => {
+        await loadCatalog();
+    });
+    beforeEach(() => {
+        process.env.MUONROI_FORCE_ROUTING_CLASSIFY = "1";
+        vi.clearAllMocks();
+        globalThis.__transientAttempts = 0;
+        parentSessionState.messages = [{ role: "user", content: "Hello parent" }];
+        parentSessionState.seqs = [1];
+        mockLoadTranscriptState.mockReturnValue(parentSessionState);
+        const mockModelHandle = installMockModel({ fixture: { stream: textOnlyStream("ignored mock stream") } });
+        cleanup = () => {
+            delete process.env.MUONROI_FORCE_ROUTING_CLASSIFY;
+            mockModelHandle.uninstall();
+        };
+    });
+    afterEach(() => {
+        cleanup?.();
+    });
+    it("routes DIRECT_ANSWER directly without spawning a sub-session", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "DIRECT_ANSWER",
+            confidence: 0.95,
+            reason: "simple question",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Clear initial messages
+        agent.messages = [];
+        const generator = agent.processMessage("What is 2+2?");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // Since it's DIRECT_ANSWER, it should NOT try to insert child sub-sessions
+        expect(mockDb.prepare).not.toHaveBeenCalledWith(expect.stringContaining("parent_session_id"));
+        expect(agent.getSessionId()).toBe("session-parent");
+    });
+    it("routes SPAWN_SUB_SESSION: creates child session, injects overlay prompt, runs in isolation, and absorbs final outcome", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires multi-step tool execution",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        const generator = agent.processMessage("Implement auth and write tests");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // 1. Verify DB parent session link update is triggered
+        expect(mockDb.prepare).toHaveBeenCalledWith("UPDATE sessions SET parent_session_id = ? WHERE id = ?");
+        // 2. Verify parent session was restored at the end
+        expect(agent.getSessionId()).toBe("session-parent");
+        // 3. Verify final messages in parent contain the absorbed outcome
+        // We expect the final messages list to have absorbed:
+        // - last assistant message: "Sub-session final structured response"
+        // - subsequent tool message(s): "Final tool outcome (should be copied)"
+        // It should NOT contain:
+        // - intermediate assistant: "Intermediate assistant prompt analysis"
+        // - intermediate tool: "Intermediate tool result that should be ignored"
+        expect(agent.messages).toHaveLength(3); // Hello parent + absorbed assistant + absorbed tool
+        expect(agent.messages[1]).toEqual({
+            role: "assistant",
+            content: "Sub-session final structured response",
+        });
+        expect(agent.messages[2]).toEqual({
+            role: "tool",
+            content: "Final tool outcome (should be copied)",
+        });
+        // 4. Verify appendMessages was called to persist the absorbed turn in the parent
+        expect(mockAppendMessages).toHaveBeenCalledWith("session-parent", expect.arrayContaining([
+            expect.objectContaining({ role: "user", content: "Implement auth and write tests" }),
+            expect.objectContaining({ role: "assistant", content: "Sub-session final structured response" }),
+            expect.objectContaining({ role: "tool", content: "Final tool outcome (should be copied)" }),
+        ]));
+    });
+    it("restores parent session if sub-session execution crashes", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires sub-session",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        // Run a turn that will crash
+        let threw = false;
+        try {
+            const generator = agent.processMessage("trigger error");
+            for await (const chunk of generator) {
+                // consume stream
+            }
+        }
+        catch (err) {
+            expect(err.message).toBe("Simulated MessageProcessor crash");
+            threw = true;
+        }
+        expect(threw).toBe(true);
+        // Verify parent session is restored even after crash
+        expect(agent.getSessionId()).toBe("session-parent");
+    });
+    it("resumes an existing active sub-session if found in database", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires sub-session",
+        });
+        // Mock active sub-session row lookup
+        mockDb.prepare.mockImplementation((sql) => {
+            if (sql.includes("status = 'active'")) {
+                return {
+                    get: () => ({ id: "session-active-child" }),
+                    run: () => ({ changes: 1 }),
+                    all: () => [],
+                };
+            }
+            return {
+                run: () => ({ changes: 1 }),
+                get: () => undefined,
+                all: () => [],
+            };
+        });
+        // Mock loadTranscriptState to return a state for the child session or parent session depending on input
+        mockLoadTranscriptState.mockImplementation((sessId) => {
+            if (sessId === "session-parent") {
+                return parentSessionState;
+            }
+            return {
+                messages: [{ role: "user", content: "Previous attempt" }],
+                seqs: [1],
+            };
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        const generator = agent.processMessage("Implement auth and write tests");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // 1. Verify that we yielded the resumption status message
+        const hasResumeMessage = chunks.some((c) => c.type === "content" && c.content?.includes("Phát hiện sub-session trước đó bị gián đoạn"));
+        expect(hasResumeMessage).toBe(true);
+        // 2. Verify that the agent restored parent session at the end
+        expect(agent.getSessionId()).toBe("session-parent");
+        // 3. Verify that loadTranscriptState was called with the resumed sub-session ID
+        expect(mockLoadTranscriptState).toHaveBeenCalledWith("session-active-child");
+    });
+    it("triggers session rotation if the model decides ROTATE_SESSION", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "ROTATE_SESSION",
+            confidence: 0.9,
+            reason: "New topic",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        agent.messages = [{ role: "user", content: "Switch topics" }];
+        const generator = agent.processMessage("switch topic");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // Verify deliberateCompact was called
+        expect(mockDeliberateCompact).toHaveBeenCalled();
+        // Verify a new session was created (the active session ID changes)
+        expect(agent.getSessionId()).toBe("session-child");
+    });
+    it("triggers session rotation if currentChars exceeds the hard safety threshold (threshold * 2)", async () => {
+        process.env.MUONROI_SILENT_ROTATION_THRESHOLD = "100";
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "DIRECT_ANSWER",
+            confidence: 0.95,
+            reason: "simple answer",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        agent.messages = [{ role: "user", content: "A".repeat(250) }];
+        try {
+            const generator = agent.processMessage("short message");
+            const chunks = [];
+            for await (const chunk of generator) {
+                chunks.push(chunk);
+            }
+            // Verify deliberateCompact was called
+            expect(mockDeliberateCompact).toHaveBeenCalled();
+            // Verify it rotated to session-child
+            expect(agent.getSessionId()).toBe("session-child");
+        }
+        finally {
+            delete process.env.MUONROI_SILENT_ROTATION_THRESHOLD;
+        }
+    });
+    it("does not resume a stale active sub-session (timeout), marks it as abandoned, and forks a new child session", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires sub-session",
+        });
+        const twentyMinsAgo = new Date(Date.now() - 20 * 60 * 1000).toISOString();
+        // Mock active sub-session row lookup returning a stale row
+        mockDb.prepare.mockImplementation((sql) => {
+            if (sql.includes("status = 'active'")) {
+                return {
+                    get: () => ({ id: "session-stale-child", updated_at: twentyMinsAgo }),
+                    run: () => ({ changes: 1 }),
+                    all: () => [],
+                };
+            }
+            return {
+                run: () => ({ changes: 1 }),
+                get: () => undefined,
+                all: () => [],
+            };
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        const generator = agent.processMessage("Implement auth and write tests");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // 1. Verify that we did NOT yield the resumption message
+        const hasResumeMessage = chunks.some((c) => c.type === "content" && c.content?.includes("Phát hiện sub-session trước đó bị gián đoạn"));
+        expect(hasResumeMessage).toBe(false);
+        // 2. Verify that we marked the stale sub-session as abandoned
+        expect(mockDb.prepare).toHaveBeenCalledWith("UPDATE sessions SET status = 'abandoned', updated_at = ? WHERE id = ?");
+        // 3. Verify that we created a new session
+        expect(agent.getSessionId()).toBe("session-parent");
+    });
+    it("registers and successfully executes consultParentSession tool in sub-session", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires sub-session for consultation test",
+        });
+        mockDb.prepare.mockImplementation((sql) => {
+            if (sql.includes("SELECT parent_session_id")) {
+                return {
+                    get: () => ({ parent_session_id: "session-parent" }),
+                    run: () => ({ changes: 1 }),
+                    all: () => [],
+                };
+            }
+            if (sql.includes("SELECT model_id")) {
+                return {
+                    get: () => ({ model_id: "deepseek-v4-flash" }),
+                    run: () => ({ changes: 1 }),
+                    all: () => [],
+                };
+            }
+            return {
+                run: () => ({ changes: 1 }),
+                get: () => undefined,
+                all: () => [],
+            };
+        });
+        mockLoadTranscriptState.mockReturnValue({
+            messages: [{ role: "user", content: "Hello parent" }],
+            seqs: [1],
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        const generator = agent.processMessage("test consult");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // Verify that generateText was called to advice the sub-session
+        expect(mockGenerateText).toHaveBeenCalled();
+        // Verify parent session is restored
+        expect(agent.getSessionId()).toBe("session-parent");
+        // The parent's final messages should have absorbed the assistant message which contains Advice
+        expect(agent.messages).toHaveLength(3); // Hello parent + absorbed assistant (advice) + absorbed tool
+        expect(agent.messages[1].content).toContain("Advice: Mocked parent advice response");
+    });
+    it("automatically retries transient errors in sub-session before succeeding", async () => {
+        mockClassifySubSessionAction.mockResolvedValue({
+            action: "SPAWN_SUB_SESSION",
+            confidence: 0.98,
+            reason: "requires sub-session for transient error test",
+        });
+        const agent = new Agent("sk-dummy", undefined, "deepseek-v4-flash", undefined, {
+            persistSession: true,
+            session: "session-parent",
+        });
+        // Start with empty messages in parent
+        agent.messages = [];
+        const generator = agent.processMessage("trigger transient error");
+        const chunks = [];
+        for await (const chunk of generator) {
+            chunks.push(chunk);
+        }
+        // Verify parent session is restored
+        expect(agent.getSessionId()).toBe("session-parent");
+        console.log("TEST MESSAGES: ", JSON.stringify(agent.messages, null, 2));
+        // The sub-session should have succeeded on the 3rd attempt and its output should be absorbed
+        expect(agent.messages).toHaveLength(3); // Hello parent + absorbed assistant (after retry) + absorbed tool
+        expect(agent.messages[1].content).toContain("Sub-session final structured response after retry");
+        // Verify warning chunks were emitted
+        const warningChunks = chunks.filter((c) => c.type === "content" && c.content?.includes("Có lỗi mạng hoặc rate limit xảy ra trong sub-session"));
+        expect(warningChunks.length).toBe(2);
+    });
+});
+//# sourceMappingURL=sub-session-delegation.test.js.map

package/dist/src/orchestrator/agent.test.js

@@ -76,13 +76,16 @@ describe("Agent class", { timeout: 30_000 }, () => {
         agent.setModel("claude-sonnet-4-6-20250514");
         expect(agent.getModel()).toBe("claude-sonnet-4-6-20250514");
     });
-    it("constructs with sandbox mode", async () => {
+    it("constructs with sandbox mode — always returns 'off' (sandbox removed)", async () => {
         const { Agent } = await importAgentModule();
+        // Sandbox has been removed; passing sandboxMode: "shuru" is accepted for
+        // back-compat but getSandboxMode() always returns "off" until a new
+        // sandbox implementation is wired in.
         const agent = new Agent(undefined, undefined, undefined, undefined, {
             persistSession: false,
             sandboxMode: "shuru",
         });
-        expect(agent.getSandboxMode()).toBe("shuru");
+        expect(agent.getSandboxMode()).toBe("off");
     });
     it("defaults sandbox mode to off", async () => {
         const { Agent } = await importAgentModule();

package/dist/src/orchestrator/auto-commit.d.ts

@@ -0,0 +1,110 @@
+import type { LspDiagnostic, LspDiagnosticFile } from "../lsp/types.js";
+/** Attribution line every auto-commit message ends with (mirrors the prompt rule). */
+export declare const AUTO_COMMIT_ATTRIBUTION = "Coding by - Muonroi-CLI";
+export interface AutoCommitResult {
+    committed: boolean;
+    sha?: string;
+    fileCount?: number;
+    reason?: string;
+    /** G1: when reason === "lsp-errors", the per-file diagnostic summary the agent should fix. */
+    detail?: string;
+}
+/**
+ * G1 commit quality gate. Default ON; disable with `MUONROI_COMMIT_GATE=0`
+ * (mirrors the `MUONROI_AUTO_COMMIT=0` convention). Off automatically under the
+ * unit-test suite so specs that commit fixtures aren't gated.
+ */
+export declare function isCommitGateEnabled(): boolean;
+/**
+ * G1: per-file LSP-errors gate. Runs the SAME LSP diagnostics produced at
+ * write-time on each staged path; blocks the commit if any staged file has an
+ * ERROR (severity 1). Scoped to each file's OWN diagnostics so unrelated repo
+ * breakage never blocks. Files with no registered LSP server return no
+ * diagnostics and pass (so docs/config/non-source commits are unaffected).
+ *
+ * Fails OPEN on timeout or any error — the gate must never hang a turn or block
+ * a commit on its own failure. Only a clean, in-budget run with a real
+ * severity-1 diagnostic blocks.
+ */
+/**
+ * G1 (pure): the gate's BLOCK decision for one staged file — its own
+ * severity-1 (error) diagnostics. Scoped by absolute path so a diagnostic LSP
+ * reports against a DIFFERENT file (cross-file type breakage) never blocks this
+ * commit, and warnings/infos (severity >= 2) are ignored. Exported for testing.
+ */
+export declare function blockingErrorsForFile(diagFiles: LspDiagnosticFile[], absPath: string): LspDiagnostic[];
+export declare function gateStagedPaths(cwd: string, paths: string[], budgetMs?: number): Promise<{
+    ok: boolean;
+    summary?: string;
+}>;
+/**
+ * G1 follow-up: the set of paths a bash-tool `git commit` would include, so the
+ * LSP commit gate can run on them. A raw `git commit` (unlike the `git_commit`
+ * tool) doesn't tell us its paths, so derive them from git state:
+ *   - always: the already-staged set (`git diff --cached --name-only`)
+ *   - `git commit -a`: + tracked modifications it auto-stages at commit time
+ *     (`git diff --name-only`)
+ *   - `git add -A`/`.`/`--all` chained in the SAME command: + the whole
+ *     working-tree change set (`git status --porcelain`), since the add hasn't
+ *     run yet at pre-exec time so it isn't reflected in `--cached`.
+ * Deleted/binary/unreadable paths are skipped later by gateStagedPaths when it
+ * reads them. KNOWN GAP: `git add <specific-path> && git commit` in one command
+ * where <specific-path> was not pre-staged is NOT covered (we don't parse
+ * pathspecs); the `git_commit` tool + auto-commit backstop remain the primary
+ * gates. Returns repo-relative paths (gateStagedPaths resolves them against cwd).
+ */
+export declare function pathsForCommitGate(cwd: string, opts: {
+    broadAdd: boolean;
+    commitAll: boolean;
+}): Promise<string[]>;
+export declare function isAutoCommitEnabled(): boolean;
+/**
+ * Parse `git status --porcelain` output into the set of changed paths. Handles
+ * renames (`orig -> new`, keeps the new path) and quoted paths with spaces.
+ */
+export declare function parsePorcelainPaths(out: string): Set<string>;
+export declare function isSensitivePath(path: string): boolean;
+/** CLI artifact / build junk that must never be folded into an agent commit. */
+export declare function isCliArtifactPath(path: string): boolean;
+/** Any path the auto-commit must skip: a secret or a CLI/build artifact. */
+export declare function isExcludedPath(path: string): boolean;
+/**
+ * Backstop subject naming the changed FILES — used only by the deterministic
+ * end-of-turn safety net (when the agent did not commit its own work via the
+ * git_commit tool). Deliberately NOT derived from the raw user prompt (a
+ * truncated prompt is meaningless, especially for a multi-step plan); a file list
+ * at least says what changed. The meaningful, model-authored message is the
+ * git_commit tool's job (the agent writes it per chunk/plan-step).
+ */
+export declare function buildFileListSubject(paths: string[]): string;
+/**
+ * Split an AGENT-authored message into a bounded subject (first line, <=72 so it
+ * passes conventional-commit hooks) and a bounded body. Strips CRs and drops any
+ * attribution line the agent already added (we append exactly one ourselves).
+ * Callers pass subject/body/attribution as SEPARATE `-m` flags so git inserts the
+ * blank-line separators itself — embedding "\n\n" in a single `-m` arg gets
+ * mangled by Windows execFile (the attribution then glues onto the subject).
+ */
+export declare function splitCommitMessage(message: string): {
+    subject: string;
+    body: string;
+};
+/** Snapshot the dirty/untracked path set before a turn (empty when not a repo). */
+export declare function snapshotDirtyPaths(cwd: string): Promise<Set<string>>;
+/**
+ * Commit the files the agent changed this turn. `dirtyBefore` is the snapshot
+ * from before the turn. Returns a result describing what happened; never throws.
+ */
+export declare function maybeAutoCommitTurn(opts: {
+    cwd: string;
+    dirtyBefore: Set<string>;
+    userMessage: string;
+}): Promise<AutoCommitResult>;
+/**
+ * Commit a SPECIFIC set of paths (absolute or repo-relative) with an
+ * AGENT-AUTHORED message — backs the git_commit tool. Stages only `paths` (minus
+ * secrets/artifacts), commits with the model's message + the attribution line,
+ * scoped by pathspec. No-op if nothing among `paths` is actually staged
+ * (e.g. already committed). Never throws.
+ */
+export declare function commitSpecificPaths(cwd: string, paths: string[], message: string): Promise<AutoCommitResult>;