farming-code 2.2.8 → 2.2.11

package/backend/acp-session-state.js

@@ -1,5 +1,23 @@
+const fsp = require('fs/promises');
+const path = require('path');
+const { fileURLToPath } = require('url');
+
 const MAX_ACP_UPDATES = 2_000;
 const MAX_ACP_UPDATE_LOG_VALUE_CHARS = 32 * 1024;
+const MAX_CODEX_HISTORY_IMAGES_PER_MESSAGE = 6;
+const MAX_CODEX_HISTORY_IMAGE_BYTES = 5 * 1024 * 1024;
+const CODEX_HISTORY_IMAGE_MIME_BY_EXT = Object.freeze({
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+});
+const {
+  codexHistoryImageTargets,
+  visibleUserMessageText,
+} = require('./codex-transcript');
 const {
   isCodexInjectedContextMessage,
   stripCodexInternalContextBlocks,
@@ -44,14 +62,78 @@ function contentText(content) {
     .join('');
 }
 
+function localPathFromHistoryImageTarget(value) {
+  const target = String(value || '').trim();
+  if (!target || target.includes('\0') || /^data:/i.test(target)) return '';
+  if (/^file:\/\//i.test(target)) {
+    try {
+      return fileURLToPath(target);
+    } catch {
+      return '';
+    }
+  }
+  return path.isAbsolute(target) ? target : '';
+}
+
+function imageBlockFromDataUrl(value) {
+  const match = String(value || '').match(/^data:(image\/(?:gif|jpe?g|png|svg\+xml|webp));base64,([a-z0-9+/=]+)$/i);
+  if (!match) return null;
+  const data = match[2];
+  if (!data || Math.ceil(data.length * 3 / 4) > MAX_CODEX_HISTORY_IMAGE_BYTES) return null;
+  return { type: 'image', mimeType: match[1].toLowerCase(), data };
+}
+
+async function imageBlockFromLocalPath(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = CODEX_HISTORY_IMAGE_MIME_BY_EXT[ext];
+  if (!mimeType) return null;
+  try {
+    const stat = await fsp.stat(filePath);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_CODEX_HISTORY_IMAGE_BYTES) return null;
+    return { type: 'image', mimeType, data: (await fsp.readFile(filePath)).toString('base64') };
+  } catch {
+    return null;
+  }
+}
+
 function isContextCompactionText(content) {
-  return /^\*?Context compacted(?: to fit the model's context window)?\.?\*?$/i.test(contentText(content).trim());
+  const text = contentText(content).trim();
+  return /^\*?Context compacted(?: to fit the model's context window)?\.?\*?$/i.test(text)
+    || /^(?:#{1,3}\s*)?Handoff Summary(?:[ \t]*:|[ \t]*(?:\r?\n|$))/i.test(text)
+    || /^Another language model started to solve this problem and produced a summary\b/i.test(text);
 }
 
 function canMergeMessageIds(existing, incoming) {
   return !existing || !incoming || existing === incoming;
 }
 
+function codexMessagePhase(meta) {
+  return String(meta?.codex?.phase || '');
+}
+
+function canMergeMessageChunks(existing, update) {
+  if (!canMergeMessageIds(existing?.messageId, String(update?.messageId || ''))) return false;
+  // Codex ACP history can omit message ids while still preserving the original
+  // commentary/final-answer boundary in metadata. Never merge across that
+  // boundary or the frontend loses the only authoritative answer signal.
+  return codexMessagePhase(existing?._meta) === codexMessagePhase(update?._meta);
+}
+
+function isCodexMirroredAssistantMessage(provider, existing, update, role, type) {
+  if (provider !== 'codex' || role !== 'assistant' || type !== 'message') return false;
+  if (!existing || existing.type !== type || existing.role !== role) return false;
+  if (codexMessagePhase(existing._meta) !== codexMessagePhase(update?._meta)) return false;
+  const existingId = String(existing.messageId || '');
+  const incomingId = String(update?.messageId || '');
+  // The App Server thread item has an id while the JSONL response-item
+  // fallback does not. If both have ids, keep them as distinct protocol
+  // messages even when their visible text happens to match.
+  if (existingId && incomingId) return false;
+  const existingText = stripCodexInternalContextBlocks(contentText(existing.content));
+  const incomingText = stripCodexInternalContextBlocks(contentText([update?.content]));
+  return Boolean(existingText) && existingText === incomingText;
+}
+
 class AcpSessionState {
   constructor(options = {}) {
     this.provider = String(options.provider || '');
@@ -89,6 +171,41 @@ class AcpSessionState {
     this.sessionId = String(sessionId || this.sessionId);
   }
 
+  static fromCheckpoint(checkpoint, options = {}) {
+    if (!checkpoint || checkpoint.version !== 1 || !Array.isArray(checkpoint.entries)) return null;
+    const state = new AcpSessionState({
+      provider: options.provider || checkpoint.provider,
+      sessionId: options.sessionId || checkpoint.sessionId,
+      cwd: options.cwd || checkpoint.cwd,
+      maxUpdates: options.maxUpdates,
+      revisionBase: checkpoint.revision,
+      resetBeforeRevision: checkpoint.resetBeforeRevision,
+    });
+    state.entries = clone(checkpoint.entries);
+    state.toolEntries.clear();
+    state.compactionEntries.clear();
+    let maximumRevision = 0;
+    for (const entry of state.entries) {
+      maximumRevision = Math.max(maximumRevision, Number(entry?._revision || 0));
+      if (entry?.type === 'tool' && entry.id) state.toolEntries.set(String(entry.id), entry);
+      if (entry?.type === 'compaction' && entry.id) state.compactionEntries.set(String(entry.id), entry);
+    }
+    state.revision = Math.max(state.revision, maximumRevision);
+    state.sequence = Math.max(0, Math.floor(Number(checkpoint.sequence || 0)));
+    state.activePlanEntry = checkpoint.activePlanEntryId
+      ? state.entries.find(entry => entry?.id === checkpoint.activePlanEntryId) || null
+      : null;
+    state.plan = clone(checkpoint.plan ?? state.activePlanEntry?.plan ?? null);
+    state.usage = clone(checkpoint.usage ?? null);
+    state.availableCommands = clone(checkpoint.availableCommands || []);
+    state.currentModeId = String(checkpoint.currentModeId || '');
+    state.configOptions = clone(checkpoint.configOptions || []);
+    state.title = String(checkpoint.title || '');
+    state.updatedAt = String(checkpoint.updatedAt || '');
+    state.truncated = checkpoint.truncated === true;
+    return state;
+  }
+
   nextEntryId(prefix) {
     return `${prefix}-${++this.sequence}`;
   }
@@ -165,6 +282,44 @@ class AcpSessionState {
     // History replay uses the same reducer as live updates; nothing to close.
   }
 
+  hasCodexHistoryImageReferences() {
+    return this.provider === 'codex' && this.entries.some(entry => (
+      entry?.type === 'message'
+      && entry.role === 'user'
+      && codexHistoryImageTargets(contentText(entry.content)).length > 0
+    ));
+  }
+
+  async hydrateCodexHistoryAttachments(options = {}) {
+    if (this.provider !== 'codex') return 0;
+    const imageDataByPath = options.imageDataByPath instanceof Map ? options.imageDataByPath : new Map();
+    let hydrated = 0;
+    for (const entry of this.entries) {
+      if (entry?.type !== 'message' || entry.role !== 'user') continue;
+      const existingImages = (entry.content || []).filter(content => content?.type === 'image');
+      const remaining = MAX_CODEX_HISTORY_IMAGES_PER_MESSAGE - existingImages.length;
+      if (remaining <= 0) continue;
+      const targets = codexHistoryImageTargets(contentText(entry.content));
+      const seenPaths = new Set();
+      const blocks = [];
+      for (const target of targets) {
+        const filePath = localPathFromHistoryImageTarget(target);
+        if (!filePath || seenPaths.has(filePath)) continue;
+        seenPaths.add(filePath);
+        const fallback = imageDataByPath.get(filePath);
+        const block = await imageBlockFromLocalPath(filePath) || imageBlockFromDataUrl(fallback);
+        if (!block) continue;
+        blocks.push(block);
+        if (blocks.length >= remaining) break;
+      }
+      if (blocks.length === 0) continue;
+      entry.content.push(...blocks);
+      this.touchEntry(entry);
+      hydrated += blocks.length;
+    }
+    return hydrated;
+  }
+
   apply(notification) {
     if (!notification || notification.sessionId !== this.sessionId) return false;
     const update = notification.update;
@@ -243,9 +398,15 @@ class AcpSessionState {
     if (
       last?.type === type
       && last.role === role
-      && canMergeMessageIds(last.messageId, messageId)
+      && canMergeMessageChunks(last, update)
     ) {
+      const mirroredAssistantMessage = isCodexMirroredAssistantMessage(this.provider, last, update, role, type);
       if (!last.messageId) last.messageId = messageId;
+      if (!last._meta && update._meta) last._meta = clone(update._meta);
+      if (mirroredAssistantMessage) {
+        this.touchEntry(last);
+        return;
+      }
       appendContent(last.content, update.content);
       this.touchEntry(last);
       return;
@@ -258,6 +419,7 @@ class AcpSessionState {
       role,
       messageId,
       content: [],
+      ...(update._meta ? { _meta: clone(update._meta) } : {}),
     });
     appendContent(this.entries[this.entries.length - 1].content, update.content);
   }
@@ -326,9 +488,10 @@ class AcpSessionState {
       ? Math.max(1, Math.floor(Number(options.maxTurns)))
       : 80;
     const requestedRevision = Number(options.sinceRevision);
-    const resetRequired = this.resetBeforeRevision > 0
-      && Number.isFinite(requestedRevision)
-      && requestedRevision <= this.resetBeforeRevision;
+    const resetRequired = Number.isFinite(requestedRevision) && (
+      requestedRevision > this.revision
+      || (this.resetBeforeRevision > 0 && requestedRevision <= this.resetBeforeRevision)
+    );
     const delta = Number.isFinite(requestedRevision) && requestedRevision >= 0 && !resetRequired;
     let startIndex = 0;
 
@@ -397,8 +560,19 @@ class AcpSessionState {
       }
       entry.internal = internalSegment;
       if (!['message', 'thought'].includes(entry.type)) continue;
+      const renderedAttachmentKinds = [];
+      if (
+        entry.type === 'message'
+        && entry.role === 'user'
+        && ((entry.content || []).some(content => content?.type === 'image') || codexHistoryImageTargets(contentText(entry.content)).length > 0)
+      ) {
+        renderedAttachmentKinds.push('image');
+      }
       for (const content of entry.content || []) {
-        if (content.type === 'text') content.text = stripCodexInternalContextBlocks(content.text);
+        if (content.type !== 'text') continue;
+        content.text = entry.type === 'message' && entry.role === 'user' && entry.internal !== true
+          ? visibleUserMessageText(content.text, { renderedAttachmentKinds })
+          : stripCodexInternalContextBlocks(content.text);
       }
     }
     return entries;
@@ -439,6 +613,28 @@ class AcpSessionState {
     if (options.includeUpdates === true) snapshot.updates = clone(this.updates);
     return snapshot;
   }
+
+  exportCheckpoint() {
+    return {
+      version: 1,
+      provider: this.provider,
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      sequence: this.sequence,
+      revision: this.revision,
+      resetBeforeRevision: this.resetBeforeRevision,
+      entries: clone(this.entries),
+      activePlanEntryId: this.activePlanEntry?.id || '',
+      plan: clone(this.plan),
+      usage: clone(this.usage),
+      availableCommands: clone(this.availableCommands),
+      currentModeId: this.currentModeId,
+      configOptions: clone(this.configOptions),
+      title: this.title,
+      updatedAt: this.updatedAt,
+      truncated: this.truncated,
+    };
+  }
 }
 
 module.exports = {

package/backend/acp-transcript.js

@@ -1,6 +1,8 @@
 const { createTwoFilesPatch, diffLines } = require('diff');
 
 const MAX_RENDERED_DIFF_CHARS = 64 * 1024;
+const MAX_INLINE_TOOL_DETAIL_CHARS = 4 * 1024;
+const MAX_EMBEDDED_RESOURCE_TEXT_CHARS = 4 * 1024;
 
 function diffBlocks(content) {
   return (Array.isArray(content) ? content : [])
@@ -162,8 +164,118 @@ function detailForTool(entry) {
   return sections.join('\n\n');
 }
 
+function transcriptResource(resourceValue) {
+  const resource = resourceValue && typeof resourceValue === 'object' ? resourceValue : {};
+  const text = typeof resource.text === 'string' ? resource.text : '';
+  return {
+    name: resource.name,
+    uri: resource.uri,
+    mimeType: resource.mimeType,
+    ...(text
+      ? {
+          text: text.slice(0, MAX_EMBEDDED_RESOURCE_TEXT_CHARS),
+          ...(text.length > MAX_EMBEDDED_RESOURCE_TEXT_CHARS ? { textTruncated: true } : {}),
+        }
+      : {}),
+  };
+}
+
+function transcriptMediaBlocks(entry) {
+  const direct = Array.isArray(entry?.content) ? entry.content : [];
+  const output = entry?.rawOutput && typeof entry.rawOutput === 'object' ? entry.rawOutput : {};
+  const result = output?.result && typeof output.result === 'object' ? output.result : {};
+  const raw = Array.isArray(result.content)
+    ? result.content
+    : (Array.isArray(output.content) ? output.content : []);
+  const blocks = [...direct, ...raw].flatMap(block => {
+    if (!block || typeof block !== 'object') return [];
+    if (block.type === 'terminal') return [{ type: 'terminal', terminalId: String(block.terminalId || '') }];
+    if (['image', 'audio', 'resource_link'].includes(block.type)) return [JSON.parse(JSON.stringify(block))];
+    if (block.type === 'resource') {
+      return [{
+        type: 'resource',
+        resource: transcriptResource(block.resource),
+      }];
+    }
+    if (block.type !== 'content' || !block.content || typeof block.content !== 'object') return [];
+    const content = block.content;
+    if (['image', 'audio', 'resource_link'].includes(content.type)) {
+      return [{ type: 'content', content: JSON.parse(JSON.stringify(content)) }];
+    }
+    if (content.type === 'resource') {
+      return [{
+        type: 'content',
+        content: {
+          type: 'resource',
+          resource: transcriptResource(content.resource),
+        },
+      }];
+    }
+    return [];
+  });
+  const seenTerminals = new Set();
+  return blocks.filter(block => {
+    if (block.type !== 'terminal') return true;
+    if (!block.terminalId || seenTerminals.has(block.terminalId)) return false;
+    seenTerminals.add(block.terminalId);
+    return true;
+  });
+}
+
+function generatedMediaTool(entry) {
+  const title = String(entry?.title || '').trim().toLowerCase();
+  const id = String(entry?.id || '').trim().toLowerCase();
+  const output = entry?.rawOutput && typeof entry.rawOutput === 'object' ? entry.rawOutput : {};
+  return id.startsWith('ig_')
+    || title === 'image generation'
+    || title === 'audio generation'
+    || String(output.savedPath || '').includes('/generated_images/');
+}
+
+function acpTranscriptToolEntry(entry) {
+  if (!entry || entry.type !== 'tool') return entry;
+  const detail = detailForTool(entry);
+  const changes = patchChanges(entry.content).map(change => ({
+    path: change.path,
+    kind: change.kind,
+    added: change.added,
+    removed: change.removed,
+    ...(entry?._meta?.farming_patch_decisions?.[change.path]
+      ? { decision: entry._meta.farming_patch_decisions[change.path] }
+      : {}),
+  }));
+  const patchSummary = diffBlocks(entry.content)
+    .map(block => `${diffAction(block)} ${String(block.path || '').trim()}`)
+    .join('\n');
+  const meta = {};
+  if (entry?._meta?.subagent_session_info) {
+    meta.subagent_session_info = JSON.parse(JSON.stringify(entry._meta.subagent_session_info));
+  }
+  if (entry?._meta?.farming_patch_decisions) {
+    meta.farming_patch_decisions = JSON.parse(JSON.stringify(entry._meta.farming_patch_decisions));
+  }
+  return {
+    id: String(entry.id || ''),
+    type: 'tool',
+    title: String(entry.title || ''),
+    kind: String(entry.kind || 'other'),
+    status: String(entry.status || ''),
+    content: transcriptMediaBlocks(entry),
+    ...(Object.keys(meta).length > 0 ? { _meta: meta } : {}),
+    transcriptDetail: detail.length <= MAX_INLINE_TOOL_DETAIL_CHARS
+      ? detail
+      : `${detail.slice(0, MAX_INLINE_TOOL_DETAIL_CHARS)}\n\n[Open to load full detail]`,
+    transcriptDetailTruncated: detail.length > MAX_INLINE_TOOL_DETAIL_CHARS,
+    transcriptPatchSummary: patchSummary,
+    transcriptChanges: changes,
+    generatedMedia: generatedMediaTool(entry),
+    internal: entry.internal === true,
+  };
+}
+
 module.exports = {
   acpToolChanges: entry => patchChanges(entry?.content, { includeDiff: true }),
   acpToolDetail: detailForTool,
   acpToolReviewChanges: entry => patchReviewChanges(entry?.content),
+  acpTranscriptToolEntry,
 };

package/backend/agent-activity.js

@@ -1,3 +1,5 @@
+const { deriveRuntimeObservation } = require('./runtime-observation');
+
 function agentKindForCommand(command) {
   const executable = String(command || '')
     .trim()
@@ -10,157 +12,6 @@ function agentKindForCommand(command) {
   return executable ? 'agent' : null;
 }
 
-function currentTerminalText(agent) {
-  if (!agent) return '';
-  const previewText = typeof agent.previewText === 'string' ? agent.previewText : '';
-  if (previewText.trim()) return previewText.toLowerCase();
-  return String(agent.output || '').slice(-1800).toLowerCase();
-}
-
-function lastIndexOfAny(text, needles) {
-  return needles.reduce((last, needle) => Math.max(last, text.lastIndexOf(needle)), -1);
-}
-
-function lastCodexIdleFooterIndex(text) {
-  const matches = Array.from(text.matchAll(/(?:^|\n)\s*(?:gpt|codex)[^\n]*(?:·|•)\s*(?:~|\/)[^\n]*$/gim));
-  const lastMatch = matches.length > 0 ? matches[matches.length - 1] : undefined;
-  return lastMatch && typeof lastMatch.index === 'number' ? lastMatch.index : -1;
-}
-
-function codexActiveIndex(text) {
-  const activeTextIndex = lastIndexOfAny(text, [
-    'pursuing goal',
-    'esc to interrupt',
-    'press esc to interrupt',
-    'reconnecting',
-    '/stop to close',
-    'background terminal running',
-  ]);
-  const workingIndex = /\bworking\b/.test(text) ? text.lastIndexOf('working') : -1;
-  const stepMatches = Array.from(text.matchAll(/step\s+\d+\s*\/\s*\d+/g));
-  const lastStepMatch = stepMatches.length > 0 ? stepMatches[stepMatches.length - 1] : undefined;
-  const stepIndex = lastStepMatch && typeof lastStepMatch.index === 'number' ? lastStepMatch.index : -1;
-  return Math.max(activeTextIndex, workingIndex, stepIndex);
-}
-
-function codexKindIndex(text) {
-  const codexSpecificIndex = lastIndexOfAny(text, [
-    'pursuing goal',
-    'reconnecting',
-    '/stop to close',
-    'background terminal running',
-    'messages to be submitted after next tool call',
-    'stream disconnected before completion',
-  ]);
-  const workingIndex = /\bworking\b/.test(text) ? text.lastIndexOf('working') : -1;
-  const stepMatches = Array.from(text.matchAll(/step\s+\d+\s*\/\s*\d+/g));
-  const lastStepMatch = stepMatches.length > 0 ? stepMatches[stepMatches.length - 1] : undefined;
-  const stepIndex = lastStepMatch && typeof lastStepMatch.index === 'number' ? lastStepMatch.index : -1;
-  return Math.max(codexSpecificIndex, workingIndex, stepIndex);
-}
-
-function codexBlockedIndex(text) {
-  return lastIndexOfAny(text, [
-    'goal blocked',
-    'input exceeds the context window',
-    'please adjust your input and try again',
-  ]);
-}
-
-function titleWithoutActivityPrefix(title) {
-  return String(title || '')
-    .trim()
-    .replace(/^[\s*＊✳✱✲✶·•:.\u2800-\u28FF]+/u, '')
-    .replace(/\s+/g, ' ')
-    .toLowerCase();
-}
-
-function activeTerminalTitleKind(agent) {
-  const title = typeof agent.sessionTitle === 'string' ? agent.sessionTitle.trim() : '';
-  if (/^[\u2800-\u28ff]/u.test(title)) return 'codex';
-  return null;
-}
-
-function genericTerminalTitleKind(agent) {
-  const normalized = titleWithoutActivityPrefix(agent && agent.sessionTitle);
-  if (!normalized) return null;
-  if (/\bclaude(?:\s+code)?\b/.test(normalized)) return 'claude';
-  if (/\bcodex\b/.test(normalized)) return 'codex';
-  if (/^(?:bash|zsh|sh|fish)(?:\s|$)/.test(normalized)) return 'shell';
-  return null;
-}
-
-function lastMatchIndex(text, pattern) {
-  const matches = Array.from(text.matchAll(pattern));
-  const lastMatch = matches.length > 0 ? matches[matches.length - 1] : undefined;
-  return lastMatch && typeof lastMatch.index === 'number' ? lastMatch.index : -1;
-}
-
-function latestTerminalOutputKind(text) {
-  const candidates = [];
-  const codexIndex = Math.max(
-    lastCodexIdleFooterIndex(text),
-    codexKindIndex(text),
-    lastMatchIndex(text, /(?:^|\n)\s*›\s/g)
-  );
-  if (codexIndex >= 0) candidates.push({ kind: 'codex', index: codexIndex });
-
-  const claudeIndex = Math.max(
-    lastIndexOfAny(text, ['claude code']),
-    lastMatchIndex(text, /(?:thinking|claude)[\s\S]*(?:esc|escape|ctrl\+c|ctrl-c) to interrupt/g)
-  );
-  if (claudeIndex >= 0) candidates.push({ kind: 'claude', index: claudeIndex });
-
-  const shellIndex = lastMatchIndex(text, /(?:^|\n)\s*(?:[\w./~:@-]+\s*)?[$%#]\s*$/gm);
-  if (shellIndex >= 0) candidates.push({ kind: 'shell', index: shellIndex });
-
-  const latest = candidates.sort((a, b) => b.index - a.index)[0];
-  return latest ? latest.kind : null;
-}
-
-function inferAgentKind(agent) {
-  if (!agent) return null;
-  return activeTerminalTitleKind(agent)
-    || latestTerminalOutputKind(currentTerminalText(agent))
-    || (agent.terminalStatus && agent.terminalStatus.kind !== 'unknown' ? agent.terminalStatus.kind : null)
-    || (agent.terminalBusy === true ? 'shell' : null)
-    || genericTerminalTitleKind(agent)
-    || agentKindForCommand(agent.command);
-}
-
-function isAgentTerminalBusy(agent) {
-  if (agent && agent.terminalStatus) {
-    if (agent.terminalStatus.activity === 'busy') return true;
-    if (agent.terminalStatus.activity === 'idle' || agent.terminalStatus.activity === 'exited') return false;
-  }
-  return agent && agent.terminalBusy === true;
-}
-
-function isCodexRestartBlocking(agent) {
-  const output = currentTerminalText(agent);
-  if (!output) return false;
-  if (output.includes('messages to be submitted after next tool call')) return true;
-
-  const activeIndex = codexActiveIndex(output);
-  if (activeIndex < 0) return false;
-
-  const blockedIndex = codexBlockedIndex(output);
-  if (blockedIndex >= activeIndex) return false;
-
-  return lastCodexIdleFooterIndex(output) <= activeIndex;
-}
-
-function isClaudeRestartBlocking(agent) {
-  const output = currentTerminalText(agent);
-  return (
-    output.includes('esc to interrupt') ||
-    output.includes('escape to interrupt') ||
-    output.includes('ctrl+c to interrupt') ||
-    output.includes('ctrl-c to interrupt') ||
-    output.includes('press esc to interrupt')
-  );
-}
-
 function isRecoverableEngineAgent(agent) {
   return agent && agent.engineName === 'native';
 }
@@ -170,13 +21,11 @@ function isRestartBlockingAgent(agent) {
   if (agent.status === 'pending') return true;
   if (agent.status !== 'running') return false;
   if (isRecoverableEngineAgent(agent)) return false;
-  if (isAgentTerminalBusy(agent)) return true;
 
-  const kind = inferAgentKind(agent);
-  if (kind === 'shell') return false;
-  if (kind === 'codex') return isCodexRestartBlocking(agent);
-  if (kind === 'claude') return isClaudeRestartBlocking(agent);
-  return true;
+  const observation = deriveRuntimeObservation(agent);
+  if (observation.phase === 'starting' || observation.phase === 'working' || observation.phase === 'waiting') return true;
+  if (observation.phase === 'idle' || observation.phase === 'exited') return false;
+  return observation.kind !== 'shell';
 }
 
 module.exports = {