@pentoshi/clai 3.8.46 → 3.8.47

package/dist/agent/runner.js

@@ -6,11 +6,34 @@ import { syntheticToolCallId, isTextOnlyModel, fromWireName, } from "../llm/tool
 import { sanitizeAssistantText } from "../ui/ansi-box.js";
 import { randomUUID } from "node:crypto";
 import { jobManager } from "../tools/jobs.js";
+import { responderContextMessage, upsertResponderContextMessage, } from "./responder-context.js";
 import { agentModeDirective, planModeDirective, renderAgentSystemPrompt, renderCompactAgentSystemPrompt, scratchDirFor, toolNudge, } from "../prompts/index.js";
 import { getConfig } from "../store/config.js";
 import { beginSessionWorkspace, getActiveSessionWorkspace, } from "../store/session-workspace.js";
 import { groqInputTokenBudget } from "../llm/groq.js";
 import { classifyToolCall, isPentestToolCall, scopeHint, scopeTargetForToolCall, } from "../safety/classifier.js";
+/**
+ * Scope/engagement classification runs on every tool call and parses
+ * model-supplied arguments (URLs, hosts, commands). A malformed argument must
+ * never throw out of classification and abort the whole turn — degrade to
+ * "no target / no action" so the normal permission path still applies.
+ */
+function safeScopeTargetForToolCall(call) {
+    try {
+        return scopeTargetForToolCall(call);
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeEngagementActionForToolCall(call) {
+    try {
+        return engagementActionForToolCall(call);
+    }
+    catch {
+        return undefined;
+    }
+}
 import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, } from "../tools/registry.js";
 import { getToolDefinitions, getCompactToolDefinitions, PLAN_TOOL_NAMES, } from "../tools/definitions.js";
 import { appendAssistantWithTools, ensureUniqueToolCallIds, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
@@ -32,7 +55,7 @@ import { isScratchOnlyWrite } from "./scratch-write.js";
 import { COMPACTION_SYSTEM_PROMPT, } from "./compaction-summary.js";
 import { maybeAppendPlanModeReminder, PLAN_REMINDER_TOAST, } from "./plan-mode-reminders.js";
 import { LoopGuard } from "./loop-guard.js";
-import { loadPlan, savePlan, markTask, readyPlanTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
+import { loadPlan, savePlan, markTask, appendPlanTask, readyPlanTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
 import { fsWrite, isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools/fs.js";
 import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, looksLikePlanNarration, looksLikeErrorDiagnosisWithFixIntent, localHttpProbeIsFailure, localHttpProbeIsSuccess, requiresFreshWebSearch, freshnessGuardMessage, buildWorkflowDirective, narrowNmapOperationDirective, pentestWorkflowDirective, pentestNoLocalServerDirective, shouldDimToolChatter, looksLikePromptLeak, } from "./tool-call-parser.js";
 import { createSessionPolicy, isPreApprovalAllowedTool, isPlanModeAllowedShellCommand, isPlanModeAllowedTool, isPlanApprovedByStatus, planHasOpenWork, isAbortError, shouldEnableImageOcr, } from "./session-policy.js";
@@ -574,6 +597,20 @@ export async function runAgentTurn(prompt, options = {}) {
             userMessage,
         ];
         liveMessages = messages;
+        const responderWakeTurn = prompt.startsWith("Responder completion ready (");
+        const refreshResponderInbox = () => {
+            const pending = responderWakeTurn
+                ? jobManager
+                    .getPendingNotifications(session.sessionId)
+                    .filter((notification) => notification.responder && Boolean(notification.deliveredAt))
+                : [];
+            upsertResponderContextMessage(messages, responderContextMessage({
+                running: jobManager
+                    .getRunningJobs(session.sessionId)
+                    .filter((job) => job.responder),
+                pending,
+            }));
+        };
         /** Assigned after session flags exist — see below. */
         let refreshSessionState = () => undefined;
         /** Model-only nudge — never shown as a YOU bubble / WARN in the chat UI. */
@@ -698,7 +735,7 @@ export async function runAgentTurn(prompt, options = {}) {
         };
         const reconcileOpenTaskBeforeFinalizing = async () => {
             const plan = await loadPlan(session.sessionId).catch(() => undefined);
-            const open = plan?.tasks.find((task) => task.state === "in_progress");
+            const open = plan?.tasks.find((task) => task.state === "in_progress" && !task.responderOwned);
             if (!plan || !open)
                 return plan;
             const gate = completionGateForTask(plan, open.id);
@@ -756,9 +793,9 @@ export async function runAgentTurn(prompt, options = {}) {
             const root = getActiveProjectRoot() ?? p?.meta?.projectRoot;
             const pm = p?.meta?.packageManager ??
                 (root ? detectPackageManager(root) : undefined);
-            const open = p?.tasks.find((t) => t.state === "in_progress");
+            const open = p?.tasks.find((task) => task.state === "in_progress" && !task.responderOwned);
             const pending = p?.tasks
-                .filter((t) => t.state === "pending")
+                .filter((task) => task.state === "pending" && !task.responderOwned)
                 .map((t) => `[${t.id}] ${t.title}`);
             const done = p?.tasks
                 .filter((t) => t.state === "done" || t.state === "skipped")
@@ -967,7 +1004,9 @@ export async function runAgentTurn(prompt, options = {}) {
                     contextOutput: reason,
                 };
             }
-            if (call.name === "plan.create" || call.name === "task.update") {
+            if (call.name === "plan.create" ||
+                call.name === "task.add" ||
+                call.name === "task.update") {
                 // Evidence gate: refuse done until at least one successful work tool
                 // ran under this task (model must see results and be satisfied).
                 if (call.name === "task.update") {
@@ -1177,8 +1216,9 @@ export async function runAgentTurn(prompt, options = {}) {
             if (session.planApproved.value) {
                 const livePlanForGate = await loadPlan(session.sessionId).catch(() => undefined);
                 if (livePlanForGate) {
-                    const unfinished = livePlanForGate.tasks.some((t) => t.state === "pending" || t.state === "in_progress");
-                    const inProgress = livePlanForGate.tasks.find((t) => t.state === "in_progress");
+                    const unfinished = livePlanForGate.tasks.some((task) => !task.responderOwned &&
+                        (task.state === "pending" || task.state === "in_progress"));
+                    const inProgress = livePlanForGate.tasks.find((task) => task.state === "in_progress" && !task.responderOwned);
                     if (unfinished && !inProgress) {
                         // tool.check / fs.list preflight: allow without auto-opening a task
                         // (auto-start on preflight made models skip task.update and confused scope).
@@ -1256,9 +1296,9 @@ export async function runAgentTurn(prompt, options = {}) {
                 writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
                 alreadyPrintedIds.add(toolEventId);
             }
-            const scopeTarget = scopeTargetForToolCall(call);
+            const scopeTarget = safeScopeTargetForToolCall(call);
             const engagementAction = pentestSession || isPentestToolCall(call) || Boolean(scope)
-                ? engagementActionForToolCall(call)
+                ? safeEngagementActionForToolCall(call)
                 : undefined;
             const engagementDecision = engagementAction
                 ? evaluateEngagementAction(scope, engagementAction)
@@ -1391,7 +1431,7 @@ export async function runAgentTurn(prompt, options = {}) {
             }
             parentSignal.throwIfAborted();
             const planAtDispatch = await loadPlan(session.sessionId).catch(() => undefined);
-            dispatchedTaskId = planAtDispatch?.tasks.find((task) => task.state === "in_progress")?.id;
+            dispatchedTaskId = planAtDispatch?.tasks.find((task) => task.state === "in_progress" && !task.responderOwned)?.id;
             if (!dispatchedTaskId && planAtDispatch?.kind === "pentest") {
                 const candidate = pickPendingTaskForToolCall(readyPlanTasks(planAtDispatch), call, planAtDispatch.tasks.map((task) => task.title));
                 dispatchedTaskId = candidate?.id;
@@ -1506,6 +1546,12 @@ export async function runAgentTurn(prompt, options = {}) {
                     confirmed: true,
                     userPrompt: prompt,
                     sessionId: session.sessionId,
+                    ...(dispatchedTaskId ? { taskId: dispatchedTaskId } : {}),
+                    wakeOnCompletion: true,
+                    monitor: {
+                        toolName: call.name,
+                        toolEventId,
+                    },
                     ...(engagementAction && scope
                         ? {
                             engagementAuthorization: {
@@ -1739,6 +1785,102 @@ export async function runAgentTurn(prompt, options = {}) {
                     writeNotice("info", `project root → ${fromScaffold}`, chalk.dim(`  ℹ project root set to ${fromScaffold}\n`));
                 }
             }
+            if (result.backgroundJob) {
+                const durableJob = jobManager.getJob(result.backgroundJob.id);
+                // Responder linkage is opt-in: only jobs launched with responder:true
+                // become fire-and-forget plan subtasks that auto-wake on completion.
+                // Plain background jobs stay pollable (shell.jobs/shell.tail) as before.
+                if (durableJob?.responder) {
+                    const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
+                    let linkedTaskId = dispatchedTaskId;
+                    let linkedParentTaskId;
+                    let responderTaskId;
+                    if (durableJob && livePlan) {
+                        const existing = livePlan.tasks.find((task) => task.jobId === durableJob.id);
+                        const parentTaskId = dispatchedTaskId && livePlan.tasks.some((task) => task.id === dispatchedTaskId)
+                            ? dispatchedTaskId
+                            : undefined;
+                        const terminalState = durableJob.status === "exited"
+                            ? "done"
+                            : durableJob.status === "failed" ||
+                                durableJob.status === "killed" ||
+                                durableJob.status === "lost"
+                                ? "failed"
+                                : "in_progress";
+                        const note = `job=${durableJob.id} pid=${durableJob.pid ?? "?"} status=${durableJob.status} ` +
+                            `artifact=${durableJob.stdoutArtifact}`;
+                        const responderTask = existing ?? appendPlanTask(livePlan, {
+                            title: `Responder · ${durableJob.name ?? durableJob.commandDisplay.slice(0, 96)}`,
+                            state: terminalState,
+                            note,
+                            dependencies: [],
+                            resourceLocks: [],
+                            parentTaskId,
+                            jobId: durableJob.id,
+                            processId: durableJob.pid,
+                            responderOwned: true,
+                        });
+                        responderTask.state = terminalState;
+                        responderTask.note = note;
+                        responderTask.jobId = durableJob.id;
+                        responderTask.processId = durableJob.pid;
+                        responderTask.responderOwned = true;
+                        if (parentTaskId)
+                            responderTask.parentTaskId = parentTaskId;
+                        if (isPlanTerminal(livePlan)) {
+                            livePlan.status = isPlanSuccessful(livePlan)
+                                ? "completed"
+                                : "abandoned";
+                        }
+                        else if (livePlan.status !== "draft") {
+                            livePlan.status = "in_progress";
+                        }
+                        let responderPlanSaved = false;
+                        try {
+                            await savePlan(livePlan);
+                            responderPlanSaved = true;
+                        }
+                        catch {
+                            writeNotice("warn", `Responder job ${durableJob.id} started, but its plan subtask could not be persisted`, chalk.yellow(`  ⚠ job ${durableJob.id} is running, but task linkage persistence failed\n`));
+                        }
+                        if (responderPlanSaved) {
+                            linkedTaskId = responderTask.id;
+                            linkedParentTaskId = parentTaskId;
+                            responderTaskId = responderTask.id;
+                            pendingSessionStatePlan = livePlan;
+                            writePlanUpdate(livePlan, renderPlanForTerminal(livePlan) + "\n");
+                        }
+                    }
+                    if (durableJob) {
+                        const linkedJob = jobManager.linkJob(durableJob.id, {
+                            ...(linkedTaskId ? { taskId: linkedTaskId } : {}),
+                            ...(linkedParentTaskId
+                                ? { parentTaskId: linkedParentTaskId }
+                                : {}),
+                            wakeOnCompletion: true,
+                            responder: true,
+                            monitor: {
+                                ...(durableJob.monitor ?? {}),
+                                toolName: call.name,
+                                toolEventId,
+                            },
+                        });
+                        if (!linkedJob) {
+                            writeNotice("warn", `Responder job ${durableJob.id} started, but durable task linkage will be retried on completion`, chalk.yellow(`  ⚠ job ${durableJob.id} is running, but durable task linkage needs recovery\n`));
+                        }
+                        else if (responderTaskId) {
+                            result = {
+                                ...result,
+                                output: `${result.output}\nResponder linked job ${durableJob.id} to subtask [${responderTaskId}]` +
+                                    `${linkedParentTaskId ? ` under [${linkedParentTaskId}]` : ""}. ` +
+                                    "This child subtask advances on its own from the real process result — do not mark, poll, or wait on it. " +
+                                    "Mark your current launch step done and move to the next task now; do NOT shell.tail/shell.jobs/sleep to watch it. " +
+                                    "The Responder delivers the completion into your context automatically when it is ready.",
+                            };
+                        }
+                    }
+                }
+            }
             const output = result.output.trim();
             // Always keep a full on-disk copy of tool output (any size) so the
             // pager never depends on a truncated in-memory preview.
@@ -2052,7 +2194,7 @@ export async function runAgentTurn(prompt, options = {}) {
         };
         async function maybeAutoCompact(reason, force = false) {
             const beforeTokens = estimateNextRequestTokens(messages);
-            // E1: auto-compact trigger (default 100k, matches hard ceiling).
+            // E1: auto-compact trigger (default 72k soft; hard ceiling 100k).
             const compactTrigger = autoCompactTriggerTokens();
             if (!force && beforeTokens < compactTrigger)
                 return;
@@ -2191,6 +2333,11 @@ export async function runAgentTurn(prompt, options = {}) {
             }
             else {
                 await maybeAutoCompact("auto-token-budget");
+                // Safe boundary: no assistant tool-call group is open here. Refresh the
+                // durable Responder inbox immediately before every provider request so
+                // completions arriving mid-turn are visible without corrupting native
+                // tool protocol or forcing a separate busy-wait loop.
+                refreshResponderInbox();
                 const streamLabel = step === 0 ? "waiting for model" : `step ${step + 1}`;
                 let spinner = writesDirectly
                     ? startThinkingSpinner(streamLabel, options.signal)
@@ -3034,7 +3181,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     if (session.planApproved.value &&
                         budgetRemaining(recovery, "prematureComplete")) {
                         const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
-                        const unfinished = livePlan?.tasks.filter((t) => t.state === "pending" || t.state === "in_progress");
+                        const unfinished = livePlan?.tasks.filter((task) => !task.responderOwned &&
+                            (task.state === "pending" || task.state === "in_progress"));
                         if (livePlan && unfinished && unfinished.length > 0) {
                             const next = unfinished[0];
                             const action = recoveryForPrematureComplete({