@yemi33/minions 0.1.2382 → 0.1.2383

package/engine/shared.js

@@ -3428,9 +3428,9 @@ function resolvePollFlag(engineCfg, granularKey, legacyMacroKey) {
 
 // ─── Runtime Fleet Resolution (P-3b8e5f1d) ──────────────────────────────────
 //
-// Six helpers that are the single source of truth for "which CLI runtime + model
-// + budget + bare-mode applies to this spawn?". Engine code MUST go through
-// these — never read `agent.cli`, `engine.defaultCli`, etc. directly. Future
+// Runtime helpers are the single source of truth for "which CLI runtime + model
+// + tool ceiling + budget + bare-mode applies to this spawn?". Engine code MUST
+// go through these — never read `agent.cli`, `engine.defaultCli`, etc. directly. Future
 // agents adding new resolution rules should extend these helpers, not bypass
 // them.
 //
@@ -3476,28 +3476,27 @@ function resolveCcCli(engine) {
 /**
  * Resolve whether the Command Center / doc-chat path should route through the
  * persistent ACP worker pool. Priority:
- *   1. CC runtime guard — pool spawns `copilot --acp` (Agent Client Protocol).
- *      Claude Code does not implement ACP, and `_invokeCcStream` would silently
- *      switch a Claude operator's CC turns to copilot if the pool ran for them.
- *      Refuse the pool when CC runtime is not copilot, even if explicit-true is
- *      set. Future runtimes that don't implement ACP fall into the same bucket.
+ *   1. Runtime capability guard. Refuse the pool unless the selected adapter
+ *      declares `acpWorkerPool`, even if explicit-true is set, so pooling can
+ *      never switch the configured harness.
  *      (W-mphlriic00095f69)
  *   2. `engine.ccUseWorkerPool` explicit true/false — operator override wins
- *      *within* the copilot runtime
- *   3. Runtime-aware default: ON when CC runtime resolves to `copilot`
- *      (Copilot's cold-spawn is 18-21s on Windows — pool turns subsequent turns
- *      from 47-140s back into a few seconds).
+ *      within an ACP-capable runtime.
+ *   3. Runtime-aware default: ON for any ACP-capable adapter.
  *   4. ENGINE_DEFAULTS.ccUseWorkerPool — final fallback
  *
  * Strict boolean check on the override so a literal `false` opts out even on
- * Copilot, matching the "treat empty/null/undefined as unset" semantics used
+ * ACP runtimes, matching the "treat empty/null/undefined as unset" semantics used
  * throughout the resolve* helpers for boolean flags.
  */
 function resolveCcUseWorkerPool(engine) {
-  // Guard 1 (W-mphlriic00095f69): pool transport is ACP-only. If CC runtime
-  // isn't copilot, the pool cannot run regardless of operator opt-in — don't
-  // silently switch their runtime to copilot.
-  if (resolveCcCli(engine) !== 'copilot') return false;
+  let runtime;
+  try {
+    runtime = require('./runtimes').resolveRuntime(resolveCcCli(engine));
+  } catch {
+    return false;
+  }
+  if (runtime?.capabilities?.acpWorkerPool !== true) return false;
   if (engine && (engine.ccUseWorkerPool === true || engine.ccUseWorkerPool === false)) {
     return engine.ccUseWorkerPool;
   }
@@ -3511,7 +3510,7 @@ function resolveCcUseWorkerPool(engine) {
  * adapter (as returned by `resolveRuntime(resolveAgentCli(agent, engine))`)
  * rather than re-deriving it, since callers on the agent-spawn path already
  * have it in hand. Priority:
- *   1. Capability guard — pool transport is ACP-only (`copilot --acp`). Hard
+ *   1. Capability guard — pool transport is ACP-only. Hard
  *      false whenever `runtime.capabilities.acpWorkerPool` isn't `true`,
  *      regardless of operator override, so a future non-ACP runtime can never
  *      be silently routed through the pool (same rationale as
@@ -3585,6 +3584,17 @@ function resolveCcModel(engine) {
   return undefined;
 }
 
+/**
+ * Resolve the fleet tool ceiling for an agent spawn.
+ *
+ * `config.claude.allowedTools` predates runtime adapters but has always applied
+ * to every selected runtime. Keep that cross-runtime contract centralized here
+ * until the field is migrated to a runtime-neutral config namespace.
+ */
+function resolveAgentAllowedTools(config) {
+  return config?.claude?.allowedTools;
+}
+
 /**
  * Resolve the per-spawn USD budget cap. Priority:
  *   1. `agent.maxBudgetUsd`     — per-agent override
@@ -6043,7 +6053,7 @@ function validateProjectPath(pathStr, options = {}) {
 
 function parseSkillFrontmatter(content, filename) {
   let name = filename.replace('.md', '');
-  let trigger = '', description = '', project = 'any', author = '', created = '', allowedTools = '';
+  let trigger = '', description = '', project = 'any', author = '', created = '', allowedTools = '', scope = 'minions';
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (fmMatch) {
     const fm = fmMatch[1];
@@ -6055,8 +6065,52 @@ function parseSkillFrontmatter(content, filename) {
     author = m('author');
     created = m('created');
     allowedTools = m('allowed-tools');
+    scope = m('scope') || scope;
   }
-  return { name, trigger, description, project, author, created, allowedTools };
+  return { name, trigger, description, project, author, created, allowedTools, scope };
+}
+
+function syncBundledPersonalSkills(skillsDir, opts = {}) {
+  const result = { created: [], updated: [], unchanged: [] };
+  if (!skillsDir || !fs.existsSync(skillsDir)) return result;
+
+  const homeDir = opts.homeDir || os.homedir();
+  const { listRuntimes, resolveRuntime } = require('./runtimes');
+  const personalRoots = new Set();
+  for (const runtimeName of listRuntimes()) {
+    const runtime = resolveRuntime(runtimeName);
+    if (typeof runtime.getSkillWriteTargets !== 'function') continue;
+    const personal = runtime.getSkillWriteTargets({ homeDir }).personal;
+    if (typeof personal === 'string' && personal.trim()) {
+      personalRoots.add(path.resolve(personal));
+    }
+  }
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const sourcePath = path.join(skillsDir, entry.name, 'SKILL.md');
+    if (!fs.existsSync(sourcePath)) continue;
+    const content = fs.readFileSync(sourcePath, 'utf8');
+    const skill = parseSkillFrontmatter(content, `${entry.name}.md`);
+    if (skill.scope !== 'minions') continue;
+    const skillName = String(skill.name || entry.name).replace(/[^a-z0-9-]/g, '-');
+    if (!skillName) throw new Error(`Bundled skill has an invalid name: ${sourcePath}`);
+
+    for (const personalRoot of personalRoots) {
+      const targetPath = path.join(personalRoot, skillName, 'SKILL.md');
+      const exists = fs.existsSync(targetPath);
+      if (exists && fs.readFileSync(targetPath, 'utf8') === content) {
+        result.unchanged.push(targetPath);
+        continue;
+      }
+      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      fs.copyFileSync(sourcePath, targetPath);
+      result[exists ? 'updated' : 'created'].push(targetPath);
+    }
+  }
+  return result;
 }
 
 // ── PR → PRD Links ────────────────────────────────────────────────────────────
@@ -7740,6 +7794,7 @@ function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
     evidence.lastReviewedAt = pr?.lastReviewedAt || '';
     evidence.reviewedAt = review.reviewedAt || '';
     evidence.reviewNote = review.note || pr?.reviewNote || '';
+    evidence.findingId = prReviewFindingIdentity(pr);
     // #2979 — same rationale as BUILD_FAILURE: review feedback fingerprints
     // were sticky across force-push because reviewStatus / reviewedAt /
     // reviewNote don't change when the author rebases. Adding the head SHA
@@ -7751,6 +7806,23 @@ function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
   return crypto.createHash('sha1').update(JSON.stringify(evidence)).digest('hex').slice(0, 16);
 }
 
+function prReviewFindingIdentity(pr) {
+  const review = pr?.minionsReview || {};
+  const threads = Array.isArray(review.threads)
+    ? review.threads.map(value => String(value)).filter(Boolean).sort()
+    : [];
+  const evidence = {
+    pr: pr?.id || pr?.url || '',
+    sourceItem: review.sourceItem || '',
+    dispatchId: review.dispatchId || '',
+    reviewer: review.reviewer || '',
+    reviewedAt: review.reviewedAt || pr?.lastReviewedAt || '',
+    threads,
+    note: review.note || pr?.reviewNote || '',
+  };
+  return `review-${crypto.createHash('sha1').update(JSON.stringify(evidence)).digest('hex').slice(0, 16)}`;
+}
+
 function getPrNoOpFixRecord(pr, cause) {
   if (!pr || !cause || !pr._noOpFixes || typeof pr._noOpFixes !== 'object') return null;
   const record = pr._noOpFixes[cause];
@@ -8510,7 +8582,7 @@ module.exports = {
   ENGINE_DEFAULTS,
   resolvePollFlag, // P-c4d8e1a3 — granular per-poller flag resolution
   resolveAgentCli, resolveCcCli, resolveCcUseWorkerPool, resolveAgentUseWorkerPool, resolveAgentAcpPoolSize, resolveAgentModel, resolveCcModel,
-  resolveAgentMaxBudget, resolveAgentBareMode, resolvePropagateClaudeMdForNonClaudeRuntimes,
+  resolveAgentAllowedTools, resolveAgentMaxBudget, resolveAgentBareMode, resolvePropagateClaudeMdForNonClaudeRuntimes,
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
@@ -8648,6 +8720,7 @@ module.exports = {
   PR_FIX_CAUSE,
   getPrFixAutomationCause,
   prFixEvidenceFingerprint,
+  prReviewFindingIdentity,
   prMergeConflictGuardKey,
   resetMergeConflictStateOnRetarget,
   getPrNoOpFixRecord,
@@ -8655,6 +8728,7 @@ module.exports = {
   getPrPausedCauses,
   isBuildFixIneffectivePaused,
   parseSkillFrontmatter,
+  syncBundledPersonalSkills,
   sleepMs,
   clearWorktreeFailureCache,
   removeWorktree,

package/engine/spawn-agent.js

@@ -32,12 +32,18 @@
  */
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { runFile, cleanChildEnv, killGracefully, killImmediate, killByPidsImmediate, listProcessDescendants, ts, readFileNoFollow } = require('./shared');
-const { resolveRuntime } = require('./runtimes');
+const {
+  resolveRuntime,
+  RUNTIME_OPTIONS_FLAG,
+  RUNTIME_IMAGES_FILE_OPTION,
+  decodeRuntimeOptions,
+  prepareWorkspace: prepareRuntimeWorkspace,
+} = require('./runtimes');
 const { acquireAdoTokenSync, isLikelyAdoToken } = require('./ado-token');
 const keepProcessSweep = require('./keep-process-sweep');
+const MAX_RUNTIME_IMAGES_FILE_BYTES = 32 * 1024 * 1024;
 
 // ─── Pure helpers (exported for tests) ──────────────────────────────────────
 
@@ -76,17 +82,7 @@ function parseSpawnArgs(argv) {
       case '--disable-builtin-mcps':       opts.disableBuiltinMcps = true; break;
       case '--no-custom-instructions':     opts.suppressAgentsMd = true; break;
       case '--enable-reasoning-summaries': opts.reasoningSummaries = true; break;
-      case '--project-harness-dir': {
-        const v = peek();
-        if (typeof v === 'string' && v) projectHarnessDirs.push(v);
-        break;
-      }
-      // P-49e1c8b7 — hermetic harness opt-out. When set, computeAddDirs in
-      // main() returns [minionsDir] only (user-scope asset dirs from
-      // runtime.getUserAssetDirs AND any forwarded --project-harness-dir
-      // entries are dropped). Engine.js gates this flag via
-      // shared.resolveAgentHermeticHarness(agent, engine).
-      case '--hermetic-harness':           hermetic = true; break;
+      case RUNTIME_OPTIONS_FLAG:           Object.assign(opts, decodeRuntimeOptions(peek())); break;
       // LEGACY: dropped — the runtime adapter emits its own permission flag.
       // Pre-P-2a6d9c4f engine.js still passes `--permission-mode bypassPermissions`;
       // letting it through would duplicate the permission flag for Claude.
@@ -168,6 +164,41 @@ function injectAdoTokenEnvForRepoHost(env, opts) {
   return injectAdoTokenEnv(env, opts);
 }
 
+function hydrateRuntimeOptionFiles(opts, {
+  promptFile,
+  readFile = readFileNoFollow,
+  lstatSync = fs.lstatSync,
+  unlinkSync = fs.unlinkSync,
+} = {}) {
+  const imagesFile = opts?.[RUNTIME_IMAGES_FILE_OPTION];
+  if (!imagesFile) return opts;
+  if (typeof imagesFile !== 'string' || !promptFile) {
+    throw new Error('Invalid runtime images sidecar path');
+  }
+  const resolvedFile = path.resolve(imagesFile);
+  const optionsDir = path.resolve(path.dirname(promptFile));
+  if (path.dirname(resolvedFile) !== optionsDir) {
+    throw new Error('Runtime images sidecar must be beside the prompt file');
+  }
+  const stat = lstatSync(resolvedFile);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_RUNTIME_IMAGES_FILE_BYTES) {
+    throw new Error('Invalid runtime images sidecar file');
+  }
+  let images;
+  try {
+    images = JSON.parse(readFile(resolvedFile, 'utf8'));
+  } catch (err) {
+    throw new Error(`Invalid runtime images sidecar payload: ${err.message}`);
+  }
+  if (!Array.isArray(images)) {
+    throw new Error('Invalid runtime images sidecar payload: expected an array');
+  }
+  opts.images = images;
+  delete opts[RUNTIME_IMAGES_FILE_OPTION];
+  try { unlinkSync(resolvedFile); } catch {}
+  return opts;
+}
+
 function formatProcessExitSentinel(exitCode, signal) {
   return `\n[process-exit] code=${exitCode}${signal ? ` signal=${signal}` : ''}\n`;
 }
@@ -307,105 +338,16 @@ function createParentPipeForwarder(stream, outputPath, prefix = '') {
 }
 
 /**
- * P-7d31a06b — Pre-approve a worktree's `.mcp.json` servers in `~/.claude.json`
- * so Claude Code's first invocation in a fresh worktree cwd doesn't show the
- * project-scoped "trust this MCP server?" prompt (which `--dangerously-skip-permissions`
- * silently suppresses → the agent runs without the workspace MCPs).
- *
- * Writes to `projects[worktreePath].enabledMcpjsonServers` (the field Claude
- * Code actually reads — confirmed against the live `~/.claude.json` schema:
- * `enabledMcpjsonServers` / `disabledMcpjsonServers` are siblings of
- * `mcpServers`, indexed by absolute project path). Notes on the PRD wording
- * "mcpServers.approved": that's the intent label; `enabledMcpjsonServers` is
- * the on-disk reality.
- *
- * Pure-ish: all I/O (fs reads, mutator) is injected for tests. Best-effort —
- * callers MUST swallow errors and never block dispatch on this.
- *
- * Returns `{ wrote: boolean, reason: string, servers: string[] }`:
- *   - reason ∈ { 'ok', 'flag-off', 'not-claude', 'no-worktree',
- *                'no-workspace-mcp', 'invalid-workspace-mcp', 'no-servers' }
- *   - servers: keys discovered in the workspace `.mcp.json` (regardless of write)
- *
- * Args:
- *   runtimeName             — `runtime.name` from `resolveRuntime(...)`. Helper no-ops if !== 'claude'.
- *   worktreePath            — absolute path to the agent's cwd (the worktree). Used as both the file location
- *                             (`<worktreePath>/.mcp.json`) and the `projects[...]` key in `~/.claude.json`.
- *   homeDir                 — `os.homedir()`. Injected for test isolation; helper does NOT call os.homedir directly.
- *   engineConfig            — config.engine object; reads `claudePreApproveWorkspaceMcps` (default true via ENGINE_DEFAULTS).
- *   mutateJsonFileLocked    — injected file-locked mutator (engine/shared.js#mutateJsonFileLocked).
- *   existsSync, readFileSync — injectable fs primitives (default to node:fs).
+ * Backward-compatible wrapper for the old helper name. Runtime-owned workspace
+ * preparation now lives behind the adapter contract; the spawn wrapper does
+ * not know which harness needs which config file mutation.
  */
-function preApproveWorkspaceMcps({
-  runtimeName,
-  worktreePath,
-  homeDir,
-  engineConfig,
-  mutateJsonFileLocked,
-  existsSync = fs.existsSync,
-  readFileSync = fs.readFileSync,
-} = {}) {
-  if (engineConfig && engineConfig.claudePreApproveWorkspaceMcps === false) {
-    return { wrote: false, reason: 'flag-off', servers: [] };
-  }
-  if (runtimeName !== 'claude') {
-    return { wrote: false, reason: 'not-claude', servers: [] };
-  }
-  if (!worktreePath || typeof worktreePath !== 'string') {
-    return { wrote: false, reason: 'no-worktree', servers: [] };
+function preApproveWorkspaceMcps({ runtimeName, ...context } = {}) {
+  const result = prepareRuntimeWorkspace(resolveRuntime(runtimeName), context);
+  if (result?.reason === 'unsupported-runtime') {
+    return { ...result, reason: 'not-claude' };
   }
-  const workspaceMcpPath = path.join(worktreePath, '.mcp.json');
-  if (!existsSync(workspaceMcpPath)) {
-    return { wrote: false, reason: 'no-workspace-mcp', servers: [] };
-  }
-  let workspaceMcp;
-  try {
-    workspaceMcp = JSON.parse(readFileSync(workspaceMcpPath, 'utf8'));
-  } catch {
-    return { wrote: false, reason: 'invalid-workspace-mcp', servers: [] };
-  }
-  const serversObj = workspaceMcp && typeof workspaceMcp === 'object' ? workspaceMcp.mcpServers : null;
-  const servers = serversObj && typeof serversObj === 'object' && !Array.isArray(serversObj)
-    ? Object.keys(serversObj).filter((k) => typeof k === 'string' && k.length > 0)
-    : [];
-  if (servers.length === 0) {
-    return { wrote: false, reason: 'no-servers', servers: [] };
-  }
-  if (!homeDir || typeof mutateJsonFileLocked !== 'function') {
-    return { wrote: false, reason: 'no-home-or-mutator', servers };
-  }
-  const claudeJsonPath = path.join(homeDir, '.claude.json');
-  let didWrite = false;
-  mutateJsonFileLocked(claudeJsonPath, (data) => {
-    const root = data && typeof data === 'object' ? data : {};
-    if (!root.projects || typeof root.projects !== 'object') root.projects = {};
-    const projectKey = worktreePath;
-    const proj = root.projects[projectKey] && typeof root.projects[projectKey] === 'object'
-      ? root.projects[projectKey]
-      : {};
-    // enabledMcpjsonServers is Claude's actual on-disk approval field
-    const enabled = Array.isArray(proj.enabledMcpjsonServers) ? proj.enabledMcpjsonServers.slice() : [];
-    const disabled = Array.isArray(proj.disabledMcpjsonServers) ? proj.disabledMcpjsonServers.slice() : [];
-    const enabledSet = new Set(enabled.filter((s) => typeof s === 'string'));
-    let mutated = false;
-    for (const name of servers) {
-      if (!enabledSet.has(name)) {
-        enabledSet.add(name);
-        mutated = true;
-      }
-    }
-    // If a server was previously explicitly disabled, lift the disabled mark when we
-    // re-approve it — otherwise Claude treats the disabled entry as authoritative.
-    const nextDisabled = disabled.filter((s) => typeof s === 'string' && !servers.includes(s));
-    if (nextDisabled.length !== disabled.length) mutated = true;
-    if (!mutated) return data;
-    proj.enabledMcpjsonServers = [...enabledSet];
-    proj.disabledMcpjsonServers = nextDisabled;
-    root.projects[projectKey] = proj;
-    didWrite = true;
-    return root;
-  }, { defaultValue: {}, skipWriteIfUnchanged: true });
-  return { wrote: didWrite, reason: 'ok', servers };
+  return result;
 }
 
 // ─── Main script execution ──────────────────────────────────────────────────
@@ -421,7 +363,13 @@ function _installHint(name, runtime) {
 }
 
 function main() {
-  const parsed = parseSpawnArgs(process.argv);
+  let parsed;
+  try {
+    parsed = parseSpawnArgs(process.argv);
+  } catch (err) {
+    console.error(`FATAL: ${err.message}`);
+    process.exit(78);
+  }
   if (!parsed) {
     console.error('Usage: node spawn-agent.js <prompt-file> <sysprompt-file> [--runtime <name>] [args...]');
     process.exit(1);
@@ -445,12 +393,18 @@ function main() {
   // (Windows non-junction reads don't follow symlinks the same way POSIX does).
   const promptText = readFileNoFollow(promptFile, 'utf8');
   const sysPromptText = readFileNoFollow(sysPromptFile, 'utf8');
+  try {
+    hydrateRuntimeOptionFiles(opts, { promptFile });
+  } catch (err) {
+    console.error(`FATAL: ${err.message}`);
+    process.exit(78);
+  }
 
   // Sys prompt tmp file — only when (a) NOT resuming and (b) the adapter
   // accepts a system prompt as a separate file. For runtimes that bake the
   // system prompt into the user prompt (e.g. Copilot), sysPromptText is
   // already merged inside `runtime.buildPrompt(prompt, sys)`.
-  const isResume = opts.sessionId != null;
+  const isResume = typeof opts.sessionId === 'string' && opts.sessionId.trim() !== '';
   const sysTmpPath = sysPromptFile + '.tmp';
   const wantsSystemPromptFile = typeof runtime.usesSystemPromptFile === 'function'
     ? runtime.usesSystemPromptFile({ isResume, opts })
@@ -714,6 +668,18 @@ function main() {
   });
 }
 
-module.exports = { parseSpawnArgs, buildSpawnInvocation, normalizeRuntimeExit, shouldInjectAdoTokenEnv, injectAdoTokenEnv, injectAdoTokenEnvForRepoHost, writeProcessExitSentinel, preApproveWorkspaceMcps, createParentPipeForwarder, assertStaleHeadOk };
+module.exports = {
+  parseSpawnArgs,
+  buildSpawnInvocation,
+  normalizeRuntimeExit,
+  shouldInjectAdoTokenEnv,
+  injectAdoTokenEnv,
+  injectAdoTokenEnvForRepoHost,
+  writeProcessExitSentinel,
+  preApproveWorkspaceMcps,
+  createParentPipeForwarder,
+  assertStaleHeadOk,
+  hydrateRuntimeOptionFiles, // exported for testing
+};
 
 if (require.main === module) main();

package/engine/spawn-phase-watchdog.js

@@ -36,6 +36,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
+const { resolveRuntime, isSpawnStartupEvent } = require('./runtimes');
 const { ENGINE_DEFAULTS, FAILURE_CLASS } = shared;
 const AGENTS_DIR = queries.AGENTS_DIR;
 const log = (level, msg) => shared.log ? shared.log(level, msg) : console.log(`[${level}] ${msg}`);
@@ -43,24 +44,6 @@ const log = (level, msg) => shared.log ? shared.log(level, msg) : console.log(`[
 // Lazy require to break circular dep with dispatch.js (which lazy-requires engine.js).
 function dispatch() { return require('./dispatch'); }
 
-// ── Per-runtime startup-only event filters ──────────────────────────────────
-//
-// Anything NOT in these sets is treated as "real task activity" and the
-// watchdog stands down. These match the runtimes/*.js KNOWN_EVENT_TYPES
-// startup section — keep in sync.
-
-const COPILOT_STARTUP_TYPES = new Set([
-  'session.mcp_server_status_changed',
-  'session.mcp_servers_loaded',
-  'session.skills_loaded',
-  'session.tools_updated',
-  'session.info',
-]);
-
-// Claude stream-json prints {"type":"system","subtype":"init|hook_started|hook_response"}
-// during startup before any assistant/user/tool_use/result events fire.
-const CLAUDE_STARTUP_SUBTYPES = new Set(['init', 'hook_started', 'hook_response']);
-
 // Header line that engine.js writes at spawn: "[<iso>] pid: <n>"
 const HEADER_LINE_RE = /^\[[^\]]+\]\s+(?:pid:|spawn-failed)/;
 
@@ -79,6 +62,12 @@ const HEADER_LINE_RE = /^\[[^\]]+\]\s+(?:pid:|spawn-failed)/;
  */
 function hasRealTaskActivity(tailText, runtimeName) {
   if (!tailText) return false;
+  let runtime;
+  try {
+    runtime = resolveRuntime(runtimeName);
+  } catch {
+    return true;
+  }
   const lines = String(tailText).split(/\r?\n/);
   for (const rawLine of lines) {
     const line = rawLine.trim();
@@ -100,23 +89,7 @@ function hasRealTaskActivity(tailText, runtimeName) {
       // Object with no `type` — unusual; treat as activity to stay safe.
       return true;
     }
-    if (runtimeName === 'copilot') {
-      if (COPILOT_STARTUP_TYPES.has(type)) continue;
-      // Anything else from Copilot is real (assistant.*, tool.*, result,
-      // session.task_complete, user.message, function).
-      return true;
-    }
-    if (runtimeName === 'claude' || !runtimeName) {
-      // Claude stream-json: only {type:'system', subtype:'init|hook_*'} is startup.
-      if (type === 'system') {
-        const sub = typeof evt.subtype === 'string' ? evt.subtype : '';
-        if (CLAUDE_STARTUP_SUBTYPES.has(sub)) continue;
-        // Other `system` subtypes (e.g. errors, banners) — treat as activity.
-        return true;
-      }
-      return true;
-    }
-    // Unknown runtime — be conservative.
+    if (isSpawnStartupEvent(runtime, evt)) continue;
     return true;
   }
   return false;
@@ -266,6 +239,4 @@ function _defaultTailReader(filePath) {
 module.exports = {
   checkSpawnPhaseStalls,
   hasRealTaskActivity, // exported for testing
-  COPILOT_STARTUP_TYPES, // exported for testing
-  CLAUDE_STARTUP_SUBTYPES, // exported for testing
 };