@ashx-j/lunr 0.2.26 → 0.2.28

package/dist/builtin-extensions/pi-subagents/src/runs/foreground/execution.js

@@ -1,4 +1,5 @@
 // @ts-nocheck
+import { parseSessionRequests, parseSessionUsage, sessionUsageDelta } from "../../shared/session-tokens.js";
 /**
  * Core execution logic for running subagents
  */
@@ -17,7 +18,7 @@ import { normalizeSkillInput } from "../../agents/skills.js";
 import { evaluateCompletionMutationGuard } from "../shared/completion-guard.js";
 import { getPiSpawnCommand } from "../shared/pi-spawn.js";
 import { createJsonlWriter } from "../../shared/jsonl-writer.js";
-import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.js";
+import { attachPostExitStdioGuard } from "../../shared/post-exit-stdio-guard.js";
 import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.js";
 import { READ_ONLY_WRITE_SPAWN_ERROR, resolveChildPermissions, snapshotParentPermissionMode } from "../../../../../core/subagent-permission-inherit.js";
 import { readStructuredOutput } from "../shared/structured-output.js";
@@ -35,7 +36,7 @@ import { acceptChildWatchdogEvent, childWatchdogIsActive, isChildWatchdogStatusE
 const artifactOutputByResult = new WeakMap();
 const acceptanceOutputByResult = new WeakMap();
 function emptyUsage() {
-    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0, unknownRequests: 0, partialRequests: 0, unknownCosts: 0 };
 }
 function sumUsage(target, source) {
     target.input += source.input;
@@ -44,6 +45,9 @@ function sumUsage(target, source) {
     target.cacheWrite += source.cacheWrite;
     target.cost += source.cost;
     target.turns += source.turns;
+    target.unknownRequests += source.unknownRequests ?? 0;
+    target.partialRequests += source.partialRequests ?? 0;
+    target.unknownCosts += source.unknownCosts ?? 0;
 }
 function formatTimeoutMessage(timeoutMs) {
     return `Subagent timed out after ${timeoutMs}ms.`;
@@ -133,6 +137,7 @@ function snapshotResult(result, progress) {
     };
 }
 async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared) {
+    const usageBeforeAttempt = parseSessionUsage(options.sessionFile ?? options.sessionDir);
     const effectiveThinking = options.thinkingOverride;
     const modelArg = applyThinkingSuffix(model, effectiveThinking, options.thinkingOverride !== undefined);
     const watchdogConfig = resolveWatchdogConfig(options.cwd ?? runtimeCwd);
@@ -275,6 +280,8 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             windowsHide: true,
         });
         const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
+        let spawned = typeof proc.pid === "number" && proc.pid > 0;
+        proc.once("spawn", () => { spawned = true; });
         let processClosed = false;
         let settled = false;
         let detached = false;
@@ -290,6 +297,73 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         let turnBudgetTerminationTimer;
         let turnBudgetHardKillTimer;
         let protocolHardKillTimer;
+        let cancellationHardKillTimer;
+        let interruptTerminationTimer;
+        let terminationCheckTimer;
+        let terminationUnconfirmedReported = false;
+        const clearCancellationTimers = () => {
+            if (terminationCheckTimer)
+                clearTimeout(terminationCheckTimer);
+            terminationCheckTimer = undefined;
+            if (cancellationHardKillTimer)
+                clearTimeout(cancellationHardKillTimer);
+            if (interruptTerminationTimer)
+                clearTimeout(interruptTerminationTimer);
+            cancellationHardKillTimer = undefined;
+            interruptTerminationTimer = undefined;
+        };
+        const recordProcessError = (error) => {
+            if (!result.error)
+                result.error = error instanceof Error ? error.message : String(error);
+            progress.error = result.error;
+            if (!childExited && !processClosed && !settled && !detached) {
+                progress.status = "running";
+                fireUpdate();
+            }
+        };
+        // A delivered signal is not an exit acknowledgement. Keep this attempt owned
+        // until close, including when the OS refuses every termination signal.
+        const signalChild = (signal) => {
+            if (childExited || processClosed || settled || detached)
+                return false;
+            let sent = false;
+            try {
+                sent = proc.kill(signal);
+            }
+            catch (error) {
+                recordProcessError(error);
+            }
+            if (!sent && !childExited && !processClosed && !settled && !detached) {
+                recordProcessError(`Subagent ${signal} could not be delivered; child exit is not confirmed.`);
+            }
+            if (signal === "SIGKILL" && !childExited && !processClosed && !settled && !detached && !terminationCheckTimer && !terminationUnconfirmedReported) {
+                terminationCheckTimer = setTimeout(() => {
+                    terminationCheckTimer = undefined;
+                    if (childExited || processClosed || settled || detached)
+                        return;
+                    terminationUnconfirmedReported = true;
+                    const message = `Subagent termination unconfirmed after SIGKILL${proc.pid ? ` (diagnostic PID ${proc.pid})` : ""}. This foreground call still owns the child and waits for its exit. Verify the child process before starting replacement work.`;
+                    progress.status = "running";
+                    progress.error = message;
+                    progress.activityState = "needs_attention";
+                    progress.durationMs = Date.now() - startTime;
+                    appendRecentOutput(progress, [message]);
+                    emitUpdateSnapshot(message);
+                }, 2000);
+                terminationCheckTimer.unref?.();
+            }
+            return sent;
+        };
+        const scheduleCancellationHardKill = (delayMs) => {
+            if (cancellationHardKillTimer || childExited || processClosed || settled || detached)
+                return;
+            cancellationHardKillTimer = setTimeout(() => {
+                cancellationHardKillTimer = undefined;
+                if (!childExited && !processClosed && !settled && !detached)
+                    signalChild("SIGKILL");
+            }, delayMs);
+            cancellationHardKillTimer.unref?.();
+        };
         const clearTurnBudgetTimers = () => {
             if (turnBudgetTerminationTimer) {
                 clearTimeout(turnBudgetTerminationTimer);
@@ -371,17 +445,15 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             finalDrainTimer = setTimeout(() => {
                 if (settled || processClosed || detached)
                     return;
-                const termSent = trySignalChild(proc, "SIGTERM");
-                if (!termSent)
-                    return;
-                forcedTerminationSignal = true;
+                const termSent = signalChild("SIGTERM");
+                forcedTerminationSignal = termSent || forcedTerminationSignal;
                 if (!cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError) {
                     result.error = result.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`;
                 }
                 finalHardKillTimer = setTimeout(() => {
                     if (settled || processClosed || detached)
                         return;
-                    forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal;
+                    forcedTerminationSignal = signalChild("SIGKILL") || forcedTerminationSignal;
                 }, HARD_KILL_MS);
                 finalHardKillTimer.unref?.();
             }, FINAL_STOP_GRACE_MS);
@@ -441,6 +513,7 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             if (settled)
                 return;
             settled = true;
+            clearCancellationTimers();
             clearFinalDrainTimers();
             clearWatchdogTailTimer();
             clearStdioGuard();
@@ -538,17 +611,17 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             progress.error = message;
             progress.durationMs = Date.now() - startTime;
             fireUpdate();
-            trySignalChild(proc, "SIGINT");
+            signalChild("SIGINT");
             turnBudgetTerminationTimer = setTimeout(() => {
                 if (processClosed || settled || detached || result.timedOut)
                     return;
-                trySignalChild(proc, "SIGTERM");
+                signalChild("SIGTERM");
             }, 1000);
             turnBudgetTerminationTimer.unref?.();
             turnBudgetHardKillTimer = setTimeout(() => {
                 if (processClosed || settled || detached || result.timedOut)
                     return;
-                trySignalChild(proc, "SIGKILL");
+                signalChild("SIGKILL");
             }, 4000);
             turnBudgetHardKillTimer.unref?.();
         };
@@ -736,7 +809,10 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
                         result.usage.cacheRead += u.cacheRead || 0;
                         result.usage.cacheWrite += u.cacheWrite || 0;
                         result.usage.cost += u.cost?.total || 0;
-                        progress.tokens = result.usage.input + result.usage.output;
+                        result.usage.unknownRequests += Number(u.measurement === "unknown");
+                        result.usage.partialRequests += Number(u.measurement === "partial");
+                        result.usage.unknownCosts += Number(u.costSource === "unknown");
+                        progress.tokens = result.usage.input + result.usage.output + result.usage.cacheRead + result.usage.cacheWrite;
                     }
                     if (!result.model && evt.message.model) {
                         result.model = evt.message.model;
@@ -818,17 +894,17 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
                 progress.error = attemptTimeout.message;
                 progress.durationMs = Date.now() - startTime;
                 fireUpdate();
-                trySignalChild(proc, "SIGINT");
+                signalChild("SIGINT");
                 timeoutTerminationTimer = setTimeout(() => {
                     if (processClosed || settled || detached)
                         return;
-                    trySignalChild(proc, "SIGTERM");
+                    signalChild("SIGTERM");
                 }, 1000);
                 timeoutTerminationTimer.unref?.();
                 timeoutHardKillTimer = setTimeout(() => {
                     if (processClosed || settled || detached)
                         return;
-                    trySignalChild(proc, "SIGKILL");
+                    signalChild("SIGKILL");
                 }, 4000);
                 timeoutHardKillTimer.unref?.();
             }, attemptTimeout.remainingMs);
@@ -845,10 +921,10 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             progress.durationMs = Date.now() - startTime;
             fireUpdate();
             if (!childExited) {
-                trySignalChild(proc, "SIGTERM");
+                signalChild("SIGTERM");
                 protocolHardKillTimer = setTimeout(() => {
                     if (!childExited)
-                        trySignalChild(proc, "SIGKILL");
+                        signalChild("SIGKILL");
                 }, 3000);
                 protocolHardKillTimer.unref?.();
             }
@@ -866,11 +942,18 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             stderrTail.push(chunk);
             stderrReader.push(chunk);
         });
-        proc.on("exit", () => {
+        const confirmChildExit = () => {
             childExited = true;
+            if (terminationUnconfirmedReported) {
+                progress.error = result.error;
+                progress.activityState = undefined;
+            }
+            clearCancellationTimers();
             clearFinalDrainTimers();
-        });
+        };
+        proc.on("exit", confirmChildExit);
         proc.on("close", (code, signal) => {
+            confirmChildExit();
             clearFinalDrainTimers();
             clearStdioGuard();
             void jsonlWriter.close().catch(() => {
@@ -880,6 +963,12 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             cleanupTempDir(tempDir);
             stdoutReader.end();
             stderrReader.end();
+            const persistedUsage = parseSessionUsage(options.sessionFile ?? options.sessionDir ?? result.sessionFile);
+            if (persistedUsage) {
+                result.usageRequests = parseSessionRequests(options.sessionFile ?? options.sessionDir ?? result.sessionFile);
+                result.usage = options.sessionFile ? persistedUsage : sessionUsageDelta(persistedUsage, usageBeforeAttempt);
+                progress.tokens = result.usage.input + result.usage.output + result.usage.cacheRead + result.usage.cacheWrite;
+            }
             const stderr = stderrTail.text();
             let closeError = result.error ?? toolDiagnosticError ?? assistantError;
             const forcedDrainAfterFinalSuccess = forcedTerminationSignal && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
@@ -946,6 +1035,11 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
             finish(finalCode);
         });
         proc.on("error", (error) => {
+            // kill/send errors after spawn do not prove exit and must not discard escalation.
+            if (spawned) {
+                recordProcessError(error);
+                return;
+            }
             clearFinalDrainTimers();
             clearStdioGuard();
             void jsonlWriter.close().catch(() => {
@@ -961,10 +1055,10 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         });
         if (options.signal) {
             const kill = () => {
-                if (processClosed || detached)
+                if (childExited || processClosed || settled || detached)
                     return;
-                proc.kill("SIGTERM");
-                setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
+                signalChild("SIGTERM");
+                scheduleCancellationHardKill(3000);
             };
             if (options.signal.aborted)
                 kill();
@@ -987,12 +1081,14 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
                 result.finalOutput = "Interrupted. Waiting for explicit next action.";
                 progress.activityState = undefined;
                 fireUpdate();
-                trySignalChild(proc, "SIGINT");
-                setTimeout(() => {
-                    if (settled || processClosed || detached)
+                signalChild("SIGINT");
+                interruptTerminationTimer = setTimeout(() => {
+                    if (childExited || settled || processClosed || detached)
                         return;
-                    trySignalChild(proc, "SIGTERM");
-                }, 1000).unref?.();
+                    signalChild("SIGTERM");
+                }, 1000);
+                interruptTerminationTimer.unref?.();
+                scheduleCancellationHardKill(4000);
             };
             if (options.interruptSignal.aborted)
                 interrupt();
@@ -1315,11 +1411,13 @@ export async function runSync(runtimeCwd, spec, options) {
             },
         }
         : options;
+    const priorRequestIds = new Set(parseSessionRequests(options.sessionFile ?? options.sessionDir).map((request) => request.id));
     let lastResult;
     const modelsToTry = candidates.length > 0 ? candidates : [undefined];
     for (let i = 0; i < modelsToTry.length; i++) {
         const candidate = modelsToTry[i];
         const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
+        const usageBeforeAttempt = parseSessionUsage(options.sessionFile ?? options.sessionDir);
         const result = await runSingleAttempt(runtimeCwd, spec, taskWithAcceptance, candidate, detachedAwareOptions, {
             sessionEnabled,
             systemPrompt,
@@ -1332,6 +1430,9 @@ export async function runSync(runtimeCwd, spec, options) {
             outputSnapshot,
             originalTask: task,
         });
+        const persistedUsage = parseSessionUsage(options.sessionFile ?? options.sessionDir ?? result.sessionFile);
+        if (persistedUsage)
+            result.usage = sessionUsageDelta(persistedUsage, usageBeforeAttempt);
         lastResult = result;
         if (result.model)
             attemptedModels.push(result.model);
@@ -1371,12 +1472,17 @@ export async function runSync(runtimeCwd, spec, options) {
         usage: emptyUsage(),
         error: "Subagent did not produce a result.",
     };
-    result.usage = aggregateUsage;
+    const cumulativeResumeUsage = options.sessionFile ? parseSessionUsage(options.sessionFile) : null;
+    result.usage = cumulativeResumeUsage ?? aggregateUsage;
+    result.usageRequests = parseSessionRequests(options.sessionFile ?? options.sessionDir ?? result.sessionFile)
+        .filter((request) => Boolean(options.sessionFile) || !priorRequestIds.has(request.id));
+    if (result.usageRequests.length === 0)
+        result.usageRequests = undefined;
     result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
     result.modelAttempts = modelAttempts.length > 0 ? modelAttempts : undefined;
     result.progressSummary = {
         toolCount: totalToolCount,
-        tokens: aggregateUsage.input + aggregateUsage.output,
+        tokens: result.usage.input + result.usage.output + result.usage.cacheRead + result.usage.cacheWrite,
         durationMs: totalDurationMs,
     };
     if (attemptNotes.length > 0 && result.progress) {