@jx-grxf/patchpilot 1.0.0 → 1.2.0

package/dist/core/agent.js

@@ -4,6 +4,8 @@ import { platform, release, type } from "node:os";
 import { createModelClient } from "./modelClient.js";
 import { resolveProviderReasoning } from "./reasoning.js";
 import { formatSubagentContext, runSubagentAdvisors } from "./subagents.js";
+import { MAX_TOOL_CALLS_PER_RESPONSE } from "./types.js";
+import { estimateTokens } from "./tokenAccounting.js";
 import { getToolSpec, WorkspaceTools } from "./workspace.js";
 export class AgentRunner {
     client;
@@ -16,11 +18,24 @@ export class AgentRunner {
             ollamaUrl: options.ollamaUrl,
             workspace: options.workspace
         });
+        const documentAnalyzer = this.client.analyzeFile && (this.client.supportsFileAnalysis?.() ?? true)
+            ? async (request) => {
+                const result = await this.client.analyzeFile?.({
+                    model: options.model,
+                    path: request.path,
+                    prompt: request.prompt,
+                    signal: request.signal
+                });
+                return result?.content ?? "";
+            }
+            : undefined;
         this.tools = new WorkspaceTools({
             root: options.workspace,
             allowWrite: options.allowWrite,
             allowShell: options.allowShell,
+            allowShellMetacharacters: options.allowShellMetacharacters,
             allowExternalFileAnalysis: options.allowExternalFileAnalysis,
+            documentAnalyzer,
             memoryEnabled: options.memoryEnabled,
             signal: options.signal,
             approvalHandler: options.approvalHandler
@@ -37,15 +52,34 @@ export class AgentRunner {
             startedAt: new Date().toISOString()
         });
         const workspaceSummary = await buildWorkspaceSummary(this.tools.root);
-        let maxSteps = resolveMaxSteps(task, this.options.maxSteps, this.options.thinkingMode);
+        const ultramaxx = Boolean(this.options.ultramaxx);
+        let maxSteps = resolveMaxSteps(task, this.options.maxSteps, this.options.thinkingMode, ultramaxx);
         const reasoningEffort = resolveProviderReasoning({
             provider: this.options.provider,
             model: this.options.model,
-            requested: resolveReasoningEffort(task, this.options.reasoningEffort)
+            requested: ultramaxx ? "xhigh" : resolveReasoningEffort(task, this.options.reasoningEffort)
         });
         let stepIndex = 0;
         let repairs = 0;
+        let malformedResponses = 0;
+        let lastReadFilePath = "";
         let subagentContext = "";
+        let todos = [];
+        const expectsTodos = shouldExpectTodos(task, ultramaxx);
+        let didNudgeForTodos = false;
+        let didPushBackForTodos = false;
+        let didPushBackForVerification = false;
+        let hadWrite = false;
+        let verifiedSinceLastWrite = true;
+        let emptyToolBatches = 0;
+        const recentToolSignatures = [];
+        if (ultramaxx) {
+            yield {
+                type: "status",
+                message: "ultramaxx backend escalation active: xhigh reasoning, mandatory todos, expanded verification guard",
+                workState: "planning"
+            };
+        }
         if (this.options.subagents && shouldUseSubagents(task)) {
             yield {
                 type: "status",
@@ -80,7 +114,10 @@ export class AgentRunner {
                     hasApprovalHandler: Boolean(this.options.approvalHandler)
                 }, {
                     allowExternalFileAnalysis: Boolean(this.options.allowExternalFileAnalysis),
-                    memoryEnabled: Boolean(this.options.memoryEnabled)
+                    memoryEnabled: Boolean(this.options.memoryEnabled),
+                    allowShellMetacharacters: Boolean(this.options.allowShellMetacharacters),
+                    ultramaxx,
+                    expectsTodos
                 })
             },
             {
@@ -114,13 +151,21 @@ export class AgentRunner {
             });
             let modelResponse;
             try {
-                modelResponse = await this.client.chat({
+                const chatAttempts = this.chatWithRetry({
                     model: this.options.model,
                     messages,
-                    formatJson: true,
                     reasoningEffort,
-                    signal: this.options.signal
+                    requestWorkState,
+                    attemptLabel: `step ${stepIndex + 1}`
                 });
+                for (;;) {
+                    const nextAttempt = await chatAttempts.next();
+                    if (nextAttempt.done) {
+                        modelResponse = nextAttempt.value;
+                        break;
+                    }
+                    yield nextAttempt.value;
+                }
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -143,38 +188,89 @@ export class AgentRunner {
                 parsedResponse = parseAgentResponse(rawResponse);
             }
             catch (error) {
-                repairs += 1;
-                yield {
-                    type: "status",
-                    message: `repairing model protocol: ${formatParseError(error)}`,
-                    workState: "planning"
-                };
-                messages.push({
-                    role: "assistant",
-                    content: clipPromptValue(rawResponse, 2000)
-                });
-                messages.push({
-                    role: "user",
-                    content: "Your previous response was invalid. Return exactly one JSON object now. Do not explain. Use either {\"action\":\"tools\",\"message\":\"...\",\"tool_calls\":[...]} or {\"action\":\"final\",\"message\":\"...\"}. For simple file edits, call write_file with a workspace-relative path."
-                });
-                if (repairs >= 3) {
+                const recoveredResponse = recoverMalformedToolResponse(rawResponse);
+                if (recoveredResponse) {
+                    parsedResponse = recoveredResponse;
+                    const recoveredPath = recoveredResponse.tool_calls[0]?.arguments.path ?? "workspace file";
                     yield {
-                        type: "final",
-                        message: "The model kept returning invalid tool protocol. Try a stronger coding model or switch advisors off for this task.",
-                        workState: "error"
+                        type: "status",
+                        message: `recovered malformed model protocol as ${recoveredResponse.tool_calls[0]?.name ?? "tool"} for ${recoveredPath}`,
+                        workState: "planning"
                     };
-                    await this.options.sessionStore?.append({
-                        type: "run.failed",
-                        runId,
-                        message: "The model kept returning invalid tool protocol.",
-                        failedAt: new Date().toISOString()
+                }
+                else {
+                    repairs += 1;
+                    malformedResponses += 1;
+                    yield {
+                        type: "status",
+                        message: `repairing model protocol: ${formatParseError(error)}`,
+                        workState: "planning"
+                    };
+                    messages.push({
+                        role: "assistant",
+                        content: clipPromptValue(rawResponse, 2000)
                     });
-                    return;
+                    messages.push({
+                        role: "user",
+                        content: "Your previous response was invalid. Return exactly one JSON object now. Do not explain. Use either {\"action\":\"tools\",\"message\":\"...\",\"tool_calls\":[...]} or {\"action\":\"final\",\"message\":\"...\"}. For simple file edits, call write_file with a workspace-relative path."
+                    });
+                    if (repairs >= 3 || malformedResponses >= 3) {
+                        yield {
+                            type: "final",
+                            message: "The model kept returning invalid tool protocol. Try a stronger coding model or switch advisors off for this task.",
+                            workState: "error"
+                        };
+                        await this.options.sessionStore?.append({
+                            type: "run.failed",
+                            runId,
+                            message: "The model kept returning invalid tool protocol.",
+                            failedAt: new Date().toISOString()
+                        });
+                        return;
+                    }
+                    continue;
                 }
-                continue;
             }
             repairs = 0;
             if (parsedResponse.action === "final") {
+                if (expectsTodos && hasOpenTodos(todos) && !didPushBackForTodos) {
+                    didPushBackForTodos = true;
+                    messages.push({
+                        role: "assistant",
+                        content: JSON.stringify(parsedResponse)
+                    });
+                    messages.push({
+                        role: "user",
+                        content: "Your todo list still has pending or in_progress items. Update the todo list first, then return final when the work is genuinely complete."
+                    });
+                    stepIndex += 1;
+                    continue;
+                }
+                if (ultramaxx && hadWrite && !verifiedSinceLastWrite && !didPushBackForVerification) {
+                    didPushBackForVerification = true;
+                    messages.push({
+                        role: "assistant",
+                        content: JSON.stringify(parsedResponse)
+                    });
+                    messages.push({
+                        role: "user",
+                        content: "You changed files in ultramaxx mode without verification since the last write. Run tests, a script, shell verification, or git_diff before final."
+                    });
+                    stepIndex += 1;
+                    continue;
+                }
+                if (expectsTodos && isTodoOnlyFinalResponse(parsedResponse.message)) {
+                    messages.push({
+                        role: "assistant",
+                        content: JSON.stringify(parsedResponse)
+                    });
+                    messages.push({
+                        role: "user",
+                        content: "Your final answer was invalid because it only reported todo/status progress or deferred to an earlier step. Return a real final answer now with the actual findings, changes made, verification run, and any remaining risks. Do not mention update_todo as the outcome."
+                    });
+                    stepIndex += 1;
+                    continue;
+                }
                 yield {
                     type: "final",
                     message: parsedResponse.message,
@@ -188,7 +284,13 @@ export class AgentRunner {
                 });
                 return;
             }
-            if (looksLikeClarification(parsedResponse.message)) {
+            yield {
+                type: "assistant",
+                message: parsedResponse.message,
+                workState: "planning"
+            };
+            const toolCalls = parsedResponse.tool_calls.slice(0, MAX_TOOL_CALLS_PER_RESPONSE).map(normalizeToolCall);
+            if (toolCalls.length === 0 && looksLikeClarification(parsedResponse.message)) {
                 yield {
                     type: "final",
                     message: parsedResponse.message,
@@ -202,17 +304,107 @@ export class AgentRunner {
                 });
                 return;
             }
-            yield {
-                type: "assistant",
-                message: parsedResponse.message,
-                workState: "planning"
-            };
-            const toolCalls = parsedResponse.tool_calls.map(normalizeToolCall);
-            const toolCallRecords = toolCalls.map((toolCall) => ({
+            if (toolCalls.length === 0) {
+                emptyToolBatches += 1;
+                messages.push({
+                    role: "assistant",
+                    content: JSON.stringify(parsedResponse)
+                });
+                if (shouldStopAfterEmptyToolBatches(emptyToolBatches)) {
+                    yield {
+                        type: "final",
+                        message: "Stopped because the model returned a tool action without tool calls twice. Retry the task or switch models.",
+                        workState: "error"
+                    };
+                    await this.options.sessionStore?.append({
+                        type: "run.failed",
+                        runId,
+                        message: "Model returned empty tool batches repeatedly.",
+                        failedAt: new Date().toISOString()
+                    });
+                    return;
+                }
+                messages.push({
+                    role: "user",
+                    content: "You returned action:\"tools\" without any tool_calls. Either call one valid tool now or return action:\"final\" with the completed answer."
+                });
+                stepIndex += 1;
+                continue;
+            }
+            emptyToolBatches = 0;
+            const { todoCalls, workspaceCalls } = splitTodoToolCalls(toolCalls);
+            if (expectsTodos && todos.length === 0 && workspaceCalls.length > 0 && !didNudgeForTodos) {
+                didNudgeForTodos = true;
+                messages.push({
+                    role: "assistant",
+                    content: JSON.stringify({
+                        action: "tools",
+                        message: parsedResponse.message,
+                        tool_calls: toolCalls
+                    })
+                });
+                messages.push({
+                    role: "user",
+                    content: "This task has multiple steps. Call update_todo with a concrete 2-6 item plan first, then continue with the needed tools."
+                });
+                stepIndex += 1;
+                continue;
+            }
+            const repeatedCall = findRepeatedToolCall(workspaceCalls, recentToolSignatures);
+            if (repeatedCall) {
+                messages.push({
+                    role: "assistant",
+                    content: JSON.stringify({
+                        action: "tools",
+                        message: parsedResponse.message,
+                        tool_calls: toolCalls
+                    })
+                });
+                messages.push({
+                    role: "user",
+                    content: `You already ran ${repeatedCall.name} with the same arguments repeatedly. Act on the previous result or return final instead of repeating it.`
+                });
+                stepIndex += 1;
+                continue;
+            }
+            const todoResults = [];
+            for (const todoCall of todoCalls) {
+                todos = normalizeTodoItems(todoCall.arguments, todos);
+                const summary = summarizeTodos(todos);
+                yield {
+                    type: "todo",
+                    items: todos,
+                    summary,
+                    workState: "planning"
+                };
+                await this.options.sessionStore?.append({
+                    type: "todo.updated",
+                    runId,
+                    items: todos,
+                    summary,
+                    createdAt: new Date().toISOString()
+                });
+                todoResults.push({
+                    tool: "update_todo",
+                    ok: true,
+                    summary,
+                    content: JSON.stringify({ items: todos }),
+                    toolCallId: createToolCallId("update_todo"),
+                    category: "state",
+                    preview: undefined,
+                    approval: undefined,
+                    metadata: {
+                        items: todos
+                    },
+                    workState: "planning"
+                });
+            }
+            const toolCallRecords = workspaceCalls.map((toolCall) => ({
                 id: createToolCallId(toolCall.name),
                 call: toolCall,
                 workState: workStateForTool(toolCall.name)
             }));
+            const workspaceCallById = new Map(toolCallRecords.map((record) => [record.id, record.call]));
             for (const record of toolCallRecords) {
                 await this.options.sessionStore?.append({
                     type: "tool.requested",
@@ -224,10 +416,25 @@ export class AgentRunner {
                     createdAt: new Date().toISOString()
                 });
             }
-            const toolResults = toolCalls.every(isReadOnlyToolCall)
-                ? await Promise.all(toolCallRecords.map((record) => executeToolSafely(this.tools, record.call, record.id)))
-                : await executeToolCallsSequentially(this.tools, toolCallRecords);
+            const toolResults = [
+                ...todoResults,
+                ...(await executeToolCallsWithReadParallelism(this.tools, toolCallRecords))
+            ];
             for (const toolResult of toolResults) {
+                if (isWriteToolResult(toolResult)) {
+                    hadWrite = true;
+                    verifiedSinceLastWrite = false;
+                }
+                else if (isVerificationToolResult(toolResult)) {
+                    verifiedSinceLastWrite = true;
+                }
+                const sourceCall = workspaceCallById.get(toolResult.toolCallId);
+                if (toolResult.ok && sourceCall?.name === "read_file") {
+                    const readPath = readToolString(sourceCall.arguments.path);
+                    if (readPath) {
+                        lastReadFilePath = readPath;
+                    }
+                }
                 if (toolResult.approval) {
                     yield {
                         type: "approval",
@@ -253,6 +460,7 @@ export class AgentRunner {
                     toolCallId: toolResult.toolCallId,
                     category: toolResult.category,
                     preview: toolResult.preview,
+                    content: toolResult.ok ? undefined : toolResult.content,
                     metadata: toolResult.metadata
                 };
                 await this.options.sessionStore?.append({
@@ -278,9 +486,24 @@ export class AgentRunner {
                 role: "user",
                 content: formatToolResultsForPrompt(toolResults)
             });
+            compactTranscript(messages);
             stepIndex += 1;
-            if (this.options.thinkingMode === "adaptive" && stepIndex >= maxSteps && shouldExtendAdaptiveRun(task, toolResults, maxSteps)) {
-                const nextMaxSteps = Math.min(32, maxSteps + 4);
+            if (this.options.shouldStopAfterStep?.()) {
+                yield {
+                    type: "final",
+                    message: "Stopped after the current step.",
+                    workState: "done"
+                };
+                await this.options.sessionStore?.append({
+                    type: "run.failed",
+                    runId,
+                    message: "Stopped after the current step.",
+                    failedAt: new Date().toISOString()
+                });
+                return;
+            }
+            if (this.options.thinkingMode === "adaptive" && stepIndex >= maxSteps && shouldExtendAdaptiveRun(task, toolResults, maxSteps, ultramaxx ? 60 : 32)) {
+                const nextMaxSteps = Math.min(ultramaxx ? 60 : 32, maxSteps + 4);
                 if (nextMaxSteps > maxSteps) {
                     maxSteps = nextMaxSteps;
                     yield {
@@ -303,6 +526,73 @@ export class AgentRunner {
             failedAt: new Date().toISOString()
         });
     }
+    async *chatWithRetry(options) {
+        const maxAttempts = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                return await this.client.chat({
+                    model: options.model,
+                    messages: options.messages,
+                    formatJson: true,
+                    reasoningEffort: options.reasoningEffort,
+                    signal: this.options.signal
+                });
+            }
+            catch (error) {
+                lastError = error;
+                if (this.options.signal?.aborted || attempt >= maxAttempts || !isRetryableModelError(error)) {
+                    break;
+                }
+                yield {
+                    type: "status",
+                    message: `provider retry ${attempt + 1}/${maxAttempts} after ${formatRetryableModelError(error)}`,
+                    workState: options.requestWorkState
+                };
+                await delay(modelRetryDelayMs(attempt));
+            }
+        }
+        throw lastError;
+    }
+}
+export function recoverMalformedToolResponse(rawContent) {
+    const targetPath = readWriteFileToolPath(rawContent);
+    if (!targetPath) {
+        return null;
+    }
+    if (!/"tool_calls"\s*:/.test(rawContent) || !/"name"\s*:\s*"write_file"/.test(rawContent)) {
+        return null;
+    }
+    const htmlContent = readFirstRegexGroup(rawContent, /(```(?:html)?\s*)([\s\S]*?<\/html>)\s*```/i, 2) ??
+        readFirstRegexGroup(rawContent, /(<!doctype html[\s\S]*?<\/html>)/i) ??
+        readFirstRegexGroup(rawContent, /(<html[\s\S]*?<\/html>)/i);
+    if (!htmlContent) {
+        return null;
+    }
+    return {
+        action: "tools",
+        message: "Recovered malformed HTML tool response.",
+        tool_calls: [
+            {
+                name: "write_file",
+                arguments: {
+                    path: targetPath,
+                    content: htmlContent.trim()
+                }
+            }
+        ]
+    };
+}
+function readFirstRegexGroup(value, pattern, groupIndex = 1) {
+    const match = value.match(pattern);
+    const group = match?.[groupIndex];
+    return typeof group === "string" && group.trim() ? group : null;
+}
+function readWriteFileToolPath(rawContent) {
+    return readFirstRegexGroup(rawContent, /"tool_calls"\s*:\s*\[[\s\S]*?"name"\s*:\s*"write_file"[\s\S]*?"arguments"\s*:\s*\{[\s\S]*?"path"\s*:\s*"([^"]+)"/);
+}
+function readToolString(value) {
+    return typeof value === "string" ? value : "";
 }
 function shouldUseSubagents(task) {
     const normalizedTask = task.toLowerCase();
@@ -311,6 +601,37 @@ function shouldUseSubagents(task) {
     }
     return /\b(repo|repository|projekt|project|code|file|datei|test|build|fix|debug|implement|refactor|review|analyze|analyse|analysiere|prüf|pruef|bewerte|architektur|erklär|erklaer|such|find|install|commit|diff|patch|src|readme|sprache|programmiersprache|stack|framework|dependencies|abhängigkeiten|abhaengigkeiten|typescript|javascript|node|swift|python|c)\b/.test(normalizedTask);
 }
+export function shouldExpectTodos(task, ultramaxx = false) {
+    if (ultramaxx) {
+        return true;
+    }
+    const words = task.trim().split(/\s+/).filter(Boolean).length;
+    return (words > 8 &&
+        /\b(implement|refactor|fix|debug|add|build|migrate|rewrite|hardening|verify|test|release|umsetz|reparier|baue|füge|fuege|prüf|pruef)\b/i.test(task));
+}
+export function isTodoOnlyFinalResponse(message) {
+    const normalized = message.trim().toLowerCase().replace(/\s+/g, " ");
+    if (!normalized) {
+        return true;
+    }
+    const mentionsTodoState = /\b(update_todo|todo(?:s|-list| list|-liste| liste)?|checklist|aufgabenliste)\b/i.test(normalized);
+    const mentionsProgressOnly = /\b(updated|aktualisiert|completed|complete|done|erledigt|abgeschlossen|marked|gepflegt)\b/i.test(normalized);
+    const defersToEarlierStep = /\b(previous|prior|earlier|above|already|before)\b/i.test(normalized) ||
+        /\b(vorherig|vorherigen|vorher|oben|zuvor|bereits|letzten schritt)\b/i.test(normalized);
+    const mentionsDeferredAnswer = /\b(summary|overview|answer|result|findings|zusammenfassung|überblick|ueberblick|antwort|ergebnis)\b/i.test(normalized);
+    const hasConcreteOutcome = /\b(fixed|implemented|changed|added|removed|verified|tested|ran|created|gefixt|implementiert|geändert|geaendert|ergänzt|ergaenzt|verifiziert|getestet)\b|(?:^|\s)(?:src|tests|docs)\//i.test(normalized);
+    const wordCount = normalized.split(/\s+/).filter(Boolean).length;
+    if (mentionsTodoState && defersToEarlierStep) {
+        return true;
+    }
+    if (mentionsTodoState && mentionsProgressOnly && !hasConcreteOutcome && wordCount <= 18) {
+        return true;
+    }
+    if (mentionsDeferredAnswer && defersToEarlierStep && !hasConcreteOutcome && wordCount <= 24) {
+        return true;
+    }
+    return /^(done|complete|completed|erledigt|fertig|ok)[.! ]*$/i.test(normalized);
+}
 function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, resumeContext, permissions, experimental) {
     const workspaceLabel = path.basename(workspaceRoot) || "workspace";
     const writePolicy = permissions.allowWrite
@@ -348,6 +669,17 @@ function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, res
         "Never pass placeholder examples like relative/path, path/to/file, or <path> as tool arguments.",
         "For repository summaries, inspect README.md, package.json, tests, docs, and top-level source files before answering.",
         "For implementation tasks, first inspect the narrowest relevant files, then edit only what is needed.",
+        experimental.expectsTodos
+            ? "This task requires proactive todos. Your FIRST tool call MUST be update_todo with a concrete 2-6 item plan before reading or editing. After each completed step, call update_todo to mark progress. Exactly one item may be in_progress."
+            : "If a task needs more than one tool call or touches more than one file, your FIRST tool call MUST be update_todo with a concrete 2-6 item plan. Tiny one-file edits, single-file reads, and direct answers do not need todos.",
+        "Todo example required: user asks to fix a provider bug and run tests -> first call update_todo, then inspect, edit, verify, and mark items completed.",
+        "Todo example not required: user asks what package manager this repo uses -> inspect package files or answer directly.",
+        experimental.ultramaxx
+            ? "ULTRAMAXX mode is active: use xhigh care, keep todos mandatory, verify after writes before final, and do not skip self-checks."
+            : "",
+        experimental.expectsTodos
+            ? "Final answers must contain the actual outcome: findings, changes made, verification run, and remaining risks when relevant. Never use final just to say the todo list was updated or that the answer is in a previous step."
+            : "",
         "When diagnosing a failure, form a concrete hypothesis, gather targeted evidence with tools, then fix the smallest cause.",
         experimental.allowExternalFileAnalysis
             ? "Experimental file analysis is enabled: inspect_document may inspect supported absolute paths outside the workspace when the user provides them."
@@ -355,6 +687,9 @@ function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, res
         experimental.memoryEnabled
             ? "Experimental memory is enabled: use memory_search for relevant durable context and memory_remember when the user asks you to remember something or states durable project guidance."
             : "Experimental memory is disabled.",
+        experimental.allowShellMetacharacters
+            ? "Experimental shell metacharacters are enabled: run_shell may use pipes, &&, and ;. Redirects, shell expansion, background jobs, OR chains, and multiline commands still require explicit approval even in bypass."
+            : "Experimental shell metacharacters are disabled: run_shell may use simple commands and pipes only.",
         workspaceSummary ? ["", "Workspace context:", workspaceSummary].join("\n") : "",
         resumeContext
             ? [
@@ -385,12 +720,14 @@ function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, res
         "{\"action\":\"final\",\"message\":\"short useful answer\"}",
         "",
         "Available tools:",
+        "- update_todo: {\"items\":[{\"id\":\"inspect\",\"content\":\"Inspect relevant files\",\"status\":\"in_progress\"},{\"id\":\"verify\",\"content\":\"Run checks\",\"status\":\"pending\"}]} to maintain the visible task checklist. For multi-step implementation work, call this before and after meaningful task changes.",
         "- list_files: {\"path\":\".\"}",
+        "- find_files: {\"query\":\"agent\",\"limit\":80} for matching workspace file paths without reading file contents",
         "- read_file: {\"path\":\"src/index.ts\"}",
         "- read_range: {\"path\":\"src/index.ts\",\"start\":1,\"end\":80}",
         "- file_info: {\"path\":\"src/index.ts\"}",
         "- search_text: {\"query\":\"functionName\"}",
-        "- inspect_document: {\"path\":\"docs/spec.pdf\"} for pdf, docx, and text/code files",
+        "- inspect_document: {\"path\":\"docs/spec.pdf\",\"mode\":\"auto\"} for pdf, docx, images, and text/code files. Use mode \"local\" or \"ocr\" only when the user explicitly asks for local text/OCR extraction.",
         ...(experimental.memoryEnabled
             ? [
                 "- memory_search: {\"query\":\"provider setup\",\"limit\":5}",
@@ -399,9 +736,17 @@ function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, res
             : []),
         "- git_status: {} for current branch and dirty files",
         "- git_diff: {\"path\":\"src/index.ts\"} or {} for all current changes",
+        "- git_log: {\"limit\":8} for recent commits without shell access",
+        "- git_show: {\"revision\":\"HEAD\",\"path\":\"src/index.ts\"} or {\"revision\":\"HEAD\"} for a compact revision summary",
         "- list_changed_files: {}",
         "- list_scripts: {} for package manager scripts from package.json",
-        "- write_file: {\"path\":\"test2/test.txt\",\"content\":\"full file content\"}",
+        "- repo_overview: {} for package metadata, Git state, and top-level files",
+        "- test_list: {} for likely tests and test-related scripts without running them",
+        "- dependency_tree: {} for top-level package dependencies",
+        "- write_file: {\"path\":\"test2/test.txt\",\"content\":\"full file content\"} for new files or intentional full-file replacement",
+        "- edit_file: {\"path\":\"src/index.ts\",\"find\":\"old unique text\",\"replace\":\"new text\"} or {\"path\":\"src/index.ts\",\"startLine\":10,\"endLine\":12,\"expected\":\"current lines\",\"replacement\":\"new lines\"} for existing files. Include expected with line-range edits when you have read the target lines.",
+        "- create_pdf: {\"path\":\"docs/summary.pdf\",\"title\":\"Summary\",\"content\":\"plain text\"}",
+        "- create_docx: {\"path\":\"docs/summary.docx\",\"title\":\"Summary\",\"content\":\"plain text\"}",
         "- apply_patch: {\"patch\":\"unified git patch\"}",
         "- run_script: {\"script\":\"test\"}",
         "- run_tests: {}",
@@ -409,9 +754,9 @@ function buildSystemPrompt(workspaceRoot, subagentContext, workspaceSummary, res
         "",
         "Act like a coding agent. For simple create/edit/run requests, use tools directly instead of over-warning.",
         "Do not call search_text with an empty query. Use list_files {\"path\":\".\"} to inspect a directory.",
-        "Prefer reading before risky edits; for explicit simple writes, write the requested file.",
-        "Batch independent read-only tool calls in one response when it helps avoid extra thinking steps.",
-        "Prefer parallel read-only context gathering over one file per step.",
+        "Prefer reading before risky edits. For existing files, prefer edit_file or apply_patch over full-file write_file.",
+        "Batch small related tool calls in one response when it helps avoid extra thinking steps.",
+        "Keep update_todo current: mark exactly what you are doing as in_progress and completed tasks as completed.",
         "In final answers, separate verified facts from remaining risks.",
         "Keep tool requests and final answers compact."
     ].join("\n");
@@ -421,8 +766,36 @@ function looksLikeClarification(message) {
     return (normalizedMessage.endsWith("?") &&
         /\b(what|which|please provide|would you like|do you want|can you specify|welche|was genau|bitte)\b/.test(normalizedMessage));
 }
-function isReadOnlyToolCall(toolCall) {
-    return getToolSpec(toolCall.name)?.sideEffects === "none";
+export function shouldStopAfterEmptyToolBatches(emptyToolBatches) {
+    return emptyToolBatches >= 2;
+}
+export function findRepeatedToolCall(toolCalls, recentSignatures) {
+    for (const toolCall of toolCalls) {
+        const signature = toolCallSignature(toolCall);
+        recentSignatures.push(signature);
+        while (recentSignatures.length > 6) {
+            recentSignatures.shift();
+        }
+        if (recentSignatures.filter((item) => item === signature).length >= 3) {
+            return toolCall;
+        }
+    }
+    return null;
+}
+function toolCallSignature(toolCall) {
+    return `${toolCall.name}:${stableStringify(toolCall.arguments)}`;
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (isRecord(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
 }
 function normalizeToolCall(toolCall) {
     if (toolCall.name === "search_text") {
@@ -438,13 +811,108 @@ function normalizeToolCall(toolCall) {
     }
     return toolCall;
 }
-async function executeToolCallsSequentially(tools, toolCalls) {
+function splitTodoToolCalls(toolCalls) {
+    return {
+        todoCalls: toolCalls.filter((toolCall) => toolCall.name === "update_todo"),
+        workspaceCalls: toolCalls.filter((toolCall) => toolCall.name !== "update_todo")
+    };
+}
+export function normalizeTodoItems(argumentsValue, existingItems = []) {
+    const rawItems = Array.isArray(argumentsValue.items) ? argumentsValue.items : Array.isArray(argumentsValue.todos) ? argumentsValue.todos : [];
+    const existingById = new Map(existingItems.map((item) => [item.id, item]));
+    const normalizedItems = [];
+    for (const rawItem of rawItems.slice(0, 12)) {
+        if (!isRecord(rawItem)) {
+            continue;
+        }
+        const content = readTodoString(rawItem.content) || readTodoString(rawItem.text) || readTodoString(rawItem.task);
+        if (!content) {
+            continue;
+        }
+        const explicitId = readTodoString(rawItem.id);
+        const id = sanitizeTodoId(explicitId || existingById.get(content)?.id || content);
+        const status = normalizeTodoStatus(rawItem.status);
+        normalizedItems.push({
+            id,
+            content: content.slice(0, 120),
+            status
+        });
+    }
+    return dedupeTodoItems(normalizedItems);
+}
+function summarizeTodos(items) {
+    const completed = items.filter((item) => item.status === "completed").length;
+    const active = items.find((item) => item.status === "in_progress");
+    return active ? `${completed}/${items.length} done, working on ${active.content}` : `${completed}/${items.length} todos done`;
+}
+function hasOpenTodos(items) {
+    return items.some((item) => item.status === "pending" || item.status === "in_progress");
+}
+function dedupeTodoItems(items) {
+    const seen = new Set();
+    const deduped = [];
+    for (const item of items) {
+        const uniqueId = seen.has(item.id) ? `${item.id}-${deduped.length + 1}` : item.id;
+        seen.add(uniqueId);
+        deduped.push({ ...item, id: uniqueId });
+    }
+    return deduped;
+}
+function normalizeTodoStatus(value) {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase().replace(/[- ]/g, "_") : "";
+    if (normalized === "done" || normalized === "complete" || normalized === "completed" || normalized === "checked") {
+        return "completed";
+    }
+    if (normalized === "active" || normalized === "doing" || normalized === "current" || normalized === "in_progress") {
+        return "in_progress";
+    }
+    return "pending";
+}
+function sanitizeTodoId(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized.slice(0, 40) || `todo-${Date.now().toString(36)}`;
+}
+function readTodoString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export async function executeToolCallsWithReadParallelism(tools, toolCalls) {
     const results = [];
-    for (const toolCall of toolCalls) {
-        results.push(await executeToolSafely(tools, toolCall.call, toolCall.id));
+    for (let index = 0; index < toolCalls.length;) {
+        const currentCall = toolCalls[index];
+        if (!isParallelSafeToolCall(currentCall)) {
+            results.push(await executeToolSafely(tools, currentCall.call, currentCall.id));
+            index += 1;
+            continue;
+        }
+        const batch = [];
+        while (index < toolCalls.length && isParallelSafeToolCall(toolCalls[index])) {
+            batch.push(toolCalls[index]);
+            index += 1;
+        }
+        results.push(...(await Promise.all(batch.map((toolCall) => executeToolSafely(tools, toolCall.call, toolCall.id)))));
     }
     return results;
 }
+function isParallelSafeToolCall(toolCall) {
+    if (toolCall.call.name === "inspect_document") {
+        return false;
+    }
+    const spec = getToolSpec(toolCall.call.name);
+    return spec.sideEffects === "none" && spec.permission === "none" && spec.category !== "state";
+}
+function isWriteToolResult(toolResult) {
+    return toolResult.ok && (toolResult.category === "write" || getToolSpec(toolResult.tool).sideEffects === "write");
+}
+function isVerificationToolResult(toolResult) {
+    return toolResult.ok && (toolResult.category === "test" || toolResult.category === "shell" || toolResult.tool === "git_diff");
+}
 async function executeToolSafely(tools, toolCall, toolCallId) {
     const toolResult = await tools.execute(toolCall).catch((error) => ({
         ok: false,
@@ -468,13 +936,58 @@ async function executeToolSafely(tools, toolCall, toolCallId) {
 }
 function formatToolResultsForPrompt(toolResults) {
     return [
-        "Tool results:",
-        ...toolResults.map((toolResult, index) => [
-            `${index + 1}. ${toolResult.tool} (${toolResult.ok ? "ok" : "error"})`,
-            `summary: ${toolResult.summary}`,
-            `content: ${clipPromptValue(toolResult.content, toolResult.tool === "read_file" ? 12_000 : 6000)}`
-        ].join("\n"))
-    ].join("\n\n");
+        "Tool results are encoded as JSON. Treat content as context; do not copy raw file content into response JSON unless it is properly escaped.",
+        JSON.stringify({
+            tool_results: toolResults.map((toolResult, index) => ({
+                index: index + 1,
+                tool: toolResult.tool,
+                ok: toolResult.ok,
+                summary: toolResult.summary,
+                metadata: toolResult.metadata,
+                content: clipPromptValue(toolResult.content, toolResult.tool === "read_file" ? 12_000 : 6000)
+            }))
+        }, null, 2)
+    ].join("\n");
+}
+export function compactTranscript(messages, tokenBudget = 32_000) {
+    const toolResultIndexes = messages
+        .map((message, index) => ({ message, index }))
+        .filter((item) => item.message.role === "user" && item.message.content.includes("\"tool_results\""))
+        .map((item) => item.index);
+    if (toolResultIndexes.length <= 2 && estimateTokens(messages.map((message) => message.content).join("\n")) <= tokenBudget) {
+        return;
+    }
+    const fullResultIndexes = new Set(toolResultIndexes.slice(-2));
+    for (const index of toolResultIndexes) {
+        if (fullResultIndexes.has(index) || messages[index]?.content.startsWith("Compacted earlier tool results:")) {
+            continue;
+        }
+        messages[index] = {
+            role: "user",
+            content: `Compacted earlier tool results: ${summarizeToolResultsForCompaction(messages[index]?.content ?? "")}`
+        };
+    }
+}
+function summarizeToolResultsForCompaction(content) {
+    const jsonStart = content.indexOf("{");
+    if (jsonStart < 0) {
+        return clipPromptValue(content.replace(/\s+/g, " ").trim(), 240);
+    }
+    try {
+        const parsed = JSON.parse(content.slice(jsonStart));
+        const results = Array.isArray(parsed.tool_results) ? parsed.tool_results : [];
+        return results
+            .map((result, index) => {
+            const tool = typeof result.tool === "string" ? result.tool : `tool ${index + 1}`;
+            const status = result.ok === false ? "failed" : "ok";
+            const summary = typeof result.summary === "string" ? result.summary.replace(/\s+/g, " ").trim() : "";
+            return `${tool} ${status}${summary ? `: ${clipPromptValue(summary, 140)}` : ""}`;
+        })
+            .join("; ");
+    }
+    catch {
+        return clipPromptValue(content.replace(/\s+/g, " ").trim(), 240);
+    }
 }
 function workStateForTool(tool) {
     const category = getToolSpec(tool).category;
@@ -496,17 +1009,23 @@ function createToolCallId(tool) {
     return `${tool}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 async function buildWorkspaceSummary(workspaceRoot) {
-    const [patchPilotInstructions, packageJson, tsconfig, readme] = await Promise.all([
+    const [patchPilotInstructions, packageJson, tsconfig, readme, productContext, architecture, commands] = await Promise.all([
         readWorkspaceFile(workspaceRoot, "PATCHPILOT.md", 4000),
         readWorkspaceFile(workspaceRoot, "package.json", 4000),
         readWorkspaceFile(workspaceRoot, "tsconfig.json", 1600),
-        readWorkspaceFile(workspaceRoot, "README.md", 3000)
+        readWorkspaceFile(workspaceRoot, "README.md", 3000),
+        readWorkspaceFile(workspaceRoot, "docs/product-context.md", 4000),
+        readWorkspaceFile(workspaceRoot, "docs/architecture.md", 2200),
+        readWorkspaceFile(workspaceRoot, "src/tui/commands.ts", 2400)
     ]);
     return [
         patchPilotInstructions ? `PATCHPILOT.md instructions:\n${patchPilotInstructions}` : "",
+        productContext ? `PatchPilot product context:\n${productContext}` : "",
         packageJson ? `package.json:\n${packageJson}` : "",
         tsconfig ? `tsconfig.json:\n${tsconfig}` : "",
-        readme ? `README excerpt:\n${readme}` : ""
+        readme ? `README excerpt:\n${readme}` : "",
+        architecture ? `Architecture excerpt:\n${architecture}` : "",
+        commands ? `TUI command definitions excerpt:\n${commands}` : ""
     ]
         .filter(Boolean)
         .join("\n\n");
@@ -521,22 +1040,34 @@ async function readWorkspaceFile(workspaceRoot, relativePath, maxLength) {
     const content = await readFile(normalizedFile, "utf8").catch(() => "");
     return clipPromptValue(content.trim(), maxLength);
 }
-function resolveMaxSteps(task, configuredMaxSteps, thinkingMode) {
+function resolveMaxSteps(task, configuredMaxSteps, thinkingMode, ultramaxx = false) {
     if (thinkingMode !== "adaptive") {
-        return configuredMaxSteps;
+        return Math.max(2, configuredMaxSteps);
     }
     const words = task.trim().split(/\s+/).filter(Boolean).length;
     const looksComplex = shouldUseSubagents(task) || words > 18 || /\b(implement|refactor|debug|fix|review|architektur|performance|pipeline|context|memory|provider)\b/i.test(task);
+    if (ultramaxx) {
+        return Math.max(40, configuredMaxSteps);
+    }
     const adaptiveSteps = looksComplex ? Math.max(configuredMaxSteps, 12) : Math.min(configuredMaxSteps, 5);
     return Math.max(3, Math.min(20, adaptiveSteps));
 }
-function shouldExtendAdaptiveRun(task, toolResults, currentMaxSteps) {
-    if (currentMaxSteps >= 32) {
+function shouldExtendAdaptiveRun(task, toolResults, currentMaxSteps, ceiling = 32) {
+    if (currentMaxSteps >= ceiling) {
         return false;
     }
-    const hasUsefulProgress = toolResults.some((result) => result.ok);
+    const hasUsefulProgress = toolResults.some((result) => result.ok &&
+        (result.category === "write" ||
+            result.category === "test" ||
+            result.category === "shell" ||
+            result.tool === "git_diff" ||
+            (result.tool === "update_todo" && todoMetadataHasCompletedItem(result.metadata))));
     const hasRecoverableFailure = toolResults.some((result) => !result.ok && /not found|missing|requires|denied|failed|unreadable/i.test(result.summary));
-    return hasUsefulProgress || hasRecoverableFailure || shouldUseSubagents(task);
+    return hasUsefulProgress || hasRecoverableFailure || (shouldUseSubagents(task) && hasUsefulProgress);
+}
+function todoMetadataHasCompletedItem(metadata) {
+    const items = Array.isArray(metadata?.items) ? metadata.items : [];
+    return items.some((item) => isRecord(item) && item.status === "completed");
 }
 function resolveReasoningEffort(task, effort) {
     if (effort !== "adaptive") {
@@ -557,4 +1088,20 @@ function clipPromptValue(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}\n...[clipped ${value.length - maxLength} chars]`;
 }
+function isRetryableModelError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /\b(429|500|502|503|504|rate limit|timeout|timed out|socket|econnreset|network|temporar|could not be reached|cannot reach)\b/i.test(message);
+}
+function formatRetryableModelError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return clipPromptValue(message.replace(/\s+/g, " ").trim(), 120);
+}
+function modelRetryDelayMs(attempt) {
+    return Math.min(4000, 300 * 2 ** Math.max(0, attempt - 1) + Math.floor(Math.random() * 250));
+}
+function delay(durationMs) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, durationMs);
+    });
+}
 //# sourceMappingURL=agent.js.map