cli-jaw 2.2.16 → 2.2.17

package/dist/src/agent/spawn.js

@@ -10,10 +10,11 @@ import { publish as ssePublish } from '../core/event-bus.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, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, } from '../core/db.js';
+import { clearEmployeeSession, getSession, insertMessage, insertMessageWithTraceRun, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, migrateQueuedMessagesV1ToV2, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, } from '../core/db.js';
 import { sanitizeToolLogForDurableStorage } from '../shared/tool-log-sanitize.js';
 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 { extractSessionId, extractFromEvent, extractFromAcpUpdate, extractOutputChunk, logEventSummary, flushClaudeBuffers, flushOpenCodeBuffers } from './events.js';
 import { detectSmokeResponse } from './smoke-detector.js';
@@ -22,35 +23,33 @@ import { resolveMainCli, consumePendingBootstrapPrompt, peekPendingBootstrapProm
 import { getSessionOwnershipGeneration, persistMainSession, } from './session-persistence.js';
 import { isCompactMarkerRow } from '../core/compact.js';
 import { isRuntimeSettingsMutationInFlight, waitForRuntimeSettingsIdle } from '../core/runtime-settings-gate.js';
-import { hasBlockingWorkers, hasPendingWorkerReplays, getActiveWorkers, clearAllWorkers } from '../orchestrator/worker-registry.js';
+import { hasBlockingWorkers, hasPendingWorkerReplays, getActiveWorkers, clearAllWorkers, clearWorkersForScope } from '../orchestrator/worker-registry.js';
 import { sanitizeWorkerProgressTools } from '../orchestrator/worker-progress.js';
 import { handleAgentExit, setSpawnAgent, setMainMetaHandler } from './lifecycle-handler.js';
 import { buildServicePath } from '../core/runtime-path.js';
-import { resolveOrcScope } from '../orchestrator/scope.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';
 import { setSpawnRef as setMemorySpawnRef, } from './memory-flush-controller.js';
 import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPermissions } from './spawn-env.js';
-import { buildPromptForArgs, withHistoryPrompt } from './prompt-context.js';
+import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt } 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';
 import { isJawRuntimeEvent, handleJawRuntimeEvent } from './claude-e-runtime.js';
-import { jawRuntime } from './jwc-runtime.js';
+import { jawRuntimesByScope, runtimeForScope } from './jwc-runtime.js';
 import { applyOutputPolicy, runBeforeSpawnChecks } from '../core/policy-hooks.js';
-import { appendTraceEvent, stampTraceTool, startTraceRun } from '../trace/store.js';
+import { appendTraceEvent, finalizeTraceRun, stampTraceTool, startTraceRun } from '../trace/store.js';
 import { AGY_COMPLETE_KILL_REASON, appendAgyFullText, classifyAgyTranscriptMode, describeAgyFinalSource, extractAgyConversationId, finalizeAgyFallbackText, AGY_PLANNER_ONLY_NOTICE, isAgyIntermediatePlannerText, formatAgyWatchdogContext, resolveAgyEmptyCloseError, formatAgyTimeoutMessage, getAgyQuietCompletionDelayMs, isAgyStaleSessionOutput, normalizeAgyCloseText, shouldFreezeAgyLiveDisplay, stripAgyPromptEchoPrefix, stripAgyResumeReplayPrefix, stripAgyResumeReplayPrefixes, } from './agy-runtime.js';
 import { detectAgyCapabilities } from './agy-capabilities.js';
 import { buildAgyBootstrapEnvelope, resolveAgyPromptOrder, } from './agy-bootstrap.js';
 import { startAgyTranscriptWatcher } from './agy-transcript-watcher.js';
-import { appendAssistantTextSegment, emitAgentTool, normalizeAssistantDisplayText, pushTrace } from './events/helpers.js';
-import { listKiroConversationIdsForCwd } from './kiro-auth.js';
-import { captureKiroSessionIdAfterExit, finalizeKiroFullText, flushKiroStdoutContext, isKiroPlainTextCli, isKiroStaleSessionOutput, parseAiESessionIdFromStderr, processKiroStdoutChunk, } from './kiro-runtime.js';
+import { appendAssistantRawText, appendAssistantTextSegment, emitAgentTool, normalizeAssistantDisplayText, pushTrace } from './events/helpers.js';
+import { captureKiroSessionIdAfterExit, finalizeKiroFullText, flushKiroStdoutContext, isKiroPlainTextCli, isKiroStaleSessionOutput, parseAiESessionIdFromStderr, processKiroStdoutChunk, spawnWithKiroSnapshot, } from './kiro-runtime.js';
 import { resolveCursorModelVariant } from './cursor-runtime.js';
 import { normalizePiSettings, spawnPiRpc } from './pi-runtime.js';
 import { getEmployeeMcpServers } from './mcp-passthrough.js';
 // ─── State ───────────────────────────────────────────
-export let activeProcess = null;
 export const activeProcesses = new Map(); // agentId → child process
 /** Kill reason recorded when a duplicate registration reaps the previous child. */
 const DUP_REGISTRATION_KILL_REASON = 'dup-registration';
@@ -98,12 +97,40 @@ function registerActiveProcess(agentLabel, child) {
     }
     activeProcesses.set(agentLabel, child);
 }
-let currentMainMeta = null;
-export function getCurrentMainMeta() {
-    return currentMainMeta;
+export const activeMainProcesses = new Map();
+export function getCurrentMainMeta(scopeKey) {
+    const scope = scopeKey ?? currentSessionScope()?.scope ?? 'default';
+    return activeMainProcesses.get(scope)?.meta ?? null;
 }
-export function setCurrentMainMeta(meta) {
-    currentMainMeta = meta;
+export function setCurrentMainMeta(scopeKeyOrMeta, nextMeta) {
+    const scopeKey = typeof scopeKeyOrMeta === 'string'
+        ? scopeKeyOrMeta
+        : currentSessionScope()?.scope ?? 'default';
+    const meta = typeof scopeKeyOrMeta === 'string' ? nextMeta ?? null : scopeKeyOrMeta;
+    const run = activeMainProcesses.get(scopeKey);
+    if (!meta) {
+        activeMainProcesses.delete(scopeKey);
+        return;
+    }
+    if (run) {
+        run.meta = meta;
+    }
+    else {
+        activeMainProcesses.set(scopeKey, {
+            process: null,
+            starting: false,
+            steering: false,
+            ownerGeneration: 0,
+            meta,
+        });
+    }
+}
+export function releaseMainRun(scopeKey, child, ownerGeneration) {
+    const run = activeMainProcesses.get(scopeKey);
+    if (!run || run.process !== child || run.ownerGeneration !== ownerGeneration)
+        return false;
+    activeMainProcesses.delete(scopeKey);
+    return true;
 }
 export function buildAiERuntimeStatusMeta(cli, provider, model) {
     if (cli !== 'ai-e')
@@ -230,7 +257,7 @@ export function killAgentById(agentId) {
 }
 export { memoryFlushCounter, flushCycleCount } from './memory-flush-controller.js';
 const queueCtrl = createQueueController({
-    isSpawnBusy: () => Boolean(activeProcess) || mainSpawnStarting || steerInProgress || queueCtrl.isRetryPending(),
+    isSpawnBusy: (scopeKey) => isAgentBusy(scopeKey),
     hasBlockingWorkers,
     hasPendingWorkerReplays,
     insertMessage,
@@ -238,30 +265,41 @@ const queueCtrl = createQueueController({
     insertQueuedMessage,
     deleteQueuedMessage,
     listQueuedMessages: listQueuedMessages,
+    migrateQueuedMessagesV1ToV2,
     broadcast,
     importPipeline: () => import('../orchestrator/pipeline.js'),
     getWorkingDir: () => settings["workingDir"] || null,
+    isMultiSessionEnabled: () => settings["multiSession"]?.enabled === true,
+    isLocalSessionScopeEnabled: () => LOCAL_SESSION_SCOPE_ACTIVATION,
 });
-export const { messageQueue, enqueueMessage, removeQueuedMessage, processQueue, setQueueHold, clearQueueHold, getQueueHoldId, clearRetryTimer, resetFallbackState, getFallbackState, getQueuedMessageSnapshotForScope, } = queueCtrl;
-let mainSpawnStarting = false;
-let cancelPendingMainSpawn = null;
-let steerInProgress = false;
-let cancelActiveCodexAppTurn = null;
-let cancelActivePiTurn = null;
+export const { messageQueue, enqueueMessage, removeQueuedMessage, processQueue, setQueueHold, clearQueueHold, getQueueHoldId, isScopedQueue, isRetryPending, isQueueBusy, clearRetryTimer, 
+// Exposed so DELETE's 409 paths can be driven end-to-end against the
+// production controller instead of an isolated instance.
+retryStateForScope, resetFallbackState, getFallbackState, getQueuedMessageSnapshotForScope, purgeQueueOnStop, } = queueCtrl;
 const piProfileFingerprintKey = crypto.randomBytes(32);
-export function setSteerInProgress(v) {
-    const was = steerInProgress;
-    steerInProgress = v;
-    if (was && !v)
-        queueMicrotask(() => processQueue());
+export function setSteerInProgress(scopeKeyOrValue, nextValue) {
+    const scopeKey = typeof scopeKeyOrValue === 'string' ? scopeKeyOrValue : 'default';
+    const value = typeof scopeKeyOrValue === 'boolean' ? scopeKeyOrValue : nextValue === true;
+    const run = activeMainProcesses.get(scopeKey);
+    if (!run)
+        return;
+    const was = run.steering;
+    run.steering = value;
+    if (was && !value)
+        queueMicrotask(() => { void processQueue(scopeKey); });
 }
-export function isSteerInProgress() {
-    return steerInProgress;
+export function isSteerInProgress(scopeKey = 'default') {
+    return activeMainProcesses.get(scopeKey)?.steering === true;
 }
-export function isAgentBusy() {
-    // jwc in-process turns hold no ChildProcess, so activeProcess stays null —
-    // fold the resident runtime's own busy flag in (110.3 §D).
-    return !!activeProcess || jawRuntime.busy || queueCtrl.isRetryPending() || mainSpawnStarting || steerInProgress;
+export function isAgentBusy(scopeKey = 'default') {
+    if (scopeKey === null) {
+        return activeMainProcesses.size > 0
+            || [...jawRuntimesByScope.values()].some(runtime => runtime.busy)
+            || queueCtrl.isRetryPending(null);
+    }
+    return activeMainProcesses.has(scopeKey)
+        || runtimeForScope(scopeKey).busy
+        || queueCtrl.isRetryPending(scopeKey);
 }
 // ─── Kill / Steer ────────────────────────────────────
 // [I2] Per-process kill reason map (replaces global variable to avoid cross-process confusion)
@@ -272,25 +310,28 @@ const CLAUDE_E_STEER_WAIT_MS = 30_000;
 const CLAUDE_E_STEER_KILL_ESCALATION_MS = 8_000;
 const DEFAULT_CODEX_APP_TURN_IDLE_MS = 300_000;
 const DEFAULT_CODEX_APP_TURN_ABS_MS = 2 * 60 * 60_000;
+const DEFAULT_CODEX_APP_ACQUIRE_WAIT_MS = 60_000;
+const CODEX_APP_ACQUIRE_RETRY_BACKOFF_MAX_MS = 250;
 function configuredPositiveMs(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
-function getActiveMainCli() {
-    return typeof currentMainMeta?.cli === 'string' ? currentMainMeta.cli : null;
+function getActiveMainCli(scopeKey) {
+    const cli = activeMainProcesses.get(scopeKey)?.meta.cli;
+    return typeof cli === 'string' ? cli : null;
 }
-function isActiveAiEPtyRuntime() {
-    const cli = getActiveMainCli();
+function isActiveAiEPtyRuntime(scopeKey) {
+    const cli = getActiveMainCli(scopeKey);
     return cli === 'claude-e' || cli === 'ai-e';
 }
-function getKillPolicy(reason) {
-    if (reason === 'steer' && isActiveAiEPtyRuntime()) {
+function getKillPolicy(scopeKey, reason) {
+    if (reason === 'steer' && isActiveAiEPtyRuntime(scopeKey)) {
         return { signal: 'SIGINT', escalationMs: CLAUDE_E_STEER_KILL_ESCALATION_MS };
     }
     return { signal: 'SIGTERM', escalationMs: DEFAULT_KILL_ESCALATION_MS };
 }
-export function getSteerWaitMsForActiveAgent() {
-    return isActiveAiEPtyRuntime() ? CLAUDE_E_STEER_WAIT_MS : DEFAULT_STEER_WAIT_MS;
+export function getSteerWaitMsForActiveAgent(scopeKey = 'default') {
+    return isActiveAiEPtyRuntime(scopeKey) ? CLAUDE_E_STEER_WAIT_MS : DEFAULT_STEER_WAIT_MS;
 }
 /** Get kill reason for a process (by PID), consuming it */
 function consumeKillReason(pid) {
@@ -303,81 +344,78 @@ function consumeKillReason(pid) {
 }
 /**
  * Fix A: 사용자 stop은 메모리 큐 + DB persisted_queue + frontend pending row를
- * 모두 폐기한다. exit handler의 processQueue() 자동 드레인이 stop 직후 잔존
+ * 모두 폐기한다. exit handler의 scoped queue 자동 드레인이 stop 직후 잔존
  * 메시지를 "스스로 steer" 처럼 실행하던 회귀를 차단.
  */
 /**
  * Fix C2: 사용자 stop 시 worker-registry 도 비운다.
- * gateway.submitMessage가 isAgentBusy() 외에 hasBlockingWorkers()/hasPendingWorkerReplays()
+ * gateway.submitMessage가 scoped main/worker/replay 상태를 모두 검사하므로,
  * 도 검사하므로, 이걸 비우지 않으면 stop 직후 새 메시지가 busy 분기 → 큐로 떨어지고
  * 프론트는 (1) 낙관 bubble + (2) applyQueuedOverlay 가 만든 queued bubble = 2개를 보여준다.
  */
-function clearWorkerSlotsOnStop(reason) {
-    const active = getActiveWorkers().length;
-    if (active === 0 && !hasPendingWorkerReplays())
+function clearWorkerSlotsOnStop(scopeKey, reason) {
+    const active = getActiveWorkers(scopeKey).length;
+    if (active === 0 && !hasPendingWorkerReplays(scopeKey))
         return;
-    clearAllWorkers();
-    console.log(`[jaw:stop] cleared worker registry (active=${active}, reason=${reason})`);
+    clearWorkersForScope(scopeKey);
+    console.log(`[jaw:stop] cleared worker registry (active=${active}, scope=${scopeKey}, reason=${reason})`);
 }
-function clearMainLiveRunOnStop(reason) {
-    if (reason !== 'api' && reason !== 'user' && reason !== 'steer')
+function clearMainLiveRunOnStop(scopeKey, reason) {
+    if (reason !== 'api' && reason !== 'user' && reason !== 'steer' && reason !== 'interrupt')
         return;
-    const scope = currentMainMeta?.scopeId || resolveOrcScope(stripUndefined({
-        origin: currentMainMeta?.origin || 'web',
-        chatId: currentMainMeta?.chatId,
-        workingDir: settings["workingDir"] || null,
-    }));
-    clearLiveRun(scope);
+    clearLiveRun(scopeKey);
 }
 /**
  * jwc turns run in-process (no ChildProcess), so the SIGTERM/SIGKILL paths
  * below never touch them — abort the resident runtime session explicitly or
  * /api/stop is a no-op while jwc streams (devlog 260703 tui_steer_esc_rca).
  */
-function abortInProcessRuntimeOnStop(reason) {
-    if (reason !== 'api' && reason !== 'user' && reason !== 'steer')
+function abortInProcessRuntimeOnStop(scopeKey, reason) {
+    if (reason !== 'api' && reason !== 'user' && reason !== 'steer' && reason !== 'interrupt')
         return false;
-    if (!jawRuntime.busy)
+    if (getActiveMainCli(scopeKey) !== 'jwc')
         return false;
-    jawRuntime.abort().catch((err) => {
+    const runtime = runtimeForScope(scopeKey);
+    if (!runtime.busy)
+        return false;
+    runtime.abort().catch((err) => {
         console.warn('[jaw:stop] jwc abort failed', err?.message || err);
     });
     return true;
 }
-export function killActiveAgent(reason = 'user') {
-    const hadTimer = queueCtrl.isRetryPending();
-    const cancelledPendingMain = cancelPendingMainSpawn ? (cancelPendingMainSpawn(reason), true) : false;
-    clearRetryTimer(false); // stop 의도: 큐 재개 안 함
-    clearMainLiveRunOnStop(reason);
-    const abortedInProcess = abortInProcessRuntimeOnStop(reason);
+export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
+    const scopeKey = scopedReason === undefined ? 'default' : scopeKeyOrReason;
+    const reason = scopedReason ?? scopeKeyOrReason;
+    const run = activeMainProcesses.get(scopeKey);
+    const hadTimer = queueCtrl.isRetryPending(scopeKey);
+    const cancelledPendingMain = run?.cancelPending ? (run.cancelPending(reason), true) : false;
+    clearRetryTimer(scopeKey, false);
+    if (!cancelledPendingMain)
+        clearMainLiveRunOnStop(scopeKey, reason);
+    const abortedInProcess = abortInProcessRuntimeOnStop(scopeKey, reason);
     // Fix A: 사용자 stop은 큐도 폐기. steer/internal kill은 큐 보존.
     // Fix C2: worker registry 도 비워서 hasBlockingWorkers/hasPendingWorkerReplays가 즉시 false.
     if (reason === 'api' || reason === 'user') {
-        queueCtrl.purgeQueueOnStop(reason);
-        clearWorkerSlotsOnStop(reason);
+        queueCtrl.purgeQueueOnStop(scopeKey, reason);
+        clearWorkerSlotsOnStop(scopeKey, reason);
     }
-    if (cancelActiveCodexAppTurn && getActiveMainCli() === 'codex-app') {
-        if (activeProcess?.pid)
-            killReasons.set(activeProcess.pid, reason);
-        console.log(`[jaw:kill] reason=${reason} cli=codex-app action=lease.cancel`);
-        cancelActiveCodexAppTurn(reason);
-        if (reason === 'api' || reason === 'user' || reason === 'steer')
-            activeProcess = null;
+    if (run?.cancelTurn && (getActiveMainCli(scopeKey) === 'codex-app' || getActiveMainCli(scopeKey) === 'pi')) {
+        if (run.process?.pid)
+            killReasons.set(run.process.pid, reason);
+        console.log(`[jaw:kill] reason=${reason} scope=${scopeKey} cli=${getActiveMainCli(scopeKey)} action=lease.cancel`);
+        run.cancelTurn(reason);
+        if (reason === 'api' || reason === 'user' || reason === 'steer' || reason === 'interrupt')
+            activeMainProcesses.delete(scopeKey);
         return true;
     }
-    if (cancelActivePiTurn && getActiveMainCli() === 'pi') {
-        if (activeProcess?.pid)
-            killReasons.set(activeProcess.pid, reason);
-        console.log(`[jaw:kill] reason=${reason} cli=pi action=lease.cancel`);
-        cancelActivePiTurn(reason);
-        if (reason === 'api' || reason === 'user' || reason === 'steer')
-            activeProcess = null;
-        return true;
+    const activeProcess = run?.process ?? null;
+    if (!activeProcess) {
+        if (reason === 'api' || reason === 'user' || reason === 'steer' || reason === 'interrupt')
+            activeMainProcesses.delete(scopeKey);
+        return hadTimer || cancelledPendingMain || abortedInProcess;
     }
-    if (!activeProcess)
-        return hadTimer || cancelledPendingMain || abortedInProcess; // timer/gated spawn/jwc abort 취소도 "killed" 취급
-    const policy = getKillPolicy(reason);
-    console.log(`[jaw:kill] reason=${reason} cli=${getActiveMainCli() || 'unknown'} signal=${policy.signal} escalationMs=${policy.escalationMs}`);
+    const policy = getKillPolicy(scopeKey, reason);
+    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 {
@@ -411,25 +449,23 @@ export function killActiveAgent(reason = 'user') {
         proc.stdout?.destroy();
         proc.stderr?.destroy();
     }, policy.escalationMs);
-    // Fix C1: 사용자 stop/steer 시 isAgentBusy()가 즉시 false가 되도록 참조를 동기 해제.
+    // Fix C1: 사용자 stop/steer 시 해당 scope busy가 즉시 false가 되도록 참조를 동기 해제.
     // 실제 child 종료는 위 setTimeout SIGKILL이 백그라운드에서 마무리.
     // exit handler의 setActiveProcess(null) / activeProcesses.delete 는 idempotent.
-    if (reason === 'api' || reason === 'user' || reason === 'steer') {
-        activeProcess = null;
+    if (reason === 'api' || reason === 'user' || reason === 'steer' || reason === 'interrupt') {
+        activeMainProcesses.delete(scopeKey);
     }
     return true;
 }
 export function killAllAgents(reason = 'user') {
-    const hadTimer = queueCtrl.isRetryPending();
-    const cancelledPendingMain = cancelPendingMainSpawn ? (cancelPendingMainSpawn(reason), true) : false;
-    clearRetryTimer(false); // stop 의도: 큐 재개 안 함
-    clearMainLiveRunOnStop(reason);
-    const abortedInProcess = abortInProcessRuntimeOnStop(reason);
-    // Fix A: 사용자 stop은 큐도 폐기. Fix C2: worker 슬롯도 비움.
-    if (reason === 'api' || reason === 'user') {
-        queueCtrl.purgeQueueOnStop(reason);
-        clearWorkerSlotsOnStop(reason);
+    const hadTimer = queueCtrl.isRetryPending(null);
+    const mainScopes = [...activeMainProcesses.keys()];
+    let killedMain = false;
+    for (const scopeKey of mainScopes) {
+        killedMain = killActiveAgent(scopeKey, reason) || killedMain;
     }
+    if (reason === 'api' || reason === 'user')
+        queueCtrl.purgeQueueOnStop(null, reason);
     let killed = 0;
     for (const [id, proc] of activeProcesses) {
         console.log(`[jaw:killAll] killing ${id}, reason=${reason}`);
@@ -465,23 +501,21 @@ export function killAllAgents(reason = 'user') {
             ref.stderr?.destroy();
         }, 2000);
     }
-    // Also kill main activeProcess if not in map
-    if (activeProcess && !activeProcesses.has('main')) {
-        killActiveAgent(reason);
-    }
-    // Fix C1: 사용자 stop 시 isAgentBusy() 즉시 false. 실제 종료는 백그라운드 SIGKILL.
     if (reason === 'api' || reason === 'user') {
-        activeProcess = null;
         activeProcesses.clear();
+        activeMainProcesses.clear();
+        clearAllWorkers();
     }
-    return killed > 0 || !!activeProcess || hadTimer || cancelledPendingMain || abortedInProcess;
+    return killed > 0 || killedMain || hadTimer;
 }
-export function waitForProcessEnd(timeoutMs = 3000) {
-    if (!activeProcess)
+export function waitForProcessEnd(scopeKeyOrTimeout = 'default', scopedTimeout = 3000) {
+    const scopeKey = typeof scopeKeyOrTimeout === 'string' ? scopeKeyOrTimeout : 'default';
+    const timeoutMs = typeof scopeKeyOrTimeout === 'number' ? scopeKeyOrTimeout : scopedTimeout;
+    if (!activeMainProcesses.has(scopeKey))
         return Promise.resolve();
     return new Promise(resolve => {
         const check = setInterval(() => {
-            if (!activeProcess) {
+            if (!activeMainProcesses.has(scopeKey)) {
                 clearInterval(check);
                 resolve();
             }
@@ -489,21 +523,35 @@ export function waitForProcessEnd(timeoutMs = 3000) {
         setTimeout(() => { clearInterval(check); resolve(); }, timeoutMs);
     });
 }
-export async function steerAgent(newPrompt, source) {
-    const steerWaitMs = getSteerWaitMsForActiveAgent();
-    const wasRunning = killActiveAgent('steer');
+export function canSteerAgent(scopeKey) {
+    const run = activeMainProcesses.get(scopeKey);
+    return run?.meta.cli === 'jwc' && jawRuntimesByScope.get(scopeKey)?.busy === true;
+}
+export async function steerAgent(scopeKey, newPrompt, source, meta) {
+    const run = activeMainProcesses.get(scopeKey);
+    const runtime = runtimeForScope(scopeKey);
+    const chatSessionId = meta?.chatSessionId || run?.meta.chatSessionId || getActiveChatSession();
+    if (run?.meta.cli === 'jwc' && runtime.busy) {
+        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 }));
+        await runtime.steer(settings["workingDir"] || process.cwd(), newPrompt);
+        return;
+    }
+    const steerWaitMs = getSteerWaitMsForActiveAgent(scopeKey);
+    const wasRunning = killActiveAgent(scopeKey, 'steer');
     if (wasRunning)
-        await waitForProcessEnd(steerWaitMs);
-    insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, getActiveChatSession());
-    broadcast('new_message', { role: 'user', content: newPrompt, source });
-    broadcast('steer_started', { prompt: newPrompt, origin: source || 'web' });
+        await waitForProcessEnd(scopeKey, steerWaitMs);
+    insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, chatSessionId);
+    broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
+    broadcast('steer_started', { prompt: newPrompt, origin: source || 'web', scope: scopeKey });
     const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
     const origin = source || 'web';
     const task = isResetIntent(newPrompt)
-        ? orchestrateReset({ origin, _skipInsert: true })
+        ? orchestrateReset({ origin, scope: scopeKey, chatSessionId, _skipInsert: true })
         : isContinueIntent(newPrompt)
-            ? orchestrateContinue({ origin, _skipInsert: true })
-            : orchestrate(newPrompt, { origin, _skipInsert: true });
+            ? orchestrateContinue({ origin, scope: scopeKey, chatSessionId, _skipInsert: true })
+            : orchestrate(newPrompt, { origin, scope: scopeKey, chatSessionId, _skipInsert: true });
     task.catch((err) => {
         console.error('[steer:orchestrate]', err.message);
         broadcast('orchestrate_done', { text: `[error] ${err.message}`, error: true, origin });
@@ -539,8 +587,8 @@ function formatCliUnavailableMessage(cli, detected) {
     }
     return `CLI '${cli}' not found in PATH. Run \`jaw doctor --json\`.`;
 }
-function buildHistoryBlock(currentPrompt, workingDir, maxSessions = 10, maxTotalChars = 8000) {
-    const recent = getRecentMessages.all(workingDir || null, getActiveChatSession(), Math.max(1, maxSessions * 2));
+function buildHistoryBlock(currentPrompt, workingDir, chatSessionId, maxSessions = 10, maxTotalChars = 8000) {
+    const recent = getRecentMessages.all(workingDir || null, chatSessionId, Math.max(1, maxSessions * 2));
     if (!recent.length)
         return '';
     const promptText = String(currentPrompt || '').trim();
@@ -605,18 +653,21 @@ function isStaleWorklogHistoryArtifact(text) {
         '正在从上一个 worklog 继续。',
     ].some(marker => value.includes(marker));
 }
-function getLatestAssistantContentForAgyResume(workingDir) {
-    const rows = getRecentMessages.all(workingDir || null, getActiveChatSession(), 12);
+// The session is passed in rather than read globally: the replay is prepended to THIS
+// run's prompt, so it has to come from this run's conversation and not from whichever
+// one happens to be active (073 §2.5a).
+function getLatestAssistantContentForAgyResume(workingDir, chatSessionId) {
+    const rows = getRecentMessages.all(workingDir || null, chatSessionId, 12);
     const row = rows.find((msg) => msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim().length > 0);
     return row?.content || null;
 }
-function getRecentAssistantContentsForAgyResume(workingDir) {
-    const rows = getRecentMessages.all(workingDir || null, getActiveChatSession(), 20);
+function getRecentAssistantContentsForAgyResume(workingDir, chatSessionId) {
+    const rows = getRecentMessages.all(workingDir || null, chatSessionId, 20);
     return rows
         .filter((msg) => msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim().length > 0)
         .map((msg) => String(msg.content || '').trim());
 }
-import { buildArgs, buildResumeArgs, formatAgyPrintTimeout, resolveAiEProvider, resolveSessionBucket } from './args.js';
+import { buildArgs, buildResumeArgs, formatAgyPrintTimeout, resolveAiEProvider, resolveScopedSessionBucket, resolveSessionBucket } from './args.js';
 export { buildArgs, buildResumeArgs, resolveAiEProvider, resolveSessionBucket };
 const warnedAgyCapabilityFallbacks = new Set();
 // ─── Upload wrapper ──────────────────────────────────
@@ -625,9 +676,10 @@ export { buildMediaPrompt, buildMediaPromptMany };
 // ─── Spawn Agent ─────────────────────────────────────
 import { AcpClient } from '../cli/acp-client.js';
 import { CodexAppClient, isRecoverableResumeError } from './codex-app-client.js';
-import { acquireCodexAppRuntime, acquirePiRuntime } from './runtime-pool.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';
-import { extractFromCodexAppEvent } from './codex-app-events.js';
+import { listenCodexAppTurnAdapter, } from './codex-app-events.js';
 import { canGuardedAgyResume, resolveAgyNativeResume, shouldEmitHeartbeat, shouldResumeBucketSession } from './spawn/resume.js';
 export { canGuardedAgyResume, resolveAgyNativeResume, shouldEmitHeartbeat, shouldResumeBucketSession };
 import { createQueueController, FALLBACK_MAX_RETRIES } from './spawn/queue.js';
@@ -649,19 +701,57 @@ export function spawnAgent(prompt, opts = {}) {
     const gateEligibleMain = mainManaged && !opts.agentId && !opts.internal && !opts._isFallback && !opts._isSmokeContinuation && !opts._isGoalContinuation;
     const isEmployee = !mainManaged;
     const empTag = isEmployee ? { isEmployee: true } : {};
+    const multiSessionEnabled = settings["multiSession"]?.enabled === true;
+    const capturedScope = currentSessionScope();
+    const scopeKey = multiSessionEnabled
+        ? (opts.scopeKey || capturedScope?.scope || resolveOrcScope(stripUndefined({
+            origin,
+            target: opts.target,
+            chatId: opts.chatId,
+            workingDir: settings["workingDir"] || null,
+            persistedScopeId: opts.remoteKey,
+            multiSessionEnabled,
+        })))
+        : 'default';
+    const chatSessionId = multiSessionEnabled
+        ? (opts.chatSessionId || capturedScope?.chatSessionId || getActiveChatSession())
+        : getActiveChatSession();
+    if (multiSessionEnabled) {
+        opts = stripUndefined({
+            ...opts,
+            scopeKey,
+            chatSessionId,
+            ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}),
+        });
+    }
+    let mainRun = mainManaged ? activeMainProcesses.get(scopeKey) : undefined;
+    if (mainManaged && mainRun && !opts._settingsGateWaited) {
+        console.log(`[jaw] Agent already running for scope=${scopeKey}, skipping`);
+        return { child: null, promise: Promise.resolve({ text: '', code: -1 }) };
+    }
+    if (mainManaged && !mainRun) {
+        mainRun = {
+            process: null,
+            starting: false,
+            steering: false,
+            ownerGeneration: 0,
+            meta: { origin, scopeId: scopeKey, chatSessionId, ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}) },
+        };
+        activeMainProcesses.set(scopeKey, mainRun);
+    }
     if (gateEligibleMain && !opts._settingsGateWaited && isRuntimeSettingsMutationInFlight()) {
-        if (activeProcess || queueCtrl.isRetryPending() || mainSpawnStarting) {
+        if (queueCtrl.isRetryPending(scopeKey) || mainRun?.starting) {
             console.log('[jaw] Agent already running, skipping');
             return { child: null, promise: Promise.resolve({ text: '', code: -1 }) };
         }
-        mainSpawnStarting = true;
+        mainRun.starting = true;
         let cancelled = false;
         let cancelReason = 'user';
         const cancelThisSpawn = (reason) => {
             cancelled = true;
             cancelReason = reason;
         };
-        cancelPendingMainSpawn = cancelThisSpawn;
+        mainRun.cancelPending = cancelThisSpawn;
         const promise = (async () => {
             try {
                 await waitForRuntimeSettingsIdle();
@@ -672,10 +762,12 @@ export function spawnAgent(prompt, opts = {}) {
                 return await next.promise;
             }
             finally {
-                if (cancelPendingMainSpawn === cancelThisSpawn)
-                    cancelPendingMainSpawn = null;
-                mainSpawnStarting = false;
-                processQueue();
+                const latest = activeMainProcesses.get(scopeKey);
+                if (latest?.cancelPending === cancelThisSpawn)
+                    delete latest.cancelPending;
+                if (latest)
+                    latest.starting = false;
+                void processQueue(scopeKey);
             }
         })();
         return { child: null, promise };
@@ -684,39 +776,46 @@ export function spawnAgent(prompt, opts = {}) {
     // Skip for employee spawns — distribute.ts manages AGENTS.md isolation
     if (!opts.internal && !opts._isFallback && !opts.agentId)
         regenerateB();
-    const liveScope = resolveOrcScope(stripUndefined({ origin, chatId: opts.chatId, workingDir: settings["workingDir"] || null }));
+    const liveScope = scopeKey;
     // Employee must not pollute boss's liveRun (see devlog 260423_employee_liverun_contamination)
     const effectiveLiveScope = mainManaged ? liveScope : null;
-    // INVARIANT: 모든 외부 호출은 gateway.ts isAgentBusy()를 거침.
-    // 직접 spawnAgent 호출 시 retryPendingTimer도 확인할 것.
-    if ((activeProcess || (mainSpawnStarting && gateEligibleMain && !opts._settingsGateWaited)) && mainManaged) {
+    // INVARIANT: 모든 외부 호출은 gateway.ts의 scoped busy admission을 거침.
+    // 직접 spawnAgent 호출 시 scope별 retry state도 확인할 것.
+    if (mainManaged && mainRun?.starting && gateEligibleMain && !opts._settingsGateWaited) {
         console.log('[jaw] Agent already running, skipping');
         return { child: null, promise: Promise.resolve({ text: '', code: -1 }) };
     }
     // Capture Boss main session channel so disconnected worker results can be
     // replayed to the correct origin/chatId later. Cleared in lifecycle-handler.
     if (mainManaged) {
-        setCurrentMainMeta(stripUndefined({
+        setCurrentMainMeta(scopeKey, stripUndefined({
             origin,
             target: opts.target,
             chatId: opts.chatId,
             requestId: opts.requestId,
             replyViaTarget: opts.replyViaTarget,
             scopeId: liveScope,
+            chatSessionId,
+            ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}),
         }));
     }
     let resolve;
     const resultPromise = new Promise(r => { resolve = r; });
     const session = getSession() ?? {};
-    const ownerGeneration = getSessionOwnershipGeneration();
+    const persistenceOwner = getSessionOwnershipGeneration(scopeKey);
+    const ownerGeneration = persistenceOwner.global;
+    if (mainRun)
+        mainRun.ownerGeneration = ownerGeneration;
     let cli = resolveMainCli(opts.cli, settings, session);
+    if (mainRun)
+        mainRun.meta.cli = cli;
     // Phase 52: Bootstrap consumption is moved BELOW the bucket-aware `isResume`
     // computation so we can use the authoritative per-bucket resume decision
     // instead of the legacy `isResumeGuess` heuristic. See comment near line 762.
     // ─── Fallback retry: skip to fallback if retries exhausted ───
     if (!opts._isFallback && !opts.internal) {
-        const st = queueCtrl.fallbackState.get(cli);
-        if (st && st.retriesLeft <= 0) {
+        const st = queueCtrl.fallbackStateForScope(scopeKey).get(cli);
+        if (st?.fallbackCli && st.retriesLeft <= 0) {
             const fbAvail = detectCli(st.fallbackCli)?.available;
             if (fbAvail) {
                 console.log(`[jaw:fallback] ${cli} retries exhausted → direct ${st.fallbackCli}`);
@@ -730,8 +829,9 @@ export function spawnAgent(prompt, opts = {}) {
     // ─── jwc in-process branch (110.3 §B) ───────────────────────────────
     // Resident engine, no ChildProcess. Mirrors the main-managed lifecycle
     // (insertMessage → beginLiveRun → run → persist → clearLiveRun → processQueue)
-    // so isAgentBusy()/queue/SSE behave identically. Employees fall through.
+    // so scoped busy/queue/SSE behave identically. Employees fall through.
     if (cli === 'jwc' && mainManaged && !opts.internal) {
+        const jawRuntime = runtimeForScope(scopeKey);
         const jwcLabel = 'main';
         const jwcOverrides = settings["activeOverrides"]?.['jwc'];
         const jwcPerCli = settings["perCli"]?.['jwc'];
@@ -739,9 +839,9 @@ export function spawnAgent(prompt, opts = {}) {
         const jwcProvider = jwcOverrides?.['provider'] || jwcPerCli?.['provider'] || 'anthropic';
         const jwcCwd = settings["workingDir"] || process.cwd();
         if (!opts._skipInsert) {
-            insertMessage.run('user', prompt, 'jwc', jwcModel, settings["workingDir"] || null, getActiveChatSession());
+            insertMessage.run('user', prompt, 'jwc', jwcModel, settings["workingDir"] || null, chatSessionId);
         }
-        mainSpawnStarting = true;
+        mainRun.starting = true;
         beginLiveRun(liveScope, 'jwc');
         broadcast('agent_status', { running: true, agentId: jwcLabel, cli: 'jwc' });
         const jwcEffort = jwcOverrides?.['effort'] || jwcPerCli?.['effort'] || '';
@@ -753,9 +853,9 @@ export function spawnAgent(prompt, opts = {}) {
             const rawFinalText = result.code === 0 ? live.text : result.text;
             const finalText = applyOutputPolicy(rawFinalText, { scope: 'main' }).text;
             // Persist may throw (better-sqlite3 is sync: DB lock / schema). Cleanup MUST
-            // still run or mainSpawnStarting sticks true and the jwc queue deadlocks.
+            // still run or this scope's starting flag stays true and its queue deadlocks.
             try {
-                insertMessageWithTraceRun.run('assistant', finalText, 'jwc', jwcModel, null, JSON.stringify(sanitizeToolLogForDurableStorage(live.toolLog)), settings["workingDir"] || null, live.traceRunId || null, getActiveChatSession());
+                insertMessageWithTraceRun.run('assistant', finalText, 'jwc', jwcModel, null, JSON.stringify(sanitizeToolLogForDurableStorage(live.toolLog)), settings["workingDir"] || null, live.traceRunId || null, chatSessionId);
                 broadcast('agent_done', { text: finalText, origin, ...(result.code === 0 ? {} : { error: true }) });
             }
             catch (err) {
@@ -765,10 +865,11 @@ export function spawnAgent(prompt, opts = {}) {
             finally {
                 clearLiveRun(liveScope);
                 broadcast('agent_status', { running: false, agentId: jwcLabel, cli: 'jwc' });
-                mainSpawnStarting = false;
+                mainRun.starting = false;
                 jawRuntime.setLiveScope(undefined);
+                releaseMainRun(scopeKey, null, ownerGeneration);
                 resolve({ text: finalText, code: result.code });
-                processQueue();
+                void processQueue(scopeKey);
             }
         };
         // jawRuntime.prompt is designed never to reject, but guard defensively so a
@@ -798,14 +899,18 @@ export function spawnAgent(prompt, opts = {}) {
         ? migrateLegacyClaudeValue(requestedModel)
         : requestedModel;
     const runtimeModel = cli === 'cursor' ? resolveCursorModelVariant(model, effort) : model;
+    const codexMultiplexMain = cli === 'codex-app' && mainManaged && !opts.agentId
+        && settings["runtime"]?.codexApp?.multiplex === true;
     if (mainManaged) {
-        setCurrentMainMeta(stripUndefined({
+        setCurrentMainMeta(scopeKey, stripUndefined({
             origin,
             target: opts.target,
             chatId: opts.chatId,
             requestId: opts.requestId,
             replyViaTarget: opts.replyViaTarget,
             scopeId: liveScope,
+            chatSessionId,
+            ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}),
             cli,
             model: runtimeModel,
             effectiveProvider,
@@ -821,7 +926,12 @@ export function spawnAgent(prompt, opts = {}) {
     // Bucket-aware resume: codex-spark is kept in its own session bucket so
     // cross-model resume (gpt-5.4 ↔ gpt-5.3-codex-spark) doesn't send a
     // mismatched session_id to the server.
-    const currentBucket = resolveSessionBucket(cli, runtimeModel, effectiveProvider);
+    // Every runtime now keys its bucket by scope (073 §2.1), which replaces the guard 072
+    // put here. That guard gave a non-default scope no bucket at all — no resume, no
+    // snapshot, no stale clear — because sharing one was worse. Having its own is better
+    // than either. The default scope keeps the bare bucket name, so a session that existed
+    // before this change continues the conversation it was already in.
+    const currentBucket = resolveScopedSessionBucket(cli, runtimeModel, effectiveProvider, scopeKey, effort, 'fallback', codexMultiplexMain);
     const envDefaultsCli = cli === 'ai-e' ? effectiveProvider : cli;
     const cliEnv = applyCliEnvDefaults(envDefaultsCli, opts.env);
     const spawnEnv = makeCleanEnv(cliEnv);
@@ -839,7 +949,7 @@ export function spawnAgent(prompt, opts = {}) {
         sessionId: bucketSessionId, bucketUpdatedAt, requestedModel: runtimeModel, bucketModel,
         cwd: settings['workingDir'] || '', lastRunCwd: bucketRow?.last_run_cwd,
         lastRunClean: bucketRow?.last_run_clean, lastRunMeta: bucketRow?.last_run_meta,
-        freshBootstrap: forceNew || opts._skipResume === true || Boolean(peekPendingBootstrapPrompt()),
+        freshBootstrap: forceNew || opts._skipResume === true || Boolean(peekPendingBootstrapPrompt(scopeKey)),
     });
     if (cli === 'agy')
         console.log(`[agy-resume] ${agyResumeDecision.ok ? 'resume' : 'fresh'} reason=${agyResumeDecision.reason}`);
@@ -859,16 +969,20 @@ export function spawnAgent(prompt, opts = {}) {
     // Using `isResume` (bucket-aware) instead of legacy `isResumeGuess` so cross-model
     // toggles (e.g. gpt-5.4 ↔ gpt-5.3-codex-spark) get the bootstrap they need.
     if (!opts.agentId && !opts.internal && !isResume) {
-        const pending = consumePendingBootstrapPrompt();
+        const pending = consumePendingBootstrapPrompt(scopeKey);
         if (pending) {
             console.log(`[jaw:compact] injecting bootstrap (${pending.length} chars)`);
             prompt = `${pending}\n\n---\n\n${prompt}`;
         }
     }
     if (!empSid && !forceNew && bucketSessionId && !canResumeBucketSession) {
-        if (!peekPendingBootstrapPrompt()) {
+        if (!peekPendingBootstrapPrompt(scopeKey)) {
             import('../core/compact.js')
-                .then(({ autoCompactRefresh }) => autoCompactRefresh({ workDir: settings["workingDir"] || null, instructions: '', cli, model }))
+                .then(({ autoCompactRefresh }) => autoCompactRefresh({
+                workDir: settings["workingDir"] || null, instructions: '', cli, model: runtimeModel, scopeKey,
+                chatSessionId,
+                ...(currentBucket ? { sessionBucket: currentBucket } : {}),
+            }))
                 .catch(() => { });
         }
         try {
@@ -934,9 +1048,14 @@ export function spawnAgent(prompt, opts = {}) {
         prompt = `${ts}\n${projLine}${prompt}${memoryNudge}`;
     }
     const resumeSessionId = empSid || (isResume ? bucketSessionId : null);
-    const needsHistory = !opts._skipHistory && (!isResume || cli === 'pi');
+    const needsHistory = shouldBuildHistoryBlock({
+        skipHistory: opts._skipHistory === true,
+        isResume,
+        cli,
+        codexMultiplexMain,
+    });
     const historyBlock = needsHistory
-        ? buildHistoryBlock(prompt, settings["workingDir"], 10, 8000)
+        ? buildHistoryBlock(prompt, settings["workingDir"], chatSessionId, 10, 8000)
         : '';
     let agyBootstrap = null;
     let promptForArgs = buildPromptForArgs({
@@ -948,10 +1067,10 @@ export function spawnAgent(prompt, opts = {}) {
         isResume,
     });
     const agyResumeReplayPrefix = cli === 'agy' && isResume
-        ? getLatestAssistantContentForAgyResume(settings["workingDir"])
+        ? getLatestAssistantContentForAgyResume(settings["workingDir"], chatSessionId)
         : null;
     const agyResumeReplayPrefixes = cli === 'agy' && isResume
-        ? getRecentAssistantContentsForAgyResume(settings["workingDir"])
+        ? getRecentAssistantContentsForAgyResume(settings["workingDir"], chatSessionId)
         : [];
     const claudeBin = (cli === 'claude-e' || (cli === 'ai-e' && effectiveProvider === 'claude'))
         ? detectCli('claude').path
@@ -1045,8 +1164,8 @@ export function spawnAgent(prompt, opts = {}) {
         promptChars: promptForArgs.length + (sysPrompt?.length || 0),
         prompt: `${sysPrompt || ''}\n${promptForArgs}`,
     });
-    if (policyVerdicts.length && currentMainMeta)
-        currentMainMeta.policyVerdicts = policyVerdicts;
+    if (policyVerdicts.length && mainRun)
+        mainRun.meta.policyVerdicts = policyVerdicts;
     // ─── DIFF-A: Preflight — verify CLI binary exists before spawn ───
     const detected = detectCli(cli);
     const resolvedOpencodeBinary = cli === 'opencode'
@@ -1062,8 +1181,10 @@ export function spawnAgent(prompt, opts = {}) {
             clearLiveRun(liveScope);
         broadcast('agent_done', { text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
         resolve({ text: '', code: 127 });
-        if (mainManaged)
-            processQueue();
+        if (mainManaged) {
+            releaseMainRun(scopeKey, null, ownerGeneration);
+            void processQueue(scopeKey);
+        }
         cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
         return { child: null, promise: resultPromise };
     }
@@ -1113,8 +1234,9 @@ export function spawnAgent(prompt, opts = {}) {
             throw new Error('Copilot ACP process was not created');
         }
         if (mainManaged)
-            activeProcess = child;
-        registerActiveProcess(agentLabel, child);
+            mainRun.process = child;
+        else
+            registerActiveProcess(agentLabel, child);
         if (!opts.internal)
             broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
         if (mainManaged && !opts.internal)
@@ -1129,19 +1251,21 @@ export function spawnAgent(prompt, opts = {}) {
             opts.lifecycle?.onExit?.(null);
             const msg = `Copilot ACP spawn failed: ${err.message}`;
             console.error(`[acp:error] ${msg}`);
-            activeProcesses.delete(agentLabel);
             if (mainManaged) {
-                activeProcess = null;
+                releaseMainRun(scopeKey, child, ownerGeneration);
                 clearLiveRun(liveScope);
                 broadcast('agent_status', { running: false, agentId: agentLabel });
             }
+            else {
+                activeProcesses.delete(agentLabel);
+            }
             broadcast('agent_done', { text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
             resolve({ text: '', code: 1 });
             if (mainManaged)
-                processQueue();
+                void processQueue(scopeKey);
         });
         if (mainManaged && !opts.internal && !opts._skipInsert) {
-            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, getActiveChatSession());
+            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, chatSessionId);
         }
         if (!opts.internal)
             broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
@@ -1317,7 +1441,7 @@ export function spawnAgent(prompt, opts = {}) {
                 }
                 // If loadSession failed (or not resuming), inject history into prompt
                 const needsHistoryFallback = isResume && !loadSessionOk;
-                const fallbackHistory = needsHistoryFallback && !opts._skipHistory ? buildHistoryBlock(prompt, settings["workingDir"]) : '';
+                const fallbackHistory = needsHistoryFallback && !opts._skipHistory ? buildHistoryBlock(prompt, settings["workingDir"], chatSessionId) : '';
                 const acpPrompt = needsHistoryFallback
                     ? withHistoryPrompt(prompt, fallbackHistory)
                     : (isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
@@ -1330,7 +1454,8 @@ export function spawnAgent(prompt, opts = {}) {
                 // which skips the exit handler's code===0 gate, losing session continuity.
                 const persistedAcpSessionId = ctx.sessionId;
                 if (persistedAcpSessionId && persistMainSession(stripUndefined({
-                    ownerGeneration,
+                    persistenceOwner,
+                    scopeKey,
                     forceNew,
                     employeeSessionId: empSid,
                     sessionId: persistedAcpSessionId,
@@ -1340,6 +1465,11 @@ export function spawnAgent(prompt, opts = {}) {
                     resumeKey,
                     effort: cfg.effort || '',
                     skipSessionPersist: opts._skipSessionPersist === true,
+                    // Without this the save falls back to the bare, unscoped bucket, and a
+                    // successful turn in another session writes its vendor id into the row
+                    // the default session resumes from. The exit handler below passes the
+                    // same value; this path runs first and must not disagree with it.
+                    scopedBucket: currentBucket,
                 }))) {
                     console.log(`[jaw:session] saved ${cli} session=${persistedAcpSessionId.slice(0, 12)}... (pre-shutdown)`);
                 }
@@ -1376,14 +1506,18 @@ export function spawnAgent(prompt, opts = {}) {
             handleAgentExit({
                 ctx, code: acpCode, cli, model, agentLabel, mainManaged, origin,
                 resumeKey,
-                prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                 isResume, wasKilled, wasSteer, smokeResult,
                 effortDefault: '', costLine: '',
                 resolve: resolve,
                 activeProcesses,
-                setActiveProcess: (v) => { activeProcess = v; },
-                retryState: queueCtrl.retryState,
-                fallbackState: queueCtrl.fallbackState,
+                scopeKey,
+                scopedBucket: currentBucket,
+                chatSessionId,
+                childProcess: child,
+                releaseMainRun,
+                retryState: queueCtrl.retryStateForScope(scopeKey),
+                fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
                 fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                 processQueue,
             }).catch((err) => {
@@ -1515,8 +1649,8 @@ export function spawnAgent(prompt, opts = {}) {
                 return leaseCancel;
             };
             const cancelHook = (_reason) => { void requestCancel(); };
-            if (lease)
-                cancelActivePiTurn = cancelHook;
+            if (lease && mainRun)
+                mainRun.cancelTurn = cancelHook;
             const piWatchdog = attachWatchdog(child, agentLabel, (reason) => {
                 console.log(`[jaw:watchdog] cancelling ${agentLabel} (pi) — ${reason}`);
                 ctx.stallReason = reason;
@@ -1524,8 +1658,9 @@ export function spawnAgent(prompt, opts = {}) {
             });
             ctx.stallWatchdog = piWatchdog;
             if (mainManaged)
-                activeProcess = child;
-            registerActiveProcess(agentLabel, child);
+                mainRun.process = child;
+            else
+                registerActiveProcess(agentLabel, child);
             if (!opts.internal)
                 broadcast('agent_status', { running: true, agentId: agentLabel, cli, provider: profile.id, ...empTag });
             if (mainManaged && !opts.internal) {
@@ -1533,15 +1668,15 @@ export function spawnAgent(prompt, opts = {}) {
                 setLiveRunTraceId(liveScope, traceRunId);
             }
             if (mainManaged && !opts.internal && !opts._skipInsert) {
-                insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, getActiveChatSession());
+                insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
             }
             if (!opts.internal)
                 broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, provider: profile.id, ...empTag }, traceAudience);
             const releaseLease = async () => {
                 if (leaseCancel)
                     await leaseCancel;
-                if (cancelActivePiTurn === cancelHook)
-                    cancelActivePiTurn = null;
+                if (mainRun?.cancelTurn === cancelHook)
+                    delete mainRun.cancelTurn;
                 if (lease)
                     lease.release();
                 else
@@ -1568,14 +1703,18 @@ export function spawnAgent(prompt, opts = {}) {
                 return handleAgentExit({
                     ctx, code: result.code, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
                     resumeKey,
-                    prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                    prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                     isResume: false, wasKilled, wasSteer, smokeResult,
                     effortDefault: 'medium', costLine: '',
                     resolve: resolve,
                     activeProcesses,
-                    setActiveProcess: (v) => { activeProcess = v; },
-                    retryState: queueCtrl.retryState,
-                    fallbackState: queueCtrl.fallbackState,
+                    scopeKey,
+                    scopedBucket: currentBucket,
+                    chatSessionId,
+                    childProcess: child,
+                    releaseMainRun,
+                    retryState: queueCtrl.retryStateForScope(scopeKey),
+                    fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
                     fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                     processQueue,
                 });
@@ -1588,14 +1727,18 @@ export function spawnAgent(prompt, opts = {}) {
                 handleAgentExit({
                     ctx, code: 1, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
                     resumeKey,
-                    prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                    prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                     isResume: false, wasKilled: false, wasSteer: false, smokeResult: detectSmokeResponse('', [], 1, cli),
                     effortDefault: 'medium', costLine: '',
                     resolve: resolve,
                     activeProcesses,
-                    setActiveProcess: (v) => { activeProcess = v; },
-                    retryState: queueCtrl.retryState,
-                    fallbackState: queueCtrl.fallbackState,
+                    scopeKey,
+                    scopedBucket: currentBucket,
+                    chatSessionId,
+                    childProcess: child,
+                    releaseMainRun,
+                    retryState: queueCtrl.retryStateForScope(scopeKey),
+                    fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
                     fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                     processQueue,
                 }).catch((handleErr) => {
@@ -1620,10 +1763,10 @@ export function spawnAgent(prompt, opts = {}) {
             .update(profile.apiKey || '')
             .digest('hex')
             .slice(0, 12);
-        mainSpawnStarting = true;
+        mainRun.starting = true;
         void acquirePiRuntime({
             key: {
-                scopeKey: `chat:${getActiveChatSession()}`,
+                scopeKey,
                 cwd: spawnCwd,
                 profileId: profile.id,
                 fullEndpoint: profile.endpoint,
@@ -1637,20 +1780,21 @@ export function spawnAgent(prompt, opts = {}) {
             instructions: piSysPrompt,
             forceNew,
         }).then((lease) => {
-            mainSpawnStarting = false;
+            mainRun.starting = false;
             ctx.sessionId = lease.session.sessionId;
             console.log(`[jaw:pi:pool] reused=${lease.reused} sessionId=${lease.session.sessionId || 'new'}`);
             const done = lease.session.sendPrompt(piPrompt, { effort, onEvent: onPiEvent })
                 .then((result) => ({ ...result, code: 0, sessionId: lease.session.sessionId }));
             runPiTurn(lease.session.child, done, lease);
         }).catch((err) => {
-            mainSpawnStarting = false;
+            mainRun.starting = false;
             console.error(`[jaw:pi:pool] acquire failed: ${err.message}`);
             clearLiveRun(liveScope);
             broadcast('agent_status', { running: false, agentId: agentLabel });
             broadcast('agent_done', { text: `❌ Pi RPC acquire failed: ${err.message}`, error: true, origin }, 'public');
+            releaseMainRun(scopeKey, null, ownerGeneration);
             resolve({ text: '', code: 1 });
-            processQueue();
+            void processQueue(scopeKey);
         });
         return { child: null, promise: resultPromise };
     }
@@ -1664,7 +1808,7 @@ export function spawnAgent(prompt, opts = {}) {
             }
         }
         if (mainManaged && !opts.internal && !opts._skipInsert) {
-            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, getActiveChatSession());
+            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, chatSessionId);
         }
         if (!opts.internal)
             broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
@@ -1711,13 +1855,7 @@ export function spawnAgent(prompt, opts = {}) {
             settleTurn = resolveTurn;
             rejectTurn = rejectTurnPromise;
         });
-        const handleNotification = (method, params) => {
-            markCodexProgress();
-            if (method === 'turn/completed' || method === 'turn/started' || method === 'error') {
-                console.log(`[codex-app:notify] ${method}`);
-            }
-            appendTraceEvent({ runId: ctx.traceRunId, source: 'codex_app_raw', eventType: method, raw: params });
-            const parsed = extractFromCodexAppEvent(method, params, ctx);
+        const consumeCodexAppEvent = (method, parsed) => {
             if (!parsed) {
                 if (method === 'turn/completed')
                     settleTurn();
@@ -1748,7 +1886,11 @@ export function spawnAgent(prompt, opts = {}) {
             }
             if (parsed.text) {
                 flushCodexAppThinking();
-                const segment = appendAssistantTextSegment(ctx, parsed.text);
+                // codex-app streams item/agentMessage/delta at TOKEN granularity;
+                // the segment formatter would inject "\n- " between unjoined
+                // tokens ("이"+"지만" → "이\n- 지만"). Raw-append like the plain
+                // `claude` text_delta path (events/index.ts) instead.
+                const segment = appendAssistantRawText(ctx, parsed.text);
                 if (segment) {
                     broadcastAgentOutput(ctx, agentLabel, cli, segment, empTag, traceAudience);
                     lastVisibleBroadcastTs = Date.now();
@@ -1786,13 +1928,14 @@ export function spawnAgent(prompt, opts = {}) {
             }
         };
         const effectiveFastMode = cfg.fastMode ?? settings["perCli"]?.["codex"]?.fastMode ?? false;
-        const runCodexAppTurn = async (appClient, lease) => {
+        const runCodexAppTurn = async (appClient, lease, laneScope) => {
             const child = appClient.proc;
             if (!child)
                 throw new Error('Codex AppServer process was not created');
             if (mainManaged)
-                activeProcess = child;
-            registerActiveProcess(agentLabel, child);
+                mainRun.process = child;
+            else
+                registerActiveProcess(agentLabel, child);
             if (!opts.internal)
                 broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
             const processExit = { value: null };
@@ -1813,8 +1956,8 @@ export function spawnAgent(prompt, opts = {}) {
                 return leaseCancel;
             };
             const cancelHook = (_reason) => { void requestLeaseCancel(); };
-            if (lease)
-                cancelActiveCodexAppTurn = cancelHook;
+            if (lease && mainRun)
+                mainRun.cancelTurn = cancelHook;
             const watchdogTimeout = (kind) => {
                 if (watchdogCancel)
                     return;
@@ -1829,8 +1972,23 @@ export function spawnAgent(prompt, opts = {}) {
             idleTimer = setTimeout(() => { watchdogTimeout('idle'); }, idleMs);
             absoluteTimer = setTimeout(() => { watchdogTimeout('absolute'); }, absoluteMs);
             markCodexProgress = resetIdleTimer;
-            const scope = appClient.listenTurn({
-                onNotification: handleNotification,
+            const listener = listenCodexAppTurnAdapter(appClient, lease, laneScope, ctx, {
+                onProgress: () => { markCodexProgress(); },
+                onRawNotification: (method, params) => {
+                    if (method === 'turn/completed' || method === 'turn/started' || method === 'error') {
+                        console.log(`[codex-app:notify] ${method}`);
+                    }
+                    appendTraceEvent({ runId: ctx.traceRunId, source: 'codex_app_raw', eventType: method, raw: params });
+                },
+                onDiagnosticNotification: (entry) => {
+                    appendTraceEvent({
+                        runId: ctx.traceRunId,
+                        source: 'codex_app_raw',
+                        eventType: 'unrouted-notification',
+                        raw: entry,
+                    });
+                },
+                onEvent: consumeCodexAppEvent,
                 onStderr: handleStderr,
                 onExit: (code, signal) => {
                     processExit.value = { code, signal };
@@ -1850,9 +2008,16 @@ export function spawnAgent(prompt, opts = {}) {
                     const initResult = await appClient.initialize();
                     if (process.env["DEBUG"])
                         console.log('[codex-app:init]', JSON.stringify(initResult).slice(0, 200));
+                    const threadOptions = {
+                        model,
+                        effort,
+                        cwd: spawnCwd,
+                        fastMode: effectiveFastMode,
+                        instructions: sysPrompt,
+                    };
                     if (isResume && resumeSessionId) {
                         try {
-                            await appClient.resumeThread(resumeSessionId, { instructions: sysPrompt });
+                            await appClient.resumeThread(laneScope, resumeSessionId, threadOptions);
                             console.log(`[codex-app:session] resumeThread OK: ${resumeSessionId.slice(0, 12)}...`);
                         }
                         catch (resumeErr) {
@@ -1862,27 +2027,29 @@ export function spawnAgent(prompt, opts = {}) {
                             console.warn(`[codex-app:session] resumeThread FAILED (recoverable): ${message} — starting new thread`);
                             if (empSid && opts.agentId)
                                 clearEmployeeSession.run(opts.agentId);
-                            await appClient.startThread({ instructions: sysPrompt, cwd: spawnCwd });
+                            await appClient.startThread(laneScope, threadOptions);
                         }
                     }
                     else {
-                        await appClient.startThread({ instructions: sysPrompt, cwd: spawnCwd });
+                        await appClient.startThread(laneScope, threadOptions);
                     }
-                    ctx.sessionId = appClient.threadId;
+                    ctx.sessionId = appClient.getThreadId(laneScope) ?? '';
                 }
                 const shouldPrependHistory = lease
-                    ? !lease.resumedThread
+                    ? !(lease.resumedThread || lease.reused)
                     : !(isResume && Boolean(resumeSessionId));
                 const codexAppPrompt = (shouldPrependHistory && historyBlock)
                     ? `${historyBlock}\n\n[User Message]\n${prompt}`
                     : prompt;
-                await Promise.race([appClient.startTurn(codexAppPrompt), turnDone]);
+                const startTurn = appClient.startTurn(laneScope, codexAppPrompt);
+                await Promise.race([startTurn, turnDone]);
                 await turnDone;
                 turnCompleted = !turnReportedFailure;
                 flushCodexAppThinking();
-                const persistedThreadId = lease?.threadId ?? appClient.threadId;
+                const persistedThreadId = lease?.threadId ?? appClient.getThreadId(laneScope);
                 if (persistedThreadId && persistMainSession(stripUndefined({
-                    ownerGeneration,
+                    persistenceOwner,
+                    scopeKey,
                     forceNew,
                     employeeSessionId: empSid,
                     sessionId: persistedThreadId,
@@ -1892,6 +2059,11 @@ export function spawnAgent(prompt, opts = {}) {
                     resumeKey,
                     effort: cfg.effort || '',
                     skipSessionPersist: opts._skipSessionPersist === true,
+                    ...(lease?.bucketKey ? { codexAppBucket: lease.bucketKey } : {}),
+                    // With multiplex off there is no lease bucket key, and without this the
+                    // save lands on the bare `codex-app` row that belongs to the default
+                    // session. codex-app is the default runtime, so that is the common case.
+                    scopedBucket: currentBucket,
                 }))) {
                     console.log(`[jaw:session] saved ${cli} session=${persistedThreadId.slice(0, 12)}... (pre-shutdown)`);
                 }
@@ -1909,9 +2081,9 @@ export function spawnAgent(prompt, opts = {}) {
                 markCodexProgress = () => { };
                 if (watchdogCancel)
                     await watchdogCancel;
-                if (cancelActiveCodexAppTurn === cancelHook)
-                    cancelActiveCodexAppTurn = null;
-                scope.dispose();
+                if (mainRun?.cancelTurn === cancelHook)
+                    delete mainRun.cancelTurn;
+                listener.dispose();
                 if (lease)
                     lease.release();
                 else {
@@ -1920,7 +2092,11 @@ export function spawnAgent(prompt, opts = {}) {
                     cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
                 }
             }
-            const exitCode = turnCompleted ? 0 : (processExit.value?.code ?? 1);
+            // A turn that never completed is a failure even when the process it
+            // was running on exited cleanly. Trusting the child's status here
+            // reports success for a turn that produced nothing, which is exactly
+            // what happens when a shared host is closed mid-turn.
+            const exitCode = turnCompleted ? 0 : (processExit.value?.code || 1);
             opts.lifecycle?.onExit?.(exitCode);
             const killReason = consumeKillReason(child.pid);
             if (processExit.value && processExit.value.code !== 0 && !killReason) {
@@ -1934,14 +2110,19 @@ export function spawnAgent(prompt, opts = {}) {
             await handleAgentExit({
                 ctx, code: exitCode, cli, model, agentLabel, mainManaged, origin,
                 resumeKey,
-                prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                 isResume, wasKilled, wasSteer, smokeResult,
                 effortDefault: '', costLine: '',
                 resolve: resolve,
                 activeProcesses,
-                setActiveProcess: (v) => { activeProcess = v; },
-                retryState: queueCtrl.retryState,
-                fallbackState: queueCtrl.fallbackState,
+                scopeKey,
+                scopedBucket: currentBucket,
+                chatSessionId,
+                ...(lease?.bucketKey ? { codexAppBucket: lease.bucketKey } : {}),
+                childProcess: child,
+                releaseMainRun,
+                retryState: queueCtrl.retryStateForScope(scopeKey),
+                fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
                 fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                 processQueue,
             }).catch((err) => {
@@ -1949,38 +2130,160 @@ export function spawnAgent(prompt, opts = {}) {
             });
         };
         if (opts.agentId) {
+            const employeeLaneScope = `employee:${opts.agentId}`;
             const appClient = new CodexAppClient({
                 binary: detected.path || 'codex', workDir: spawnCwd, env: spawnEnv,
-                model, effort, fastMode: effectiveFastMode,
             });
             appClient.spawn();
             const child = appClient.proc;
             if (!child)
                 throw new Error('Codex AppServer process was not created');
-            void runCodexAppTurn(appClient, null);
+            void runCodexAppTurn(appClient, null, employeeLaneScope);
             return { child, promise: resultPromise };
         }
-        mainSpawnStarting = true;
-        void acquireCodexAppRuntime({
-            binary: detected.path || 'codex', env: spawnEnv,
-            key: {
-                scopeKey: `chat:${getActiveChatSession()}`,
-                cwd: spawnCwd, model, effort, fastMode: effectiveFastMode,
-            },
-            storedThreadId: resumeSessionId || null,
-            instructions: sysPrompt,
-            forceNew,
-        }).then(async (lease) => {
-            mainSpawnStarting = false;
-            await runCodexAppTurn(lease.client, lease);
+        mainRun.starting = true;
+        const acquireCodexAppForTurn = async () => {
+            let cancelled = false;
+            let cancelReason = 'user';
+            const cancelThisAcquire = (reason) => {
+                cancelled = true;
+                cancelReason = reason;
+            };
+            const acquireWasCancelled = () => cancelled || activeMainProcesses.get(scopeKey) !== mainRun;
+            try {
+                if (!codexMultiplexMain) {
+                    const lease = await acquireCodexAppRuntime({
+                        binary: detected.path || 'codex', env: spawnEnv,
+                        route: 'legacy',
+                        key: {
+                            scopeKey,
+                            cwd: spawnCwd, model, effort, fastMode: effectiveFastMode,
+                        },
+                        storedThreadId: resumeSessionId || null,
+                        instructions: sysPrompt,
+                        forceNew,
+                    });
+                    return { kind: 'lease', lease };
+                }
+                mainRun.cancelPending = cancelThisAcquire;
+                const waitMs = configuredPositiveMs(process.env["CODEX_APP_ACQUIRE_WAIT_MS"], DEFAULT_CODEX_APP_ACQUIRE_WAIT_MS);
+                const deadlineAt = Date.now() + waitMs;
+                let lastStaleError = null;
+                let staleAttempts = 0;
+                const deadlineError = (stage) => lastStaleError
+                    ?? new Error(`Codex App ${stage} timed out after ${waitMs}ms`);
+                const awaitWithinDeadline = async (stage, pending, onLateValue) => {
+                    let deadlineWon = false;
+                    let timeout;
+                    void pending.then((value) => {
+                        if (deadlineWon)
+                            onLateValue?.(value);
+                    }, () => { });
+                    const remainingMs = deadlineAt - Date.now();
+                    if (remainingMs <= 0) {
+                        deadlineWon = true;
+                        throw deadlineError(stage);
+                    }
+                    const deadline = new Promise((_resolveDeadline, rejectDeadline) => {
+                        timeout = setTimeout(() => {
+                            deadlineWon = true;
+                            rejectDeadline(deadlineError(stage));
+                        }, remainingMs);
+                    });
+                    try {
+                        return await Promise.race([pending, deadline]);
+                    }
+                    finally {
+                        if (timeout)
+                            clearTimeout(timeout);
+                    }
+                };
+                for (;;) {
+                    if (acquireWasCancelled())
+                        return { kind: 'cancelled', reason: cancelReason };
+                    // Check the budget before spawning more work. awaitWithinDeadline()
+                    // only measures what remains once the promise already exists, so a
+                    // backoff that consumed the last of the budget would still get to
+                    // start one more prepare.
+                    if (deadlineAt - Date.now() <= 0)
+                        throw lastStaleError ?? deadlineError('prepare');
+                    try {
+                        const prepared = await awaitWithinDeadline('prepare', prepareCodexAppHost({
+                            binary: detected.path || 'codex', cwd: spawnCwd,
+                            fastMode: effectiveFastMode, env: spawnEnv, model, effort,
+                        }));
+                        if (acquireWasCancelled())
+                            return { kind: 'cancelled', reason: cancelReason };
+                        const lease = await awaitWithinDeadline('acquire', acquireCodexAppLane(prepared, {
+                            scopeKey,
+                            bucketKey: currentBucket,
+                            storedThreadId: resumeSessionId || null,
+                            instructions: sysPrompt,
+                            forceNew,
+                            waitMs: deadlineAt - Date.now(),
+                        }), (lateLease) => { lateLease.release(); });
+                        if (acquireWasCancelled()) {
+                            lease.release();
+                            return { kind: 'cancelled', reason: cancelReason };
+                        }
+                        return { kind: 'lease', lease };
+                    }
+                    catch (err) {
+                        if (!(err instanceof CodexHostGenerationStaleError))
+                            throw err;
+                        lastStaleError = err;
+                        if (acquireWasCancelled())
+                            return { kind: 'cancelled', reason: cancelReason };
+                        const remainingMs = deadlineAt - Date.now();
+                        if (remainingMs <= 0)
+                            throw lastStaleError;
+                        staleAttempts += 1;
+                        const backoffMs = Math.min(remainingMs, CODEX_APP_ACQUIRE_RETRY_BACKOFF_MAX_MS, 25 * staleAttempts);
+                        await new Promise((done) => { setTimeout(done, backoffMs); });
+                    }
+                }
+            }
+            finally {
+                const latest = activeMainProcesses.get(scopeKey);
+                if (latest?.cancelPending === cancelThisAcquire)
+                    delete latest.cancelPending;
+                mainRun.starting = false;
+            }
+        };
+        void acquireCodexAppForTurn().then(async (outcome) => {
+            // A run that never started a turn owns nothing but its own map slot.
+            // releaseMainRun() matches on (process, ownerGeneration), and a pending
+            // run has process=null while sharing the global generation with whatever
+            // replaced it, so calling it here would delete the replacement's entry.
+            // Compare the captured object instead and only drop our own slot.
+            const abandonTurn = (lease) => {
+                lease?.release();
+                finalizeTraceRun(traceRunId, 'interrupted');
+                clearLiveRun(liveScope);
+                broadcast('agent_status', { running: false, agentId: agentLabel });
+                resolve({ text: '', code: -1 });
+                if (activeMainProcesses.get(scopeKey) === mainRun)
+                    activeMainProcesses.delete(scopeKey);
+                void processQueue(scopeKey);
+            };
+            if (outcome.kind === 'cancelled') {
+                abandonTurn(null);
+                return;
+            }
+            const lease = outcome.lease;
+            if (activeMainProcesses.get(scopeKey) !== mainRun) {
+                abandonTurn(lease);
+                return;
+            }
+            await runCodexAppTurn(lease.client, lease, lease.laneScope);
         }).catch((err) => {
-            mainSpawnStarting = false;
             console.error(`[codex-app:pool] acquire failed: ${err.message}`);
             clearLiveRun(liveScope);
             broadcast('agent_status', { running: false, agentId: agentLabel });
             broadcast('agent_done', { text: `❌ Codex AppServer acquire failed: ${err.message}`, error: true, origin }, 'public');
+            releaseMainRun(scopeKey, null, ownerGeneration);
             resolve({ text: '', code: 1 });
-            processQueue();
+            void processQueue(scopeKey);
         });
         return { child: null, promise: resultPromise };
     }
@@ -1997,15 +2300,23 @@ export function spawnAgent(prompt, opts = {}) {
     if (opencodeSpawnAudit) {
         console.log(`[jaw:opencode:audit] ${JSON.stringify(opencodeSpawnAudit)}`);
     }
-    const child = spawn(spawnCommand, args, {
+    // The snapshot has to predate the child; the helper owns that ordering (073 §2.4).
+    const kiroPlainText = isKiroPlainTextCli(cli, effectiveProvider);
+    const { child, kiroConversationIdsBefore, kiroSpawnStartedAt } = spawnWithKiroSnapshot({
+        kiroPlainText,
+        isFreshMainRun: !isResume && !empSid,
         cwd: spawnCwd,
-        env: spawnEnv,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        ...(windowsSpawnUsesShell ? { shell: true } : {}),
+        spawn: () => spawn(spawnCommand, args, {
+            cwd: spawnCwd,
+            env: spawnEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            ...(windowsSpawnUsesShell ? { shell: true } : {}),
+        }),
     });
     if (mainManaged)
-        activeProcess = child;
-    registerActiveProcess(agentLabel, child);
+        mainRun.process = child;
+    else
+        registerActiveProcess(agentLabel, child);
     if (!opts.internal)
         broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...runtimeStatusMeta, ...empTag });
     if (mainManaged && !opts.internal)
@@ -2050,19 +2361,21 @@ export function spawnAgent(prompt, opts = {}) {
                 ? `CLI '${cli}' 실행 실패 (ENOEXEC). PATH의 실행 파일이 바이너리 또는 shebang 스크립트가 아닙니다. \`jaw doctor --json\`으로 깨진 shim을 확인하세요.`
                 : `CLI '${cli}' 실행 실패: ${err.message}`;
         console.error(`[jaw:${agentLabel}:error] ${msg}`);
-        activeProcesses.delete(agentLabel);
         if (mainManaged) {
-            activeProcess = null;
+            releaseMainRun(scopeKey, child, ownerGeneration);
             clearLiveRun(liveScope);
             broadcast('agent_status', { running: false, agentId: agentLabel });
         }
+        else {
+            activeProcesses.delete(agentLabel);
+        }
         broadcast('agent_done', { text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
         resolve({ text: '', code: 127 });
         if (mainManaged)
-            processQueue();
+            void processQueue(scopeKey);
     });
     if (mainManaged && !opts.internal && !opts._skipInsert) {
-        insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, getActiveChatSession());
+        insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
     }
     if (cli === 'claude') {
         child.stdin.write(isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
@@ -2082,11 +2395,6 @@ export function spawnAgent(prompt, opts = {}) {
     const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
     if (mainManaged && !opts.internal)
         setLiveRunTraceId(liveScope, traceRunId);
-    const kiroPlainText = isKiroPlainTextCli(cli, effectiveProvider);
-    const kiroSpawnStartedAt = kiroPlainText ? Date.now() - 1000 : 0;
-    const kiroConversationIdsBefore = (kiroPlainText && !isResume && !empSid)
-        ? listKiroConversationIdsForCwd(spawnCwd)
-        : null;
     // Native `agy --conversation ... -p` may emit only the current answer.
     // Length-based replay trimming can therefore swallow the whole new answer.
     const agyResumeOffset = 0;
@@ -2468,7 +2776,7 @@ export function spawnAgent(prompt, opts = {}) {
         if (cli === 'agy' && isResume && (agyGuardedStaleDetected || isAgyStaleSessionOutput(ctx.fullText))) {
             console.log(`[jaw:agy] stale session detected (Warning: conversation not found) — clearing bucket`);
             try {
-                const bucket = resolveSessionBucket(cli, runtimeModel, effectiveProvider);
+                const bucket = currentBucket;
                 clearSessionBucket.run(bucket);
             }
             catch (e) {
@@ -2476,9 +2784,10 @@ export function spawnAgent(prompt, opts = {}) {
             }
             ctx.sessionId = null;
             if (agyResumeDecision.ok && !opts._agyStaleFreshRetry) {
-                activeProcesses.delete(agentLabel);
                 if (mainManaged)
-                    activeProcess = null;
+                    releaseMainRun(scopeKey, child, ownerGeneration);
+                else
+                    activeProcesses.delete(agentLabel);
                 const { promise: freshPromise } = spawnAgent(prompt, {
                     ...opts, _agyStaleFreshRetry: true, _skipResume: true, _skipInsert: true,
                 });
@@ -2506,7 +2815,7 @@ export function spawnAgent(prompt, opts = {}) {
             if (isResume && isKiroStaleSessionOutput(ctx.fullText)) {
                 console.log('[jaw:kiro] stale session detected in output — clearing bucket');
                 try {
-                    const bucket = resolveSessionBucket(cli, runtimeModel, effectiveProvider);
+                    const bucket = currentBucket;
                     clearSessionBucket.run(bucket);
                 }
                 catch (e) {
@@ -2651,14 +2960,18 @@ export function spawnAgent(prompt, opts = {}) {
         handleAgentExit({
             ctx, code: effectiveExitCode, cli, model: runtimeModel, effectiveProvider, agentLabel, mainManaged, origin,
             resumeKey,
-            prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+            prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
             isResume, wasKilled, wasSteer, smokeResult,
             effortDefault: cli === 'grok' ? '' : 'medium', costLine,
             resolve: resolve,
             activeProcesses,
-            setActiveProcess: (v) => { activeProcess = v; },
-            retryState: queueCtrl.retryState,
-            fallbackState: queueCtrl.fallbackState,
+            scopeKey,
+            scopedBucket: currentBucket,
+            chatSessionId,
+            childProcess: child,
+            releaseMainRun,
+            retryState: queueCtrl.retryStateForScope(scopeKey),
+            fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
             fallbackMaxRetries: FALLBACK_MAX_RETRIES,
             processQueue,
             ...(agyTotalOutputLen > 0 ? { outputLen: agyTotalOutputLen } : {}),