cli-jaw 2.17.30 → 2.17.35

package/dist/src/agent/spawn.js

@@ -18,7 +18,7 @@ import { settleOnce } from '../orchestrator/request-registry.js';
 import { settings, UPLOADS_DIR, detectCli, getProjectDirs } from '../core/config.js';
 import { migrateLegacyClaudeValue } from '../cli/claude-models.js';
 import { stripUndefined } from '../core/strip-undefined.js';
-import { clearEmployeeSession, getSession, insertMessage, insertMessageWithTraceRun, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, migrateQueuedMessagesV1ToV2, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, } from '../core/db.js';
+import { clearEmployeeSession, getSession, insertMessage, insertMessageWithTraceRun, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, migrateQueuedMessagesV1ToV2, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, getMaxMessageId, getSteerSalvageAfter, } from '../core/db.js';
 import { sanitizeToolLogForDurableStorage } from '../shared/tool-log-sanitize.js';
 import { buildTaskSnapshot } from '../memory/runtime.js';
 import { getActiveChatSession, getRemoteBoundSessionId } from '../core/chat-sessions.js';
@@ -42,7 +42,7 @@ import { stripInterviewTracker } from '../orchestrator/sanitize.js';
 import { beginLiveRun, appendLiveRunText, setLiveRunTraceId, clearLiveRun, replaceLiveRunTools, appendLiveRunTool, getLiveRun } from './live-run-state.js';
 import { setSpawnRef as setMemorySpawnRef, } from './memory-flush-controller.js';
 import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPermissions, mergeEnvWindowsSafe } from './spawn-env.js';
-import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt } from './prompt-context.js';
+import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt, withSteerContext } from './prompt-context.js';
 import { attachWatchdog, DEFAULT_WATCHDOG_ABSOLUTE_HARD_CAP_MS } from './watchdog.js';
 import { buildOpencodeRuntimeSnapshot, buildOpencodeSpawnAudit, pushOpencodeRawEvent, resolveOpencodeBinary, } from './opencode-diagnostics.js';
 import { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
@@ -352,6 +352,48 @@ function consumeKillReason(pid) {
         killReasons.delete(pid);
     return reason;
 }
+// ─── Steer exit-settle barrier ─────────────────────
+// killActiveAgent removes the scope's activeMainProcesses entry synchronously,
+// so waitForProcessEnd() resolves immediately on a steer kill — long before the
+// exit handler has written the interrupted partial output to the messages table.
+// A follow-up spawn could then read history without the salvage row. The barrier
+// is armed at kill time (never at exit-handler entry — that is already too late)
+// and settled by the exit handler's completion, success or failure.
+const exitSettlers = new Map();
+/** Arm the barrier. Idempotent: a repeated steer keeps the first arm. */
+export function armExitSettle(scopeKey) {
+    if (exitSettlers.has(scopeKey))
+        return;
+    let resolve;
+    const promise = new Promise(r => { resolve = r; });
+    exitSettlers.set(scopeKey, { promise, resolve });
+}
+/** Settle the barrier; a no-op when no steer kill armed it. */
+export function settleExit(scopeKey) {
+    const entry = exitSettlers.get(scopeKey);
+    if (!entry)
+        return;
+    exitSettlers.delete(scopeKey);
+    entry.resolve();
+}
+/**
+ * Await the armed exit handler's completion, bounded. A timeout releases the
+ * waiter and drops the arm — a wedged exit handler must not hang the steer.
+ */
+export function waitForExitSettled(scopeKey, timeoutMs = 5000) {
+    const entry = exitSettlers.get(scopeKey);
+    if (!entry)
+        return Promise.resolve();
+    // The timer is NOT unref'd and is always cleared: an unref'd timer can vanish
+    // with a drained event loop (test runner), leaving the waiter pending forever.
+    let timer;
+    const timeout = new Promise(r => { timer = setTimeout(r, timeoutMs); });
+    return Promise.race([entry.promise, timeout]).then(() => {
+        clearTimeout(timer);
+        if (exitSettlers.get(scopeKey) === entry)
+            exitSettlers.delete(scopeKey);
+    });
+}
 /**
  * Fix A: 사용자 stop은 메모리 큐 + DB persisted_queue + frontend pending row를
  * 모두 폐기한다. exit handler의 scoped queue 자동 드레인이 stop 직후 잔존
@@ -417,6 +459,8 @@ export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
         if (run.process?.pid)
             killReasons.set(run.process.pid, reason);
         console.log(`[jaw:kill] reason=${reason} scope=${scopeKey} cli=${getActiveMainCli(scopeKey)} action=lease.cancel`);
+        if (reason === 'steer' || reason === 'interrupt')
+            armExitSettle(scopeKey);
         run.cancelTurn(reason);
         if (reason === 'api' || reason === 'user' || reason === 'steer' || reason === 'interrupt')
             activeMainProcesses.delete(scopeKey);
@@ -432,6 +476,8 @@ 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);
+    if (reason === 'steer' || reason === 'interrupt')
+        armExitSettle(scopeKey);
     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
@@ -537,7 +583,10 @@ export function waitForAllProcessesEnd(timeoutMs = 2000) {
 }
 export function canSteerAgent(scopeKey) {
     const run = activeMainProcesses.get(scopeKey);
-    return run?.meta.cli === 'jwc' && jawRuntimesByScope.get(scopeKey)?.busy === true;
+    if (run?.meta.cli === 'jwc' && jawRuntimesByScope.get(scopeKey)?.busy === true)
+        return true;
+    // codex-app: the hook exists exactly while a steerable turn is in flight.
+    return typeof run?.steerTurnInBand === 'function';
 }
 export async function steerAgent(scopeKey, newPrompt, source, meta) {
     const run = activeMainProcesses.get(scopeKey);
@@ -552,27 +601,72 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
         // event will ever carry this id. Settling here is what stops a caller
         // from waiting for an answer that structurally cannot arrive.
         settleOnce(meta?.requestId, 'steered');
-        return;
+        return 'steered';
+    }
+    if (typeof run?.steerTurnInBand === 'function') {
+        // codex-app same-turn steer. The user row is written only AFTER the
+        // server accepts — a fallback must not leave a duplicate insert for the
+        // queued path to write again.
+        let outcome;
+        try {
+            outcome = await run.steerTurnInBand(newPrompt);
+        }
+        catch (err) {
+            console.error('[jaw:steer] codex-app in-band steer failed:', err.message);
+            return 'fallback-queue';
+        }
+        if (outcome !== 'steered') {
+            if (outcome === 'rejected') {
+                // review/compact turns structurally reject steer — tell the user
+                // their message was queued instead, not silently swallowed.
+                broadcast('steer_rejected', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, reason: 'turn-not-steerable', requestId: meta?.requestId }));
+            }
+            return 'fallback-queue';
+        }
+        insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, chatSessionId);
+        broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
+        broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId, remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget }));
+        settleOnce(meta?.requestId, 'steered');
+        return 'steered';
     }
     const steerWaitMs = getSteerWaitMsForActiveAgent(scopeKey);
+    // Snapshot BEFORE the kill: the interrupted partial-output row is identified
+    // as the first ⏹️-tagged assistant message with id above this mark. A
+    // created_at comparison is not safe (second-resolution UTC column).
+    const maxIdBeforeKill = getMaxMessageId(chatSessionId);
     const wasRunning = killActiveAgent(scopeKey, 'steer');
     if (wasRunning)
         await waitForProcessEnd(scopeKey, steerWaitMs);
+    // The kill removes the scope's map entry synchronously, so the wait above can
+    // return before the exit handler's salvage insert. Wait for the settle barrier
+    // armed by the kill so the follow-up run actually sees the partial output.
+    if (wasRunning)
+        await waitForExitSettled(scopeKey);
+    let steerContext = null;
+    if (wasRunning) {
+        const salvage = getSteerSalvageAfter(chatSessionId, maxIdBeforeKill);
+        // The ⏹️ tag is a human-facing marker; the model gets the payload only.
+        steerContext = salvage ? salvage.replace(/^⏹️ \[interrupted\]\s*/, '') : null;
+    }
     insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, chatSessionId);
     broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
     broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, requestId: meta?.requestId }));
     const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
     const origin = source || 'web';
+    const steerMeta = stripUndefined({ origin, scope: scopeKey, chatSessionId, requestId: meta?.requestId, _skipInsert: true, _steerContext: steerContext || undefined });
     const task = isResetIntent(newPrompt)
-        ? orchestrateReset(stripUndefined({ origin, scope: scopeKey, chatSessionId, requestId: meta?.requestId, _skipInsert: true }))
+        ? orchestrateReset(steerMeta)
         : isContinueIntent(newPrompt)
-            ? orchestrateContinue(stripUndefined({ origin, scope: scopeKey, chatSessionId, requestId: meta?.requestId, _skipInsert: true }))
-            : orchestrate(newPrompt, stripUndefined({ origin, scope: scopeKey, chatSessionId, requestId: meta?.requestId, _skipInsert: true }));
+            ? orchestrateContinue(steerMeta)
+            : orchestrate(newPrompt, steerMeta);
     task.catch(async (err) => {
         console.error('[steer:orchestrate]', err.message);
         broadcast('orchestrate_done', stripUndefined({ text: `[error] ${err.message}`, error: true, origin, requestId: meta?.requestId }));
         settleOnce(meta?.requestId, 'failed', { error: err.message });
     });
+    // The follow-up was started as a new run (kill-path or idle race). The caller
+    // must NOT also queue the message.
+    return 'new-run';
 }
 // ─── Helpers ─────────────────────────────────────────
 export function makeCleanEnv(extraEnv = {}, inheritedEnv = process.env, platform = process.platform) {
@@ -712,7 +806,7 @@ export const saveUpload = (buffer, originalName, options) => _saveUpload(UPLOADS
 export { buildMediaPrompt, buildMediaPromptMany };
 // ─── Spawn Agent ─────────────────────────────────────
 import { AcpClient } from '../cli/acp-client.js';
-import { CodexAppClient, isRecoverableResumeError } from './codex-app-client.js';
+import { CodexAppClient, CodexSteerError, isRecoverableResumeError } from './codex-app-client.js';
 import { acquireCodexAppRuntime, acquirePiRuntime, } from './runtime-pool.js';
 import { acquireCodexAppLane, CodexHostGenerationStaleError, prepareCodexAppHost, } from './codex-host-pool.js';
 import { loadCatalogEfforts, resolveCatalogPath, validateModelEffort } from './codex-app-catalog.js';
@@ -1104,6 +1198,7 @@ export function spawnAgent(prompt, opts = {}) {
         sysPrompt,
         isResume,
     });
+    promptForArgs = withSteerContext(promptForArgs, opts.steerContext);
     const agyResumeReplayPrefix = cli === 'agy' && isResume
         ? getLatestAssistantContentForAgyResume(settings["workingDir"], chatSessionId)
         : null;
@@ -1498,7 +1593,8 @@ export function spawnAgent(prompt, opts = {}) {
                 const acpPrompt = needsHistoryFallback
                     ? withHistoryPrompt(prompt, fallbackHistory)
                     : (isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
-                const { promise: promptPromise } = acp.prompt(acpPrompt);
+                const acpPromptWithSteer = withSteerContext(acpPrompt, opts.steerContext);
+                const { promise: promptPromise } = acp.prompt(acpPromptWithSteer);
                 const promptResult = await promptPromise;
                 promptCompleted = true;
                 if (process.env["DEBUG"])
@@ -1575,7 +1671,7 @@ export function spawnAgent(prompt, opts = {}) {
                 processQueue,
             }).catch((err) => {
                 console.error('[jaw:lifecycle] handleAgentExit failed (ACP):', err.message);
-            });
+            }).finally(() => settleExit(scopeKey));
         });
         return { child, promise: resultPromise };
     }
@@ -1589,7 +1685,7 @@ export function spawnAgent(prompt, opts = {}) {
         }
         const piSessionId = isResume && bucketSessionId ? bucketSessionId : '';
         console.log(`[jaw:pi] isResume=${isResume}, bucketSessionId=${bucketSessionId || 'none'}, piSessionId=${piSessionId || 'new'}`);
-        const piPrompt = piSessionId ? prompt : withHistoryPrompt(prompt, historyBlock);
+        const piPrompt = withSteerContext(piSessionId ? prompt : withHistoryPrompt(prompt, historyBlock), opts.steerContext);
         const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
         const ctx = {
             fullText: '',
@@ -1772,7 +1868,7 @@ export function spawnAgent(prompt, opts = {}) {
                     fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
                     fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                     processQueue,
-                });
+                }).finally(() => settleExit(scopeKey));
             }).catch(async (err) => {
                 piWatchdog.stop();
                 await releaseLease().catch(() => { });
@@ -1798,7 +1894,7 @@ export function spawnAgent(prompt, opts = {}) {
                     processQueue,
                 }).catch((handleErr) => {
                     console.error('[jaw:lifecycle] handleAgentExit failed (Pi):', handleErr.message);
-                });
+                }).finally(() => settleExit(scopeKey));
             });
         };
         if (opts.agentId) {
@@ -2026,6 +2122,25 @@ export function spawnAgent(prompt, opts = {}) {
             const cancelHook = (_reason) => { void requestLeaseCancel(); };
             if (lease && mainRun)
                 mainRun.cancelTurn = cancelHook;
+            // Same-turn steer (turn/steer) for the duration of THIS turn only:
+            // installed and torn down with cancelHook so capability reads never
+            // outlive the steerable window.
+            const steerHook = async (text) => {
+                try {
+                    await appClient.steerTurn(laneScope, text, { clientUserMessageId: crypto.randomUUID() });
+                    return 'steered';
+                }
+                catch (err) {
+                    if (err instanceof CodexSteerError) {
+                        // review/compact turns reject steer; a mismatched/finished
+                        // turn raced us. Both are queue-fallback territory.
+                        return err.code === 'not-steerable' ? 'rejected' : 'unavailable';
+                    }
+                    throw err;
+                }
+            };
+            if (mainRun)
+                mainRun.steerTurnInBand = steerHook;
             const watchdogTimeout = (kind) => {
                 if (watchdogCancel)
                     return;
@@ -2109,7 +2224,8 @@ export function spawnAgent(prompt, opts = {}) {
                 const codexAppPrompt = (shouldPrependHistory && historyBlock)
                     ? `${historyBlock}\n\n[User Message]\n${prompt}`
                     : prompt;
-                const startTurn = appClient.startTurn(laneScope, codexAppPrompt);
+                const codexAppPromptWithSteer = withSteerContext(codexAppPrompt, opts.steerContext);
+                const startTurn = appClient.startTurn(laneScope, codexAppPromptWithSteer);
                 await Promise.race([startTurn, turnDone]);
                 await turnDone;
                 turnCompleted = !turnReportedFailure;
@@ -2151,6 +2267,8 @@ export function spawnAgent(prompt, opts = {}) {
                     await watchdogCancel;
                 if (mainRun?.cancelTurn === cancelHook)
                     delete mainRun.cancelTurn;
+                if (mainRun?.steerTurnInBand === steerHook)
+                    delete mainRun.steerTurnInBand;
                 listener.dispose();
                 if (lease)
                     lease.release();
@@ -2195,7 +2313,7 @@ export function spawnAgent(prompt, opts = {}) {
                 processQueue,
             }).catch((err) => {
                 console.error('[jaw:lifecycle] handleAgentExit failed (codex-app):', err.message);
-            });
+            }).finally(() => settleExit(scopeKey));
         };
         if (opts.agentId) {
             const employeeLaneScope = `employee:${opts.agentId}`;
@@ -2498,21 +2616,21 @@ export function spawnAgent(prompt, opts = {}) {
         insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
     }
     if (cli === 'claude') {
-        child.stdin.write(isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
+        child.stdin.write(withSteerContext(isResume ? prompt : withHistoryPrompt(prompt, historyBlock), opts.steerContext));
     }
     else if (cli === 'claude-e' || (cli === 'ai-e' && effectiveProvider === 'claude')) {
-        child.stdin.write(isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
+        child.stdin.write(withSteerContext(isResume ? prompt : withHistoryPrompt(prompt, historyBlock), opts.steerContext));
     }
     else if (cli === 'codex' && !isResume) {
         const codexStdin = historyBlock
             ? `${historyBlock}\n\n[User Message]\n${prompt}`
             : `[User Message]\n${prompt}`;
-        child.stdin.write(codexStdin);
+        child.stdin.write(withSteerContext(codexStdin, opts.steerContext));
     }
     else if (cli === 'codex' && isResume) {
         // Resume passes '-' in argv (see args.ts) so the prompt travels on stdin,
         // matching the fresh path.
-        child.stdin.write(prompt || '');
+        child.stdin.write(withSteerContext(prompt || '', opts.steerContext));
     }
     child.stdin.end();
     if (!opts.internal)
@@ -3127,7 +3245,7 @@ export function spawnAgent(prompt, opts = {}) {
             ...(agyTotalOutputLen > 0 ? { outputLen: agyTotalOutputLen } : {}),
         }).catch((err) => {
             console.error('[jaw:lifecycle] handleAgentExit failed (CLI):', err.message);
-        });
+        }).finally(() => settleExit(scopeKey));
     });
     return { child, promise: resultPromise };
 }