muonroi-cli 1.8.0 → 1.8.1

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/auto-commit.js

@@ -21,6 +21,7 @@
  * cannot inject shell commands.
  */
 import { execFile } from "node:child_process";
+import { logger } from "../utils/logger.js";
 import { resolve } from "node:path";
 import { promisify } from "node:util";
 const pexecFile = promisify(execFile);
@@ -114,7 +115,7 @@ export async function gateStagedPaths(cwd, paths, budgetMs = 9_000) {
             new Promise((r) => setTimeout(() => r(TIMED_OUT), budgetMs)),
         ]);
         if (outcome === TIMED_OUT) {
-            console.error(`[commit-gate] LSP gate exceeded ${budgetMs}ms — allowing commit (fail-open)`);
+            logger.error("orchestrator", `[commit-gate] LSP gate exceeded ${budgetMs}ms — allowing commit (fail-open)`);
             return { ok: true };
         }
         if (errorFiles.length === 0)
@@ -123,7 +124,8 @@ export async function gateStagedPaths(cwd, paths, budgetMs = 9_000) {
         return { ok: false, summary };
     }
     catch (err) {
-        console.error(`[commit-gate] gate failed open: ${err?.message}`, {
+        logger.error("orchestrator", "gate failed open", {
+            error: err,
             stack: err?.stack?.split("\n").slice(0, 3),
         });
         return { ok: true };
@@ -282,7 +284,7 @@ export async function maybeAutoCommitTurn(opts) {
         return { committed: false, reason: "no-agent-changes" };
     const add = await git(cwd, ["add", "--", ...newPaths]);
     if (!add.ok) {
-        console.error(`[auto-commit] git add failed for ${newPaths.length} path(s) in ${cwd}`);
+        logger.error("orchestrator", `[auto-commit] git add failed for ${newPaths.length} path(s) in ${cwd}`);
         return { committed: false, reason: "add-failed" };
     }
     // G1 quality gate: do NOT auto-commit code that fails LSP error checks. The
@@ -290,7 +292,7 @@ export async function maybeAutoCommitTurn(opts) {
     // will see/fix it next turn. Staged paths stay staged (idempotent).
     const gate = await gateStagedPaths(cwd, newPaths);
     if (!gate.ok) {
-        console.error(`[auto-commit] skipped — staged files have LSP errors:\n${gate.summary}`);
+        logger.error("orchestrator", `[auto-commit] skipped — staged files have LSP errors:\n${gate.summary}`);
         return { committed: false, reason: "lsp-errors", detail: gate.summary };
     }
     // Separate -m flags → git inserts the blank line between subject and
@@ -306,7 +308,7 @@ export async function maybeAutoCommitTurn(opts) {
         ...newPaths,
     ]);
     if (!commit.ok) {
-        console.error(`[auto-commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
+        logger.error("orchestrator", `[auto-commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
         return { committed: false, reason: "commit-failed" };
     }
     const head = await git(cwd, ["rev-parse", "--short", "HEAD"]);
@@ -330,7 +332,7 @@ export async function commitSpecificPaths(cwd, paths, message) {
         return { committed: false, reason: "not-a-repo" };
     const add = await git(cwd, ["add", "--", ...safe]);
     if (!add.ok) {
-        console.error(`[git_commit] git add failed for ${safe.length} path(s) in ${cwd}`);
+        logger.error("orchestrator", `[git_commit] git add failed for ${safe.length} path(s) in ${cwd}`);
         return { committed: false, reason: "add-failed" };
     }
     // Only commit if these paths actually have staged changes (idempotent across
@@ -351,7 +353,7 @@ export async function commitSpecificPaths(cwd, paths, message) {
         : ["-m", subject, "-m", AUTO_COMMIT_ATTRIBUTION];
     const commit = await git(cwd, ["commit", ...mArgs, "--", ...safe]);
     if (!commit.ok) {
-        console.error(`[git_commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
+        logger.error("orchestrator", `[git_commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
         return { committed: false, reason: "commit-failed" };
     }
     const head = await git(cwd, ["rev-parse", "--short", "HEAD"]);

package/dist/src/orchestrator/message-processor.d.ts

@@ -21,6 +21,7 @@ import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
  * subsequent turns). Method callbacks delegate to Agent private methods.
  */
 export interface MessageProcessorDeps extends TurnRunnerDepsBase {
+    readonly isSubSession?: boolean;
     /** Live messageSeqs array (mutated by push; parallel to messages). */
     readonly messageSeqs: Array<number | null>;
     /** Session bookkeeping. */
@@ -75,6 +76,7 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     setMessages(messages: ModelMessage[]): void;
     requireProvider(): LegacyProvider;
     emitSubagentStatus(status: SubagentStatus | null): void;
+    consultParentSession?: (question: string) => Promise<string>;
     fireHook(input: unknown, signal?: AbortSignal): Promise<{
         blocked: boolean;
         blockingErrors: Array<{

package/dist/src/orchestrator/message-processor.js

@@ -692,6 +692,10 @@ export class MessageProcessor {
         const _pilResponseTools = getResponseToolSet(pilCtx, deps.providerId);
         const _hasResponseTools = Object.keys(_pilResponseTools).length > 0;
         const systemParts = buildSystemPromptParts(deps.bash.getCwd(), deps.mode, deps.bash.getSandboxMode(), deps.getPlanContext(), subagents, deps.bash.getSandboxSettings(), deps.providerId, deps.getResumeDigest(), { chitchat: isChitchat });
+        // F3c — tool-turn system prompt: same context, but skips native-capabilities
+        // and skills sections (~4K tokens) that the model already saw on the first
+        // call.  The orchestrator switches to this on the 2nd+ streamText invocation.
+        const toolTurnParts = buildSystemPromptParts(deps.bash.getCwd(), deps.mode, deps.bash.getSandboxMode(), deps.getPlanContext(), subagents, deps.bash.getSandboxSettings(), deps.providerId, deps.getResumeDigest(), { chitchat: isChitchat, toolTurn: true });
         if (deps.getResumeDigest())
             deps.setResumeDigest(null);
         // Skip vision/playwright guidance unless the user's message has a URL
@@ -700,6 +704,8 @@ export class MessageProcessor {
         const _browserGuidanceNeeded = /https?:\/\/\S+|\b(screenshot|browser|playwright|chrome|figma|canva|render|webpage|website|url|hyperlink|navigate|click|scrape)\b/i.test(userMessage);
         const playwrightGuidance = isChitchat || !_browserGuidanceNeeded ? "" : getVisionGuidanceForTextOnly(turnModelId);
         const system = applyModelConstraints(applyPilSuffix(`${systemParts.staticPrefix}${playwrightGuidance}${systemParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
+        // Tool-turn system: same template as system but with toolTurn-prefix
+        const toolTurnSystem = applyModelConstraints(applyPilSuffix(`${toolTurnParts.staticPrefix}${playwrightGuidance}${toolTurnParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
         const runtime = resolveModelRuntime(provider, turnModelId);
         const modelInfo = runtime.modelInfo;
         // SAMR: Step-Aware Model Routing — downgrade to fast model for tool-execution
@@ -784,6 +790,7 @@ export class MessageProcessor {
                 taskHash,
                 provider,
                 system,
+                toolTurnSystem,
                 routerStore,
                 attemptedOverflowRecovery,
                 patternLoopForceHalt,

package/dist/src/orchestrator/orchestrator.d.ts

@@ -24,6 +24,7 @@ export declare class Agent {
     /** UI-registered live-queue steer drain; see Agent.setSteerDrain. */
     private steerDrain;
     private maxToolRounds;
+    private hardMaxToolRounds;
     private mode;
     private modelId;
     private maxTokens;
@@ -125,6 +126,7 @@ export declare class Agent {
     getCwd(): string;
     setCwd(dir: string): void;
     getMessages(): ModelMessage[];
+    setMessages(messages: ModelMessage[]): void;
     listSchedules(): Promise<StoredSchedule[]>;
     removeSchedule(id: string): Promise<string>;
     getScheduleDaemonStatus(): Promise<ScheduleDaemonStatus>;
@@ -233,6 +235,7 @@ export declare class Agent {
     private appendMidTurnMessages;
     private appendCompletedTurn;
     private fireHook;
+    private estimateConversationChars;
     processMessage(userMessage: string, observer?: ProcessMessageObserver, images?: Array<{
         path: string;
         mediaType: string;