cli-jaw 2.2.18 → 2.2.20

package/dist/src/agent/spawn.js

@@ -20,6 +20,7 @@ import { buildTaskSnapshot } from '../memory/runtime.js';
 import { getActiveChatSession } from '../core/chat-sessions.js';
 import { currentSessionScope } from '../core/session-context.js';
 import { getSystemPrompt, regenerateB } from '../prompt/builder.js';
+import { prependRemoteConversationContext } from '../prompt/conversation-context.js';
 import { extractSessionId, extractFromEvent, extractFromAcpUpdate, extractOutputChunk, logEventSummary, flushClaudeBuffers, flushOpenCodeBuffers } from './events.js';
 import { detectSmokeResponse } from './smoke-detector.js';
 import { saveUpload as _saveUpload, buildMediaPrompt, buildMediaPromptMany } from '../../lib/upload.js';
@@ -31,6 +32,7 @@ import { hasBlockingWorkers, hasPendingWorkerReplays, getActiveWorkers, clearAll
 import { sanitizeWorkerProgressTools } from '../orchestrator/worker-progress.js';
 import { handleAgentExit, setSpawnAgent, setMainMetaHandler } from './lifecycle-handler.js';
 import { buildServicePath } from '../core/runtime-path.js';
+import { formatCliUnavailableMessage } from '../core/cli-detect.js';
 import { LOCAL_SESSION_SCOPE_ACTIVATION, resolveOrcScope } from '../orchestrator/scope.js';
 import { stripInterviewTracker } from '../orchestrator/sanitize.js';
 import { beginLiveRun, appendLiveRunText, setLiveRunTraceId, clearLiveRun, replaceLiveRunTools, appendLiveRunTool, getLiveRun } from './live-run-state.js';
@@ -60,6 +62,10 @@ const DUP_REGISTRATION_KILL_REASON = 'dup-registration';
 /** Grace before escalating that kill to SIGKILL, matching the sibling kill paths. */
 const DUP_REGISTRATION_KILL_GRACE_MS = 2_000;
 function registerActiveProcess(agentLabel, child) {
+    // Defensive: the concrete spawn site should already own this child, and
+    // ownProcess is memoized, so this returns that existing owner rather than
+    // installing a second escalation timer.
+    ownProcess(child);
     const prev = activeProcesses.get(agentLabel);
     if (prev && prev !== child) {
         // `killed` only records that a signal was delivered, so it is not a
@@ -80,22 +86,12 @@ function registerActiveProcess(agentLabel, child) {
                 // Record a kill reason so the stale exit handler classifies this
                 // as an intentional kill rather than a genuine agent error.
                 killReasons.set(prevPid, DUP_REGISTRATION_KILL_REASON);
-                try {
-                    killProcessTree(prevPid, 'SIGTERM');
-                }
-                catch (error) {
-                    console.warn(`[spawn:dup] failed to kill previous child for ${agentLabel}:`, error?.message ?? error);
-                }
-                // Escalate like every sibling kill path does: a CLI that traps
-                // SIGTERM would otherwise survive with no map entry to find it.
-                // Route through killProcessTreeIfAlive so a child that exited
-                // during the grace period cannot have its recycled PID killed:
-                // killProcessTree walks `pgrep -P`, so a blind escalation would
-                // take an unrelated process tree down with it.
-                const escalate = setTimeout(() => {
-                    killProcessTreeIfAlive(prev, prevPid);
-                }, DUP_REGISTRATION_KILL_GRACE_MS);
-                escalate.unref?.();
+                // The owner performs the SIGTERM tree walk, schedules the same
+                // grace, and re-checks the original child before escalating —
+                // so a PID recycled during the grace is never signalled.
+                ownProcess(prev, {
+                    policy: () => ({ initialSignal: 'SIGTERM', graceMs: DUP_REGISTRATION_KILL_GRACE_MS }),
+                }).terminate('duplicate-registration');
             }
         }
     }
@@ -155,7 +151,7 @@ export function buildAiERuntimeStatusMeta(cli, provider, model) {
         },
     };
 }
-import { hasChildExited, killProcessTree, killProcessTreeIfAlive } from './spawn/process-kill.js';
+import { hasChildExited, killProcessTree, killProcessTreeIfAlive, ownProcess } from './spawn/process-kill.js';
 import { releaseChildOutputAfterExit } from './spawn/exit-drain.js';
 import { clampPendingLine } from './spawn/line-buffer.js';
 import { appendBoundedFullText } from './events/fulltext-bound.js';
@@ -426,37 +422,26 @@ export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
     console.log(`[jaw:kill] reason=${reason} scope=${scopeKey} cli=${getActiveMainCli(scopeKey) || 'unknown'} signal=${policy.signal} escalationMs=${policy.escalationMs}`);
     if (activeProcess.pid)
         killReasons.set(activeProcess.pid, reason);
-    try {
-        if (activeProcess.pid) {
-            killProcessTree(activeProcess.pid, policy.signal);
-        }
-        else {
-            activeProcess.kill(policy.signal);
-        }
-    }
-    catch (e) {
-        console.warn(`[agent:kill] ${policy.signal} failed`, { pid: activeProcess?.pid, error: e.message });
-    }
     const proc = activeProcess;
+    // One owner runs the whole termination: tree walk with the policy signal,
+    // then escalation after policy.escalationMs that re-checks the ORIGINAL
+    // child. The previous escalation guarded on `!proc.killed`, which only
+    // records that a signal was delivered — a CLI that traps SIGTERM stays
+    // alive with killed set, and was therefore never escalated.
+    ownProcess(proc, {
+        policy: () => ({ initialSignal: policy.signal, graceMs: policy.escalationMs }),
+    }).terminate(reason === 'steer' ? 'steer' : 'cancel');
     // Immediately sever stdio to stop late output from reaching broadcast handlers
     proc.stdout?.removeAllListeners('data');
     proc.stderr?.removeAllListeners('data');
-    setTimeout(() => {
-        try {
-            if (proc && !proc.killed) {
-                if (proc.pid)
-                    killProcessTree(proc.pid, 'SIGKILL');
-                else
-                    proc.kill('SIGKILL');
-            }
-        }
-        catch (e) {
-            console.warn('[agent:kill] SIGKILL failed', { pid: proc?.pid, error: e.message });
-        }
+    // Stdio teardown stays on its own timer: it must happen even when the
+    // owner short-circuits because the child had already exited.
+    const teardown = setTimeout(() => {
         proc.stdin?.destroy();
         proc.stdout?.destroy();
         proc.stderr?.destroy();
     }, policy.escalationMs);
+    teardown.unref?.();
     // Fix C1: 사용자 stop/steer 시 해당 scope busy가 즉시 false가 되도록 참조를 동기 해제.
     // 실제 child 종료는 위 setTimeout SIGKILL이 백그라운드에서 마무리.
     // exit handler의 setActiveProcess(null) / activeProcesses.delete 는 idempotent.
@@ -479,35 +464,19 @@ export function killAllAgents(reason = 'user') {
         console.log(`[jaw:killAll] killing ${id}, reason=${reason}`);
         if (proc.pid)
             killReasons.set(proc.pid, reason);
-        try {
-            if (proc.pid) {
-                killProcessTree(proc.pid, 'SIGTERM');
-            }
-            else {
-                proc.kill('SIGTERM');
-            }
-            killed++;
-        }
-        catch (e) {
-            console.warn(`[agent:killAll] SIGTERM failed for ${id}`, e.message);
-        }
+        // Same owner contract as killActiveAgent: tree walk now, escalation
+        // after the grace, guarded by real exit state rather than `killed`.
+        ownProcess(proc, {
+            policy: () => ({ initialSignal: 'SIGTERM', graceMs: 2000 }),
+        }).terminate('shutdown');
+        killed++;
         const ref = proc;
-        setTimeout(() => {
-            try {
-                if (ref && !ref.killed) {
-                    if (ref.pid) {
-                        killProcessTree(ref.pid, 'SIGKILL');
-                    }
-                    else {
-                        ref.kill('SIGKILL');
-                    }
-                }
-            }
-            catch { /* already dead */ }
+        const teardown = setTimeout(() => {
             ref.stdin?.destroy();
             ref.stdout?.destroy();
             ref.stderr?.destroy();
         }, 2000);
+        teardown.unref?.();
     }
     if (reason === 'api' || reason === 'user') {
         activeProcesses.clear();
@@ -588,18 +557,6 @@ function makeCleanEnv(extraEnv = {}) {
         PATH: buildServicePath(extraEnv["PATH"] || env["PATH"] || ''),
     };
 }
-function formatCliUnavailableMessage(cli, detected) {
-    const rejected = detected.rejected || [];
-    if (rejected.length > 0) {
-        const details = rejected
-            .slice(0, 3)
-            .map((entry) => `${entry.path} (${entry.reason})`)
-            .join('; ');
-        const suffix = rejected.length > 3 ? `; +${rejected.length - 3} more` : '';
-        return `CLI '${cli}' found on PATH but no spawnable executable was available. Rejected: ${details}${suffix}. Run \`jaw doctor --json\`.`;
-    }
-    return `CLI '${cli}' not found in PATH. Run \`jaw doctor --json\`.`;
-}
 function buildHistoryBlock(currentPrompt, workingDir, chatSessionId, maxSessions = 10, maxTotalChars = 8000) {
     const recent = getRecentMessages.all(workingDir || null, chatSessionId, Math.max(1, maxSessions * 2));
     if (!recent.length)
@@ -1058,7 +1015,8 @@ export function spawnAgent(prompt, opts = {}) {
         const memoryNudge = (!opts._isSmokeContinuation && !opts._isGoalContinuation)
             ? '\n(need history? L1: cli-jaw chat/memory search/context | L2: cli-jaw dashboard memory search, cli-jaw dashboard chat search)'
             : '';
-        prompt = `${ts}\n${projLine}${prompt}${memoryNudge}`;
+        const promptWithConversation = prependRemoteConversationContext(prompt, opts.target);
+        prompt = `${ts}\n${projLine}${promptWithConversation}${memoryNudge}`;
     }
     const resumeSessionId = empSid || (isResume ? bucketSessionId : null);
     const needsHistory = shouldBuildHistoryBlock({