@chenmk/superflow 0.4.0 → 0.5.1

package/dist/platform/agent-process.js

@@ -2,30 +2,97 @@ import { existsSync, readFileSync, unlinkSync } from "fs";
 import path from "path";
 import spawn from "cross-spawn";
 import { managedText } from "../domains/managed-work/i18n.js";
+import { resolveExecutableShim } from "./executable.js";
+import { stopProcessTree } from "./process-tree.js";
+const HOST_SUPERVISION_INTERVAL_MS = 10 * 60_000;
+const CLAUDE_MANAGED_AUTO_COMPACT_WINDOW = "200000";
+const CLAUDE_MANAGED_AUTO_COMPACT_PERCENT = "70";
+/**
+ * GUI-launched MCP servers do not reliably inherit an interactive shell PATH.
+ * Supplement it only with standard executable locations, never a user's home
+ * directory or a tool-specific private shim.
+ */
+export function managedExecutablePath(basePath, platform = process.platform, directoryExists = existsSync) {
+    const delimiter = platform === "win32" ? ";" : ":";
+    const standardDirectories = platform === "darwin"
+        ? ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]
+        : platform === "win32"
+            ? []
+            : ["/usr/local/bin", "/usr/bin", "/bin"];
+    const existing = (basePath ?? "").split(delimiter).filter(Boolean);
+    const known = new Set(existing);
+    for (const directory of standardDirectories) {
+        if (directoryExists(directory) && !known.has(directory)) {
+            existing.push(directory);
+            known.add(directory);
+        }
+    }
+    return existing.join(delimiter);
+}
 export class LocalAgentInvoker {
     async invoke(invocation) {
         return runAgentProcess(invocation);
     }
 }
+export class AgentInvocationFailure extends Error {
+    stdout;
+    stderr;
+    sessionId;
+    usage;
+    telemetry;
+    constructor(message, stdout, stderr, sessionId, usage, telemetry) {
+        super(message);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.sessionId = sessionId;
+        this.usage = usage;
+        this.telemetry = telemetry;
+        this.name = "AgentInvocationFailure";
+    }
+}
+export function classifyUnresumableSessionFailure(input) {
+    const evidence = input.message.toLowerCase();
+    const resumeFailure = /\b(?:failed|failure|error|rejected|unable|cannot|can't)\b.{0,80}\b(?:resume|resuming)\b/.test(evidence) ||
+        /\b(?:resume|resuming)\b.{0,80}\b(?:failed|failure|error|rejected|unable|cannot|can't|history exceeds)\b/.test(evidence);
+    if (!resumeFailure)
+        return null;
+    if (/(?:(?:session|conversation)(?:\s+id)?\s+(?:not found|does not exist|expired)|unknown\s+(?:session|conversation))/.test(evidence)) {
+        return "session_not_found";
+    }
+    if (/(?:(?:invalid|malformed)\s+(?:session|conversation)(?:\s+id)?|(?:session|conversation)\s+id\s+is\s+invalid)/.test(evidence)) {
+        return "session_invalid";
+    }
+    if (/context window|context limit|too large|too long/.test(evidence)) {
+        return "resume_context_limit";
+    }
+    return null;
+}
 export function buildAgentCommand(invocation) {
     if (invocation.agent === "codex")
         return buildCodexCommand(invocation);
-    return buildClaudeCommand(invocation);
+    return invocation.agent === "claude"
+        ? buildClaudeCommand(invocation)
+        : buildCodexCommand(invocation);
+}
+export function wrapWithSleepPrevention(command, args, platform = process.platform, caffeinateAvailable = existsSync("/usr/bin/caffeinate")) {
+    if (platform !== "darwin" || !caffeinateAvailable)
+        return { command, args };
+    return {
+        command: "/usr/bin/caffeinate",
+        args: ["-im", command, ...args],
+    };
 }
 async function runAgentProcess(invocation) {
     const command = buildAgentCommand(invocation);
+    const environment = buildAgentEnvironment(invocation);
+    const executable = resolveExecutableShim(command.command, environment);
+    const processCommand = wrapWithSleepPrevention(executable, command.args);
     if (command.outputFile && existsSync(command.outputFile))
         unlinkSync(command.outputFile);
     return new Promise((resolve, reject) => {
-        const child = spawn(command.command, command.args, {
+        const child = spawn(processCommand.command, processCommand.args, {
             cwd: invocation.projectRoot,
-            env: {
-                ...process.env,
-                SUPERFLOW_MANAGED_TASK_ID: invocation.taskId,
-                SUPERFLOW_MANAGED_RUN_ID: invocation.runId,
-                SUPERFLOW_MANAGED_ROLE: invocation.role,
-                SUPERFLOW_MANAGED_PROJECT_ROOT: invocation.projectRoot,
-            },
+            env: environment,
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
             shell: false,
@@ -35,18 +102,53 @@ async function runAgentProcess(invocation) {
         let lineBuffer = "";
         let sessionId = invocation.sessionId;
         let lastOutputAt = Date.now();
+        let lastClockCheckAt = lastOutputAt;
+        let activeInvocationMs = 0;
         let finished = false;
+        let telemetry = initialTelemetry();
+        let usage = emptyUsage();
+        invocation.onTelemetry?.(telemetry);
+        invocation.onProcess?.(child.pid ?? null);
         const warningTimer = setTimeout(() => {
+            if (finished)
+                return;
+            accountClockGap();
             invocation.onProgress?.(managedText(invocation.language, "连续一段时间没有新进展，后台仍在观察进程", "No new progress for a while; the background service is still observing the process"));
         }, invocation.timeout.warningMs);
+        const heartbeatTimer = setInterval(() => {
+            if (finished)
+                return;
+            accountClockGap();
+            const elapsed = Date.now() - lastOutputAt;
+            invocation.onProgress?.(managedText(invocation.language, `Agent 心跳：阶段 ${telemetry.phase}，距最近输出 ${Math.round(elapsed / 1_000)} 秒，最近进展原因 ${telemetry.lastProgressReason}`, `Agent heartbeat: phase ${telemetry.phase}, ${Math.round(elapsed / 1_000)} seconds since output, last progress reason ${telemetry.lastProgressReason}`));
+        }, 60_000);
+        const supervisionTimer = setInterval(() => {
+            if (finished)
+                return;
+            accountClockGap();
+            invocation.onProgress?.(`superflow-supervision:${JSON.stringify({
+                phase: telemetry.phase,
+                lastProgressAt: telemetry.lastProgressAt,
+                lastProgressReason: telemetry.lastProgressReason,
+                secondsSinceOutput: Math.round((Date.now() - lastOutputAt) / 1_000),
+            })}`);
+        }, HOST_SUPERVISION_INTERVAL_MS);
         let stalledTimer = setTimeout(onStalled, invocation.timeout.stalledMs);
-        const hardTimer = setTimeout(() => {
+        const hardTimer = setInterval(() => {
+            if (finished)
+                return;
+            accountClockGap();
+            if (activeInvocationMs < invocation.timeout.hardMs)
+                return;
             stopChild(child.pid);
             finishError(new Error(managedText(invocation.language, `单次 Agent 调用超过 ${invocation.timeout.hardMs}ms`, `Single Agent invocation exceeded ${invocation.timeout.hardMs}ms`)));
-        }, invocation.timeout.hardMs);
+        }, 250);
         if (invocation.sessionId)
             invocation.onSession?.(invocation.sessionId);
         child.stdout?.on("data", (chunk) => {
+            if (finished)
+                return;
+            accountClockGap();
             const text = chunk.toString();
             stdout += text;
             lastOutputAt = Date.now();
@@ -57,6 +159,16 @@ async function runAgentProcess(invocation) {
             lineBuffer = lines.pop() ?? "";
             for (const line of lines) {
                 const event = safeJson(line);
+                if (event) {
+                    telemetry = updateTelemetry(telemetry, event);
+                    usage = updateAgentUsage(usage, event);
+                    invocation.onTelemetry?.(telemetry);
+                }
+                if (invocation.agent === "claude" && shouldStopClaudeRetry(event)) {
+                    stopChild(child.pid);
+                    finishError(new Error(managedText(invocation.language, "Claude 底层模型连续出现 3 次临时 429/529/overloaded，已熔断本次调用", "Claude's provider returned 3 consecutive transient 429/529/overloaded retries; this invocation was stopped")));
+                    return;
+                }
                 const discoveredSession = extractSessionId(event);
                 if (!sessionId && discoveredSession) {
                     sessionId = discoveredSession;
@@ -68,6 +180,9 @@ async function runAgentProcess(invocation) {
             }
         });
         child.stderr?.on("data", (chunk) => {
+            if (finished)
+                return;
+            accountClockGap();
             stderr += chunk.toString();
             lastOutputAt = Date.now();
         });
@@ -78,7 +193,7 @@ async function runAgentProcess(invocation) {
             cleanupTimers();
             finished = true;
             if ((code ?? 1) !== 0) {
-                reject(new Error(formatAgentFailure(invocation.agent, code, stdout, stderr, invocation.language)));
+                reject(new AgentInvocationFailure(formatAgentFailure(invocation.agent, code, stdout, stderr, invocation.language), stdout, stderr, sessionId, usage, telemetry));
                 return;
             }
             try {
@@ -94,14 +209,24 @@ async function runAgentProcess(invocation) {
                     stdout,
                     stderr,
                     exitCode: code ?? 0,
+                    usage,
+                    telemetry,
                 });
             }
             catch (error) {
-                reject(error);
+                reject(new AgentInvocationFailure(error.message, stdout, stderr, sessionId, usage, telemetry));
             }
         });
-        child.stdin?.end(invocation.prompt);
+        child.stdin?.end(agentProcessInput(invocation));
         function onStalled() {
+            if (finished)
+                return;
+            const slept = accountClockGap();
+            if (slept) {
+                clearTimeout(stalledTimer);
+                stalledTimer = setTimeout(onStalled, invocation.timeout.stalledMs);
+                return;
+            }
             if (Date.now() - lastOutputAt < invocation.timeout.stalledMs)
                 return;
             stopChild(child.pid);
@@ -112,15 +237,167 @@ async function runAgentProcess(invocation) {
                 return;
             finished = true;
             cleanupTimers();
-            reject(error);
+            reject(error instanceof AgentInvocationFailure
+                ? error
+                : new AgentInvocationFailure(error.message, stdout, stderr, sessionId, usage, telemetry));
         }
         function cleanupTimers() {
             clearTimeout(warningTimer);
             clearTimeout(stalledTimer);
-            clearTimeout(hardTimer);
+            clearInterval(hardTimer);
+            clearInterval(heartbeatTimer);
+            clearInterval(supervisionTimer);
+            invocation.onProcess?.(null);
+        }
+        function accountClockGap() {
+            const now = Date.now();
+            const delta = Math.max(0, now - lastClockCheckAt);
+            lastClockCheckAt = now;
+            const slept = delta > 5_000;
+            if (slept) {
+                lastOutputAt += delta;
+                return true;
+            }
+            activeInvocationMs += delta;
+            return false;
         }
     });
 }
+export function buildAgentEnvironment(invocation, baseEnv = process.env) {
+    return {
+        ...baseEnv,
+        PATH: managedExecutablePath(baseEnv.PATH),
+        SUPERFLOW_MANAGED_TASK_ID: invocation.taskId,
+        SUPERFLOW_MANAGED_RUN_ID: invocation.runId,
+        SUPERFLOW_MANAGED_ROLE: invocation.role,
+        SUPERFLOW_MANAGED_PROJECT_ROOT: invocation.projectRoot,
+        SUPERFLOW_MANAGED_CONTEXT_MANIFEST: path.join(invocation.projectRoot, ".superflow", "tasks", invocation.taskId, "context-manifest.json"),
+        ...(invocation.agent === "claude" && invocation.role === "executor"
+            ? {
+                CLAUDE_CODE_AUTO_COMPACT_WINDOW: baseEnv.CLAUDE_CODE_AUTO_COMPACT_WINDOW ??
+                    CLAUDE_MANAGED_AUTO_COMPACT_WINDOW,
+                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: baseEnv.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE ??
+                    CLAUDE_MANAGED_AUTO_COMPACT_PERCENT,
+            }
+            : {}),
+    };
+}
+export function initialTelemetry() {
+    const now = new Date().toISOString();
+    return {
+        phase: "model_waiting",
+        model: null,
+        tools: [],
+        toolUses: [],
+        plugins: [],
+        lastOutputAt: now,
+        lastProgressAt: now,
+        lastProgressReason: "invocation_started",
+        permissionDenials: 0,
+    };
+}
+function emptyUsage() {
+    return {
+        inputTokens: null,
+        outputTokens: null,
+        cacheReadTokens: null,
+        cacheWriteTokens: null,
+        costUsd: null,
+    };
+}
+export function updateTelemetry(current, event) {
+    const now = new Date().toISOString();
+    const next = { ...current, lastOutputAt: now };
+    if (Array.isArray(event.permission_denials)) {
+        next.permissionDenials = Math.max(next.permissionDenials ?? 0, event.permission_denials.length);
+    }
+    if (event.type === "system" && event.subtype === "init") {
+        next.model = stringValue(event.model) ?? next.model;
+        next.tools = stringArray(event.tools);
+        next.plugins = stringArray(event.plugins);
+        next.lastProgressAt = now;
+        next.lastProgressReason = "system_init";
+    }
+    const toolNames = extractToolNames(event);
+    if (event.type === "result") {
+        next.phase = "model_waiting";
+        next.lastProgressAt = now;
+        next.lastProgressReason = "agent_result";
+    }
+    else if (toolNames.length > 0) {
+        next.toolUses = [...new Set([...next.toolUses, ...toolNames])];
+        next.phase = toolNames.some((name) => /^(write|edit|apply_patch)$/i.test(name))
+            ? "workspace_writing"
+            : "tool_running";
+        next.lastProgressAt = now;
+        next.lastProgressReason = `tool_use:${toolNames.join(",")}`;
+    }
+    else if (/permission|approval/i.test(`${event.type} ${event.subtype}`)) {
+        next.phase = "awaiting_local_approval";
+        next.lastProgressReason = "local_approval";
+    }
+    else if (event.type === "assistant" || event.type === "message") {
+        next.phase = "model_waiting";
+        next.lastProgressAt = now;
+        next.lastProgressReason = "model_output";
+    }
+    return next;
+}
+function extractToolNames(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const object = value;
+    const names = [];
+    if ((object.type === "tool_use" || object.type === "tool_call") &&
+        typeof object.name === "string") {
+        names.push(object.name);
+    }
+    for (const child of Object.values(object)) {
+        if (Array.isArray(child)) {
+            for (const item of child)
+                names.push(...extractToolNames(item));
+        }
+        else if (child && typeof child === "object") {
+            names.push(...extractToolNames(child));
+        }
+    }
+    return names;
+}
+function extractUsage(event) {
+    const usage = event.usage && typeof event.usage === "object"
+        ? event.usage
+        : {};
+    return {
+        inputTokens: numberValue(usage.input_tokens ?? usage.inputTokens),
+        outputTokens: numberValue(usage.output_tokens ?? usage.outputTokens),
+        cacheReadTokens: numberValue(usage.cache_read_input_tokens ?? usage.cacheReadTokens),
+        cacheWriteTokens: numberValue(usage.cache_creation_input_tokens ?? usage.cacheWriteTokens),
+        costUsd: numberValue(event.total_cost_usd ?? event.cost_usd),
+    };
+}
+export function updateAgentUsage(current, event) {
+    return mergeUsage(current, extractUsage(event));
+}
+function mergeUsage(current, next) {
+    return {
+        inputTokens: next.inputTokens ?? current.inputTokens,
+        outputTokens: next.outputTokens ?? current.outputTokens,
+        cacheReadTokens: next.cacheReadTokens ?? current.cacheReadTokens,
+        cacheWriteTokens: next.cacheWriteTokens ?? current.cacheWriteTokens,
+        costUsd: next.costUsd ?? current.costUsd,
+    };
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 export function formatAgentFailure(agent, code, stdout, stderr, language) {
     const details = [stderr.trim(), extractFailureFromEvents(stdout)]
         .filter(Boolean)
@@ -135,11 +412,26 @@ function extractFailureFromEvents(stdout) {
         const event = safeJson(lines[index]);
         if (!event)
             continue;
-        for (const key of ["error", "message", "result", "reason"]) {
+        for (const key of [
+            "error",
+            "message",
+            "result",
+            "reason",
+            "terminal_reason",
+            "subtype",
+            "stop_reason",
+        ]) {
             const value = event[key];
             if (typeof value === "string" && value.trim())
                 messages.push(value.trim());
         }
+        if (Array.isArray(event.errors)) {
+            for (const value of event.errors) {
+                if (typeof value === "string" && value.trim()) {
+                    messages.push(value.trim());
+                }
+            }
+        }
     }
     return messages.join("\n");
 }
@@ -156,6 +448,7 @@ function buildCodexCommand(invocation) {
             args: [
                 "exec",
                 "resume",
+                ...(invocation.role === "executor" ? ["--disable", "memories"] : []),
                 invocation.sessionId,
                 "--json",
                 "--output-schema",
@@ -176,6 +469,7 @@ function buildCodexCommand(invocation) {
         command: "codex",
         args: [
             "exec",
+            ...(invocation.role === "executor" ? ["--disable", "memories"] : []),
             "-C",
             invocation.projectRoot,
             "--sandbox",
@@ -194,7 +488,7 @@ function buildCodexCommand(invocation) {
 }
 function buildClaudeCommand(invocation) {
     const schema = readFileSync(invocation.schemaPath, "utf-8");
-    const args = ["-p"];
+    const args = ["--bare", "-p"];
     let initialSessionId = invocation.sessionId;
     if (invocation.sessionId)
         args.push("--resume", invocation.sessionId);
@@ -202,11 +496,98 @@ function buildClaudeCommand(invocation) {
         initialSessionId = cryptoRandomUuid();
         args.push("--session-id", initialSessionId);
     }
-    args.push("--output-format", "stream-json", "--verbose", "--json-schema", schema, "--permission-mode", invocation.role === "supervisor" ? "plan" : "auto");
+    args.push(...(invocation.systemPromptPath
+        ? ["--append-system-prompt-file", invocation.systemPromptPath]
+        : []), "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--json-schema", schema, "--tools", claudeTools(invocation.role));
+    if (invocation.role === "executor") {
+        args.push("--dangerously-skip-permissions");
+    }
+    else {
+        args.push("--permission-mode", "dontAsk", "--allowedTools", ...claudeAllowedTools(invocation.role));
+    }
+    if (invocation.role === "supervisor") {
+        args.push("--max-turns", "20");
+    }
     for (const root of invocation.writableRoots)
         args.push("--add-dir", root);
     return { command: "claude", args, outputFile: null, initialSessionId };
 }
+export function agentProcessInput(invocation) {
+    if (invocation.agent === "codex")
+        return invocation.prompt;
+    if (invocation.agent === "claude" && invocation.promptPath) {
+        return `Read ${invocation.promptPath} completely and execute it.`;
+    }
+    return invocation.prompt;
+}
+function claudeTools(role) {
+    return role === "supervisor"
+        ? "Read,Grep,Glob,Bash"
+        : "Read,Write,Edit,Grep,Glob,Bash";
+}
+function claudeAllowedTools(role) {
+    const readOnly = [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash(git diff *)",
+        "Bash(git status *)",
+        "Bash(git log *)",
+        "Bash(git show *)",
+        "Bash(xmllint *)",
+    ];
+    if (role === "supervisor")
+        return readOnly;
+    return [
+        ...readOnly,
+        "Write",
+        "Edit",
+        "Bash(mvn *)",
+        "Bash(JAVA_HOME=* mvn *)",
+        "Bash(JAVA_HOME=* */mvn *)",
+        "Bash(java *)",
+        "Bash(JAVA_HOME=* java *)",
+        "Bash(/usr/libexec/java_home *)",
+        "Bash(command -v java*)",
+        "Bash(command -v mvn*)",
+        "Bash(which java*)",
+        "Bash(which mvn*)",
+        "Bash(npm *)",
+        "Bash(npx *)",
+        "Bash(pnpm *)",
+        "Bash(yarn *)",
+        "Bash(gradle *)",
+        "Bash(./gradlew *)",
+        "Bash(openspec *)",
+        "Bash(bash .claude/scripts/superflow-*.sh)",
+        "Bash(bash .claude/scripts/superflow-*.sh *)",
+        "Bash(python3 .claude/scripts/superflow-*.py)",
+        "Bash(python3 .claude/scripts/superflow-*.py *)",
+        "Bash(node .claude/scripts/superflow-*.mjs)",
+        "Bash(node .claude/scripts/superflow-*.mjs *)",
+        "Bash(PORT=* npm *)",
+        "Bash(node --version*)",
+        "Bash(npm --version*)",
+        "Bash(curl --version*)",
+        "Bash(which curl*)",
+        "Bash(command -v curl*)",
+        "Bash(curl http://localhost*)",
+        "Bash(curl http://127.0.0.1*)",
+        "Bash(lsof *)",
+        "Bash(ps *)",
+        "Bash(kill *)",
+    ];
+}
+export function shouldStopClaudeRetry(event) {
+    if (event?.type !== "system" ||
+        event.subtype !== "api_retry" ||
+        typeof event.attempt !== "number" ||
+        event.attempt < 3) {
+        return false;
+    }
+    const detail = `${String(event.error_status ?? "")} ${String(event.error ?? "")}`;
+    return /\b(?:429|529)\b|overloaded|rate.?limit|访问量过大|暂时.*限流/i.test(detail);
+}
 function extractStructuredOutput(agent, stdout, outputFile, language) {
     if (agent === "codex" && outputFile && existsSync(outputFile)) {
         return parseStructuredValue(readFileSync(outputFile, "utf-8"), language);
@@ -218,9 +599,40 @@ function extractStructuredOutput(agent, stdout, outputFile, language) {
             if (event[key] !== undefined)
                 return parseStructuredValue(event[key], language);
         }
+        const text = extractEventText(event);
+        if (text) {
+            try {
+                return parseStructuredValue(text, language);
+            }
+            catch {
+                // Continue to earlier events before falling back to the whole stream.
+            }
+        }
     }
     return parseStructuredValue(stdout, language);
 }
+function extractEventText(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const object = value;
+    if (typeof object.text === "string" && object.text.trim())
+        return object.text;
+    for (const child of Object.values(object)) {
+        if (Array.isArray(child)) {
+            for (let index = child.length - 1; index >= 0; index--) {
+                const text = extractEventText(child[index]);
+                if (text)
+                    return text;
+            }
+        }
+        else if (child && typeof child === "object") {
+            const text = extractEventText(child);
+            if (text)
+                return text;
+        }
+    }
+    return null;
+}
 function parseStructuredValue(value, language) {
     if (typeof value === "object" && value !== null)
         return value;
@@ -251,7 +663,13 @@ function extractSessionId(value) {
     if (!value || typeof value !== "object")
         return null;
     const object = value;
-    for (const key of ["session_id", "sessionId", "thread_id", "threadId"]) {
+    for (const key of [
+        "session_id",
+        "sessionId",
+        "sessionID",
+        "thread_id",
+        "threadId",
+    ]) {
         if (typeof object[key] === "string" && isUuid(object[key]))
             return object[key];
     }
@@ -262,17 +680,75 @@ function extractSessionId(value) {
     }
     return null;
 }
-function extractProgress(value) {
+export function extractProgress(value) {
     if (!value || typeof value !== "object")
         return null;
+    const stageHint = extractToolStageHint(value);
+    if (stageHint)
+        return `superflow-stage:${stageHint}`;
     const object = value;
     for (const key of ["message", "summary", "text"]) {
         if (typeof object[key] === "string" && object[key].length > 0) {
-            return object[key].slice(0, 240);
+            return object[key];
+        }
+    }
+    return null;
+}
+function extractToolStageHint(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const object = value;
+    const type = stringValue(object.type);
+    const name = stringValue(object.name);
+    if (["tool_use", "tool_call"].includes(type ?? "") &&
+        /^(?:write|edit|apply_patch)$/i.test(name ?? "")) {
+        return "implementation";
+    }
+    if (["tool_use", "tool_call"].includes(type ?? "") &&
+        /^(?:bash|shell|terminal)$/i.test(name ?? "")) {
+        const input = object.input;
+        const command = input && typeof input === "object"
+            ? stringValue(input.command)
+            : null;
+        if (command)
+            return stageFromCommand(command);
+    }
+    for (const child of Object.values(object)) {
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                const stage = extractToolStageHint(item);
+                if (stage)
+                    return stage;
+            }
+        }
+        else if (child && typeof child === "object") {
+            const stage = extractToolStageHint(child);
+            if (stage)
+                return stage;
         }
     }
     return null;
 }
+function stageFromCommand(command) {
+    const value = command.toLowerCase();
+    if (/preflight|diff --check/.test(value))
+        return "delivery_self_check";
+    if (/drop table|redis.*(?:del|exists)|kill|pkill|cleanup/.test(value)) {
+        return "cleanup";
+    }
+    if (/\bcurl\b|\bwget\b|http:\/\/|https:\/\//.test(value)) {
+        return "http_e2e";
+    }
+    if (/java -jar|spring-boot:run|bootrun|npm run (?:dev|start)/.test(value)) {
+        return "application_startup";
+    }
+    if (/mvn.*package|gradle.*build|npm.*build/.test(value))
+        return "package";
+    if (/mvn.*test|gradle.*test|vitest|jest|pytest/.test(value)) {
+        return "unit_test";
+    }
+    return null;
+}
 function safeJson(value) {
     try {
         return JSON.parse(value);
@@ -282,22 +758,7 @@ function safeJson(value) {
     }
 }
 function stopChild(pid) {
-    if (!pid)
-        return;
-    try {
-        if (process.platform === "win32")
-            process.kill(pid, "SIGTERM");
-        else
-            process.kill(-pid, "SIGTERM");
-    }
-    catch {
-        try {
-            process.kill(pid, "SIGTERM");
-        }
-        catch {
-            // Process already exited.
-        }
-    }
+    stopProcessTree(pid);
 }
 function isUuid(value) {
     return (typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(value));