cli-jaw 2.0.1 → 2.0.2

package/dist/src/agent/spawn.js

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { spawn, execFileSync } from 'child_process';
 import { broadcast } from '../core/bus.js';
 import { settings, UPLOADS_DIR, detectCli, normalizeModelForCli } from '../core/config.js';
+import { stripUndefined } from '../core/strip-undefined.js';
 import { clearEmployeeSession, getSession, insertMessage, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, getSessionBucket, } from '../core/db.js';
 import { getSystemPrompt, regenerateB } from '../prompt/builder.js';
 import { extractSessionId, extractFromEvent, extractFromAcpUpdate, extractOutputChunk, logEventSummary, flushClaudeBuffers } from './events.js';
@@ -23,7 +24,10 @@ import { resolveOrcScope } from '../orchestrator/scope.js';
 import { beginLiveRun, appendLiveRunText, clearLiveRun, replaceLiveRunTools, appendLiveRunTool } from './live-run-state.js';
 import { setSpawnRef as setMemorySpawnRef, } from './memory-flush-controller.js';
 import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPermissions } from './spawn-env.js';
+import { attachWatchdog } from './watchdog.js';
 import { buildOpencodeRuntimeSnapshot, buildOpencodeSpawnAudit, pushOpencodeRawEvent, resolveOpencodeBinary, } from './opencode-diagnostics.js';
+import { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
+import { appendTraceEvent, stampTraceTool, startTraceRun } from '../trace/store.js';
 // ─── State ───────────────────────────────────────────
 export let activeProcess = null;
 export const activeProcesses = new Map(); // agentId → child process
@@ -99,7 +103,7 @@ function normalizeQueueItem(row) {
         if (typeof parsed?.id !== 'string' || typeof parsed?.prompt !== 'string' || typeof parsed?.source !== 'string') {
             return [];
         }
-        return [{
+        return [stripUndefined({
                 id: parsed.id,
                 prompt: parsed.prompt,
                 source: parsed.source,
@@ -108,7 +112,7 @@ function normalizeQueueItem(row) {
                 chatId: parsed.chatId,
                 requestId: parsed.requestId,
                 ts: typeof parsed.ts === 'number' ? parsed.ts : Date.now(),
-            }];
+            })];
     }
     catch {
         return [];
@@ -330,7 +334,7 @@ export async function steerAgent(newPrompt, source) {
     const wasRunning = killActiveAgent('steer');
     if (wasRunning)
         await waitForProcessEnd(3000);
-    insertMessage.run('user', newPrompt, source, '', settings.workingDir || null);
+    insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null);
     broadcast('new_message', { role: 'user', content: newPrompt, source });
     const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
     const origin = source || 'web';
@@ -371,7 +375,7 @@ export function removeQueuedMessage(id) {
     return { removed: removed, pending: messageQueue.length };
 }
 export function enqueueMessage(prompt, source, meta) {
-    const item = {
+    const item = stripUndefined({
         id: crypto.randomUUID(),
         prompt,
         source,
@@ -380,7 +384,7 @@ export function enqueueMessage(prompt, source, meta) {
         chatId: meta?.chatId,
         requestId: meta?.requestId,
         ts: Date.now(),
-    };
+    });
     insertQueuedMessage.run(item.id, JSON.stringify(item));
     messageQueue.push(item);
     console.log(`[queue] +1 (${messageQueue.length} pending)`);
@@ -449,7 +453,7 @@ export async function processQueue() {
     console.log(`[queue] processing 1/${batch.length} message(s) for ${groupKey}, ${messageQueue.length} remaining`);
     let inserted = false;
     try {
-        insertMessage.run('user', combined, source, '', settings.workingDir || null);
+        insertMessage.run('user', combined, source, '', settings["workingDir"] || null);
         deleteQueuedMessage.run(item.id);
         inserted = true;
         // Broadcast WITH fromQueue=true so the web client renders the user bubble
@@ -491,20 +495,20 @@ export async function processQueue() {
 // ─── Helpers ─────────────────────────────────────────
 function makeCleanEnv(extraEnv = {}) {
     const env = { ...process.env };
-    delete env.CLAUDE_CODE_SSE_PORT;
-    delete env.GEMINI_SYSTEM_MD;
+    delete env["CLAUDE_CODE_SSE_PORT"];
+    delete env["GEMINI_SYSTEM_MD"];
     // Phase 8: strip boss-only dispatch token from employee spawns so employees
     // cannot authenticate against /api/orchestrate/dispatch even via localhost.
     // Detect employee spawn by the explicit JAW_EMPLOYEE_MODE flag; main spawns
     // pass an empty extraEnv and keep the token inherited from process.env.
-    if (extraEnv.JAW_EMPLOYEE_MODE === '1') {
-        delete env.JAW_BOSS_TOKEN;
+    if (extraEnv["JAW_EMPLOYEE_MODE"] === '1') {
+        delete env["JAW_BOSS_TOKEN"];
     }
-    env.PATH = buildServicePath(env.PATH || '');
+    env["PATH"] = buildServicePath(env["PATH"] || '');
     return {
         ...env,
         ...extraEnv,
-        PATH: buildServicePath(extraEnv.PATH || env.PATH || ''),
+        PATH: buildServicePath(extraEnv["PATH"] || env["PATH"] || ''),
     };
 }
 function buildHistoryBlock(currentPrompt, workingDir, maxSessions = 10, maxTotalChars = 8000) {
@@ -517,6 +521,8 @@ function buildHistoryBlock(currentPrompt, workingDir, maxSessions = 10, maxTotal
     let charCount = 0;
     for (let i = 0; i < recent.length; i++) {
         const row = recent[i];
+        if (!row)
+            continue;
         const role = String(row.role || '');
         const content = String(row.content || '').trim();
         // Exclude the just-inserted current prompt when caller path stores user text
@@ -562,7 +568,7 @@ function withHistoryPrompt(prompt, historyBlock) {
 import { buildArgs, buildResumeArgs, resolveSessionBucket } from './args.js';
 export { buildArgs, buildResumeArgs, resolveSessionBucket };
 // ─── Upload wrapper ──────────────────────────────────
-export const saveUpload = (buffer, originalName) => _saveUpload(UPLOADS_DIR, buffer, originalName);
+export const saveUpload = (buffer, originalName, options) => _saveUpload(UPLOADS_DIR, Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer), originalName, options);
 export { buildMediaPrompt, buildMediaPromptMany };
 // ─── Spawn Agent ─────────────────────────────────────
 import { AcpClient } from '../cli/acp-client.js';
@@ -599,7 +605,7 @@ export function spawnAgent(prompt, opts = {}) {
     const { forceNew = false, agentId, sysPrompt: customSysPrompt, memorySnapshot } = opts;
     const origin = opts.origin || 'web';
     const empSid = opts.employeeSessionId || null;
-    const mainManaged = !forceNew && !empSid;
+    const mainManaged = !forceNew && !empSid && !opts.internal;
     const gateEligibleMain = mainManaged && !opts.agentId && !opts.internal && !opts._isFallback && !opts._isSmokeContinuation;
     const isEmployee = !mainManaged;
     const empTag = isEmployee ? { isEmployee: true } : {};
@@ -638,7 +644,7 @@ 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({ origin, chatId: opts.chatId, workingDir: settings.workingDir || null });
+    const liveScope = resolveOrcScope(stripUndefined({ origin, chatId: opts.chatId, workingDir: settings["workingDir"] || null }));
     // Employee must not pollute boss's liveRun (see devlog 260423_employee_liverun_contamination)
     const effectiveLiveScope = mainManaged ? liveScope : null;
     // INVARIANT: 모든 외부 호출은 gateway.ts isAgentBusy()를 거침.
@@ -650,17 +656,17 @@ export function spawnAgent(prompt, opts = {}) {
     // 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({
+        setCurrentMainMeta(stripUndefined({
             origin,
             target: opts.target,
             chatId: opts.chatId,
             requestId: opts.requestId,
             scopeId: liveScope,
-        });
+        }));
     }
     let resolve;
     const resultPromise = new Promise(r => { resolve = r; });
-    const session = getSession();
+    const session = getSession() ?? {};
     const ownerGeneration = getSessionOwnershipGeneration();
     let cli = resolveMainCli(opts.cli, settings, session);
     // Phase 52: Bootstrap consumption is moved BELOW the bucket-aware `isResume`
@@ -680,17 +686,20 @@ export function spawnAgent(prompt, opts = {}) {
             }
         }
     }
-    const permissions = opts.permissions || settings.permissions || session.permissions || 'auto';
+    const permissions = opts.permissions || settings["permissions"] || session.permissions || 'auto';
     if (cli === 'opencode') {
         ensureOpencodeAlwaysAllowPermissions();
     }
-    const cfg = settings.perCli?.[cli] || {};
-    const ao = settings.activeOverrides?.[cli] || {};
+    const cfg = settings["perCli"]?.[cli] || {};
+    const ao = settings["activeOverrides"]?.[cli] || {};
     const model = opts.model || ao.model || cfg.model || 'default';
     const effort = opts.effort || ao.effort || cfg.effort || '';
+    const includeDirectories = Array.isArray(cfg.includeDirectories)
+        ? cfg.includeDirectories.filter((dir) => typeof dir === 'string' && dir.trim().length > 0)
+        : [];
     const sysPrompt = customSysPrompt !== undefined
         ? customSysPrompt
-        : getSystemPrompt({ currentPrompt: prompt, forDisk: false, memorySnapshot, activeCli: cli });
+        : getSystemPrompt(stripUndefined({ currentPrompt: prompt, forDisk: false, memorySnapshot, activeCli: cli }));
     // 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.
@@ -738,23 +747,26 @@ export function spawnAgent(prompt, opts = {}) {
         prompt = `${ts}\n${prompt}\n(need history? cli-jaw memory search "<keywords>" in "ENGLISH")`;
     }
     const resumeSessionId = empSid || (isResume ? bucketSessionId : null);
-    const historyBlock = !isResume ? buildHistoryBlock(prompt, settings.workingDir) : '';
+    const historyBlock = !isResume && !opts._skipHistory ? buildHistoryBlock(prompt, settings["workingDir"]) : '';
     const promptForArgs = (cli === 'gemini' || cli === 'opencode')
         ? withHistoryPrompt(prompt, historyBlock)
         : prompt;
     let args;
     if (isResume) {
-        console.log(`[jaw:resume] ${cli} session=${resumeSessionId.slice(0, 12)}...`);
-        args = buildResumeArgs(cli, model, effort, resumeSessionId, prompt, permissions, { fastMode: cfg.fastMode, sysPrompt });
+        const sid = resumeSessionId || '';
+        console.log(`[jaw:resume] ${cli} session=${sid.slice(0, 12)}...`);
+        args = buildResumeArgs(cli, model, effort, sid, prompt, permissions, { fastMode: cfg.fastMode, sysPrompt, includeDirectories });
     }
     else {
-        args = buildArgs(cli, model, effort, promptForArgs, sysPrompt, permissions, { fastMode: cfg.fastMode });
+        args = buildArgs(cli, model, effort, promptForArgs, sysPrompt, permissions, { fastMode: cfg.fastMode, includeDirectories });
     }
     const agentLabel = agentId || 'main';
+    const traceAudience = (opts.internal || isEmployee) ? 'internal' : 'public';
+    const parentLiveScopeForChild = !opts.internal && isEmployee ? liveScope : null;
     // ─── Universal employee isolation ────────────────────
     // All CLIs auto-read AGENTS.md/CLAUDE.md/GEMINI.md from cwd.
     // Employees must NOT see the Boss's instruction files.
-    let spawnCwd = settings.workingDir;
+    let spawnCwd = settings["workingDir"];
     if (opts.agentId && (customSysPrompt || sysPrompt)) {
         const empPrompt = customSysPrompt || sysPrompt;
         const empPromptWithWorkspace = opts.workspaceContext
@@ -769,7 +781,7 @@ export function spawnAgent(prompt, opts = {}) {
         fs.mkdirSync(dotClaudeDir, { recursive: true });
         fs.writeFileSync(join(dotClaudeDir, 'CLAUDE.md'), empPromptWithWorkspace);
         try {
-            fs.symlinkSync(settings.workingDir, join(tmpDir, 'workspace'), 'dir');
+            fs.symlinkSync(settings["workingDir"], join(tmpDir, 'workspace'), 'dir');
         }
         catch {
             // Non-fatal: the absolute Project root in Workspace Context remains authoritative.
@@ -794,7 +806,7 @@ export function spawnAgent(prompt, opts = {}) {
         resolve({ text: '', code: 127 });
         if (mainManaged)
             processQueue();
-        cleanupEmployeeTmpDir(spawnCwd, settings.workingDir, agentLabel);
+        cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
         return { child: null, promise: resultPromise };
     }
     if (cli === 'copilot') {
@@ -806,7 +818,7 @@ export function spawnAgent(prompt, opts = {}) {
     if (cli === 'gemini' && sysPrompt) {
         const tmpSysFile = join(os.tmpdir(), `jaw-gemini-sys-${agentLabel}.md`);
         fs.writeFileSync(tmpSysFile, sysPrompt);
-        spawnEnv.GEMINI_SYSTEM_MD = tmpSysFile;
+        spawnEnv["GEMINI_SYSTEM_MD"] = tmpSysFile;
     }
     // ─── Copilot ACP branch ──────────────────────
     if (cli === 'copilot') {
@@ -842,6 +854,9 @@ export function spawnAgent(prompt, opts = {}) {
         const acp = new AcpClient({ model, workDir: spawnCwd, permissions, env: spawnEnv });
         acp.spawn();
         const child = acp.proc;
+        if (!child) {
+            throw new Error('Copilot ACP process was not created');
+        }
         if (mainManaged)
             activeProcess = child;
         // Phase 7-3: detect duplicate spawn for same agentLabel. claimWorker guards
@@ -850,8 +865,9 @@ export function spawnAgent(prompt, opts = {}) {
             console.warn(`[spawn:dup] activeProcesses already has child for ${agentLabel} — orphaning previous reference`);
         }
         activeProcesses.set(agentLabel, child);
-        broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
-        if (mainManaged)
+        if (!opts.internal)
+            broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
+        if (mainManaged && !opts.internal)
             beginLiveRun(liveScope, cli);
         // ─── DIFF-C: ACP error guard — prevent uncaught EventEmitter crash ───
         let acpSettled = false; // guard: error→exit can fire sequentially
@@ -859,7 +875,7 @@ export function spawnAgent(prompt, opts = {}) {
             if (acpSettled)
                 return;
             acpSettled = true;
-            cleanupEmployeeTmpDir(spawnCwd, settings.workingDir, agentLabel);
+            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
             opts.lifecycle?.onExit?.(null);
             const msg = `Copilot ACP spawn failed: ${err.message}`;
             console.error(`[acp:error] ${msg}`);
@@ -875,16 +891,20 @@ export function spawnAgent(prompt, opts = {}) {
                 processQueue();
         });
         if (mainManaged && !opts.internal && !opts._skipInsert) {
-            insertMessage.run('user', prompt, cli, model, settings.workingDir || null);
+            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null);
         }
-        broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag });
+        if (!opts.internal)
+            broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
+        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
         const ctx = {
             fullText: '', traceLog: [], toolLog: [], seenToolKeys: new Set(),
             hasClaudeStreamEvents: false, sessionId: null, cost: null,
             turns: null, duration: null, tokens: null, stderrBuf: '',
             thinkingBuf: '',
             liveScope: effectiveLiveScope,
-            parentLiveScope: isEmployee ? liveScope : null,
+            parentLiveScope: parentLiveScopeForChild,
+            traceRunId,
+            traceAudience,
         };
         // Flush accumulated 💭 thinking buffer as a single merged event
         function flushThinking() {
@@ -896,12 +916,13 @@ export function spawnAgent(prompt, opts = {}) {
                 const label = singleLine.length > 120 ? `${singleLine.slice(0, 119)}…` : singleLine;
                 console.log(`  💭 ${label}`);
                 const tool = { icon: '💭', label, toolType: 'thinking', detail: merged };
+                stampTraceTool(tool, ctx, 'thinking');
                 ctx.toolLog.push(tool);
                 if (ctx.liveScope)
                     replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
                 if (ctx.parentLiveScope)
                     appendLiveRunTool(ctx.parentLiveScope, { ...tool, isEmployee: true });
-                broadcast('agent_tool', { agentId: agentLabel, ...tool, ...empTag });
+                broadcast('agent_tool', { agentId: agentLabel, ...tool, ...empTag }, traceAudience);
             }
             ctx.thinkingBuf = '';
         }
@@ -912,6 +933,8 @@ export function spawnAgent(prompt, opts = {}) {
         acp.on('session/update', (params) => {
             if (replayMode)
                 return; // 리플레이 중 모든 이벤트 무시
+            const update = asCliEventRecord(asCliEventRecord(params)["update"]);
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: fieldString(update.sessionUpdate, 'session/update'), raw: params });
             const parsed = extractFromAcpUpdate(params, ctx);
             if (!parsed)
                 return;
@@ -928,12 +951,13 @@ export function spawnAgent(prompt, opts = {}) {
                 const key = `${parsedTool.icon}:${parsedTool.label}:${parsedTool.stepRef || ''}:${parsedTool.status || ''}`;
                 if (!ctx.seenToolKeys.has(key)) {
                     ctx.seenToolKeys.add(key);
+                    stampTraceTool(parsedTool, ctx, parsedTool.toolType || 'tool');
                     ctx.toolLog.push(parsedTool);
                     if (ctx.liveScope)
                         replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
                     if (ctx.parentLiveScope)
                         appendLiveRunTool(ctx.parentLiveScope, { ...parsedTool, isEmployee: true });
-                    broadcast('agent_tool', { agentId: agentLabel, ...parsedTool, ...empTag });
+                    broadcast('agent_tool', { agentId: agentLabel, ...parsedTool, ...empTag }, traceAudience);
                     // Reset heartbeat gate on actually visible broadcast (not 💭)
                     lastVisibleBroadcastTs = Date.now();
                     heartbeatSent = false;
@@ -950,34 +974,39 @@ export function spawnAgent(prompt, opts = {}) {
         });
         // [P2-3.14] session/cancelled → route through extractFromAcpUpdate for UI notification
         acp.on('session/cancelled', (params) => {
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: 'session/cancelled', raw: params });
             const parsed = extractFromAcpUpdate({
                 update: { sessionUpdate: 'session_cancelled', ...(params || {}) },
             });
             if (parsed?.tool) {
+                stampTraceTool(parsed.tool, ctx, parsed.tool.toolType || 'tool');
                 ctx.toolLog.push(parsed.tool);
                 if (ctx.liveScope)
                     replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
                 if (ctx.parentLiveScope)
                     appendLiveRunTool(ctx.parentLiveScope, { ...parsed.tool, isEmployee: true });
-                broadcast('agent_tool', { agentId: agentLabel, ...parsed.tool, ...empTag });
+                broadcast('agent_tool', { agentId: agentLabel, ...parsed.tool, ...empTag }, traceAudience);
             }
         });
         // [P2-3.15] session/request_permission → audit record in toolLog
         acp.on('session/request_permission', (params) => {
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: 'session/request_permission', raw: params });
             const parsed = extractFromAcpUpdate({
                 update: { sessionUpdate: 'request_permission', ...(params || {}) },
             });
             if (parsed?.tool) {
+                stampTraceTool(parsed.tool, ctx, parsed.tool.toolType || 'tool');
                 ctx.toolLog.push(parsed.tool);
                 if (ctx.liveScope)
                     replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
                 if (ctx.parentLiveScope)
                     appendLiveRunTool(ctx.parentLiveScope, { ...parsed.tool, isEmployee: true });
-                broadcast('agent_tool', { agentId: agentLabel, ...parsed.tool, ...empTag });
+                broadcast('agent_tool', { agentId: agentLabel, ...parsed.tool, ...empTag }, traceAudience);
             }
         });
         // stderr_activity → stderrBuf accumulation + conditional heartbeat
         acp.on('stderr_activity', (text) => {
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'stderr', eventType: 'stderr_activity', raw: text });
             // Accumulate stderr for diagnostics (capped)
             if (ctx.stderrBuf.length < 4000) {
                 ctx.stderrBuf += text + '\n';
@@ -993,7 +1022,7 @@ export function spawnAgent(prompt, opts = {}) {
                     icon: '⏳',
                     label: 'working... (no visible progress)',
                     ...empTag,
-                });
+                }, traceAudience);
             }
         });
         // Run ACP flow
@@ -1001,7 +1030,7 @@ export function spawnAgent(prompt, opts = {}) {
         (async () => {
             try {
                 const initResult = await acp.initialize();
-                if (process.env.DEBUG)
+                if (process.env["DEBUG"])
                     console.log('[acp:init]', JSON.stringify(initResult).slice(0, 200));
                 replayMode = true; // Phase 17.2: mute during session load
                 let loadSessionOk = false;
@@ -1030,23 +1059,23 @@ export function spawnAgent(prompt, opts = {}) {
                 ctx.toolLog = [];
                 ctx.seenToolKeys.clear();
                 ctx.thinkingBuf = ''; // Phase 17.2: clear replay thinking too
-                if (mainManaged)
+                if (mainManaged && !opts.internal)
                     beginLiveRun(liveScope, cli);
                 // If loadSession failed (or not resuming), inject history into prompt
                 const needsHistoryFallback = isResume && !loadSessionOk;
-                const fallbackHistory = needsHistoryFallback ? buildHistoryBlock(prompt, settings.workingDir) : '';
+                const fallbackHistory = needsHistoryFallback && !opts._skipHistory ? buildHistoryBlock(prompt, settings["workingDir"]) : '';
                 const acpPrompt = needsHistoryFallback
                     ? withHistoryPrompt(prompt, fallbackHistory)
                     : (isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
                 const { promise: promptPromise } = acp.prompt(acpPrompt);
                 const promptResult = await promptPromise;
                 promptCompleted = true;
-                if (process.env.DEBUG)
+                if (process.env["DEBUG"])
                     console.log('[acp:prompt:result]', JSON.stringify(promptResult).slice(0, 200));
                 // Save session BEFORE shutdown — acp.shutdown() causes SIGTERM (code=null),
                 // which skips the exit handler's code===0 gate, losing session continuity.
                 const persistedAcpSessionId = ctx.sessionId;
-                if (persistedAcpSessionId && persistMainSession({
+                if (persistedAcpSessionId && persistMainSession(stripUndefined({
                     ownerGeneration,
                     forceNew,
                     employeeSessionId: empSid,
@@ -1056,7 +1085,7 @@ export function spawnAgent(prompt, opts = {}) {
                     model,
                     resumeKey,
                     effort: cfg.effort || '',
-                })) {
+                }))) {
                     console.log(`[jaw:session] saved ${cli} session=${persistedAcpSessionId.slice(0, 12)}... (pre-shutdown)`);
                 }
                 await acp.shutdown();
@@ -1071,7 +1100,7 @@ export function spawnAgent(prompt, opts = {}) {
             if (acpSettled)
                 return; // error handler already resolved
             acpSettled = true;
-            cleanupEmployeeTmpDir(spawnCwd, settings.workingDir, agentLabel);
+            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
             opts.lifecycle?.onExit?.(code ?? null);
             // [I2] Consume per-process kill reason
             const acpKillReason = consumeKillReason(acp.proc?.pid);
@@ -1139,8 +1168,9 @@ export function spawnAgent(prompt, opts = {}) {
         console.warn(`[spawn:dup] activeProcesses already has child for ${agentLabel} — orphaning previous reference`);
     }
     activeProcesses.set(agentLabel, child);
-    broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
-    if (mainManaged)
+    if (!opts.internal)
+        broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
+    if (mainManaged && !opts.internal)
         beginLiveRun(liveScope, cli);
     // ─── DIFF-A: error guard — prevent uncaught ENOENT crash ───
     let stdSettled = false; // guard: error→close can fire sequentially
@@ -1157,7 +1187,7 @@ export function spawnAgent(prompt, opts = {}) {
         if (stdSettled)
             return;
         stdSettled = true;
-        cleanupEmployeeTmpDir(spawnCwd, settings.workingDir, agentLabel);
+        cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
         opts.lifecycle?.onExit?.(null);
         const msg = err.code === 'ENOENT'
             ? `CLI '${cli}' 실행 실패 (ENOENT). 설치/경로를 확인하세요.`
@@ -1175,7 +1205,7 @@ export function spawnAgent(prompt, opts = {}) {
             processQueue();
     });
     if (mainManaged && !opts.internal && !opts._skipInsert) {
-        insertMessage.run('user', prompt, cli, model, settings.workingDir || null);
+        insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null);
     }
     if (cli === 'claude') {
         child.stdin.write(withHistoryPrompt(prompt, historyBlock));
@@ -1187,7 +1217,9 @@ export function spawnAgent(prompt, opts = {}) {
         child.stdin.write(codexStdin);
     }
     child.stdin.end();
-    broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag });
+    if (!opts.internal)
+        broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
+    const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
     const ctx = {
         fullText: '',
         traceLog: [],
@@ -1201,14 +1233,41 @@ export function spawnAgent(prompt, opts = {}) {
         tokens: null,
         stderrBuf: '',
         hasActiveSubAgent: false,
-        showReasoning: settings.showReasoning === true,
+        showReasoning: settings["showReasoning"] === true,
         outputTextStarted: false,
         liveScope: effectiveLiveScope,
-        parentLiveScope: isEmployee ? liveScope : null,
+        parentLiveScope: parentLiveScopeForChild,
+        traceRunId,
+        traceAudience,
         geminiResultSeen: false,
-        opencodeSpawnAudit: opencodeSpawnAudit,
+        ...(opencodeSpawnAudit ? { opencodeSpawnAudit: opencodeSpawnAudit } : {}),
     };
     let geminiWatchdog = null;
+    // ─── Subprocess stall watchdog (Phase 1: #178 OAuth2 stall recovery) ───
+    const rawAgentTimeoutCfg = settings["agentTimeout"];
+    const agentTimeoutCfg = rawAgentTimeoutCfg && typeof rawAgentTimeoutCfg === 'object'
+        ? rawAgentTimeoutCfg
+        : {};
+    const watchdogConfig = {};
+    if (typeof agentTimeoutCfg['firstProgressMs'] === 'number')
+        watchdogConfig.firstProgressMs = agentTimeoutCfg['firstProgressMs'];
+    if (typeof agentTimeoutCfg['idleMs'] === 'number')
+        watchdogConfig.idleMs = agentTimeoutCfg['idleMs'];
+    if (typeof agentTimeoutCfg['absoluteMs'] === 'number')
+        watchdogConfig.absoluteMs = agentTimeoutCfg['absoluteMs'];
+    const stallWatchdog = attachWatchdog(child, agentLabel, (reason) => {
+        console.log(`[jaw:watchdog] killing ${agentLabel} — ${reason}`);
+        ctx.stallReason = reason;
+        if (child.pid) {
+            killProcessTree(child.pid, 'SIGTERM');
+            setTimeout(() => {
+                try {
+                    killProcessTree(child.pid, 'SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 5_000);
+        }
+    }, watchdogConfig);
     let buffer = '';
     const recordOpencodeEvent = (line, event) => {
         if (cli !== 'opencode')
@@ -1217,6 +1276,62 @@ export function spawnAgent(prompt, opts = {}) {
         ctx.opencodeLastEventType = typeof event?.type === 'string' ? event.type : 'unknown';
         ctx.opencodeLastEventAt = Date.now();
     };
+    const dispatchNdjsonLine = (line) => {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'cli_raw', eventType: 'malformed_json', raw: line });
+            return;
+        }
+        appendTraceEvent({
+            runId: ctx.traceRunId,
+            source: 'cli_raw',
+            eventType: fieldString(asCliEventRecord(raw).type, '<no-type>'),
+            raw,
+        });
+        const event = discriminate(cli, raw);
+        if (!event) {
+            const type = fieldString(asCliEventRecord(raw).type, '<no-type>');
+            ctx.traceLog.push(`[cli:unknown-event] cli=${cli} type=${type} preview=${JSON.stringify(raw).slice(0, 200)}`);
+            return;
+        }
+        recordOpencodeEvent(line, event);
+        if (process.env["DEBUG"]) {
+            console.log(`[jaw:event:${agentLabel}] ${cli} type=${event.type}`);
+            console.log(`[jaw:raw:${agentLabel}] ${line.slice(0, 300)}`);
+        }
+        logEventSummary(agentLabel, cli, event, ctx);
+        if (!ctx.sessionId)
+            ctx.sessionId = extractSessionId(cli, event);
+        extractFromEvent(cli, event, ctx, agentLabel, empTag);
+        // Gemini watchdog: AFTER extractFromEvent sets geminiResultSeen
+        if (cli === 'gemini' && ctx.geminiResultSeen && !geminiWatchdog) {
+            geminiWatchdog = setTimeout(() => {
+                console.warn(`[jaw:gemini-watchdog] ${agentLabel} — result seen but close not received after 10s, killing`);
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch { /* already dead */ }
+            }, 10000);
+        }
+        // Sub-agent wait: keep stall timer alive
+        if (ctx.hasActiveSubAgent) {
+            opts.lifecycle?.onActivity?.('heartbeat');
+        }
+        const outputChunk = extractOutputChunk(cli, event, ctx);
+        if (outputChunk) {
+            if (ctx.liveScope)
+                appendLiveRunText(ctx.liveScope, outputChunk);
+            broadcast('agent_output', {
+                agentId: agentLabel,
+                cli,
+                text: outputChunk,
+                ...empTag,
+            }, (opts.internal || isEmployee) ? 'internal' : 'public');
+        }
+    };
     if (cli === 'opencode') {
         opencodeIdleTimer = setInterval(() => {
             const idleMs = Date.now() - lastOpencodeIoAt;
@@ -1237,55 +1352,20 @@ export function spawnAgent(prompt, opts = {}) {
         for (const line of lines) {
             if (!line.trim())
                 continue;
-            try {
-                const event = JSON.parse(line);
-                recordOpencodeEvent(line, event);
-                if (process.env.DEBUG) {
-                    console.log(`[jaw:event:${agentLabel}] ${cli} type=${event.type}`);
-                    console.log(`[jaw:raw:${agentLabel}] ${line.slice(0, 300)}`);
-                }
-                logEventSummary(agentLabel, cli, event, ctx);
-                if (!ctx.sessionId)
-                    ctx.sessionId = extractSessionId(cli, event);
-                extractFromEvent(cli, event, ctx, agentLabel, empTag);
-                // Gemini watchdog: AFTER extractFromEvent sets geminiResultSeen
-                if (cli === 'gemini' && ctx.geminiResultSeen && !geminiWatchdog) {
-                    geminiWatchdog = setTimeout(() => {
-                        console.warn(`[jaw:gemini-watchdog] ${agentLabel} — result seen but close not received after 10s, killing`);
-                        try {
-                            child.kill('SIGTERM');
-                        }
-                        catch { /* already dead */ }
-                    }, 10000);
-                }
-                // Sub-agent wait: keep stall timer alive
-                if (ctx.hasActiveSubAgent) {
-                    opts.lifecycle?.onActivity?.('heartbeat');
-                }
-                const outputChunk = extractOutputChunk(cli, event, ctx);
-                if (outputChunk) {
-                    if (ctx.liveScope)
-                        appendLiveRunText(ctx.liveScope, outputChunk);
-                    broadcast('agent_output', {
-                        agentId: agentLabel,
-                        cli,
-                        text: outputChunk,
-                        ...empTag,
-                    }, isEmployee ? 'internal' : 'public');
-                }
-            }
-            catch { /* non-JSON line */ }
+            dispatchNdjsonLine(line);
         }
     });
     child.stderr.on('data', (chunk) => {
         opts.lifecycle?.onActivity?.('stderr');
         lastOpencodeIoAt = Date.now();
         const text = chunk.toString().trim();
+        appendTraceEvent({ runId: ctx.traceRunId, source: 'stderr', eventType: 'stderr', raw: text });
         console.error(`[jaw:stderr:${agentLabel}] ${text}`);
         ctx.stderrBuf += text + '\n';
     });
     child.on('close', (code) => {
         clearOpencodeIdleTimer();
+        stallWatchdog.stop();
         if (geminiWatchdog) {
             clearTimeout(geminiWatchdog);
             geminiWatchdog = null;
@@ -1294,25 +1374,11 @@ export function spawnAgent(prompt, opts = {}) {
             return; // error handler already resolved
         // [I1] Flush residual NDJSON buffer — last event may lack trailing newline
         if (buffer.trim()) {
-            try {
-                const lastEvent = JSON.parse(buffer);
-                recordOpencodeEvent(buffer, lastEvent);
-                logEventSummary(agentLabel, cli, lastEvent, ctx);
-                if (!ctx.sessionId)
-                    ctx.sessionId = extractSessionId(cli, lastEvent);
-                extractFromEvent(cli, lastEvent, ctx, agentLabel, empTag);
-                const outputChunk = extractOutputChunk(cli, lastEvent, ctx);
-                if (outputChunk) {
-                    if (ctx.liveScope)
-                        appendLiveRunText(ctx.liveScope, outputChunk);
-                    broadcast('agent_output', { agentId: agentLabel, cli, text: outputChunk, ...empTag }, isEmployee ? 'internal' : 'public');
-                }
-            }
-            catch { /* incomplete JSON — discard */ }
+            dispatchNdjsonLine(buffer);
             buffer = '';
         }
         flushClaudeBuffers(ctx, agentLabel, empTag); // flush any pending thinking/input buffers
-        cleanupEmployeeTmpDir(spawnCwd, settings.workingDir, agentLabel);
+        cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
         opts.lifecycle?.onExit?.(code ?? null);
         // [I2] Consume per-process kill reason
         const stdKillReason = consumeKillReason(child.pid);