atris 3.51.0 → 3.53.0

package/commands/youtube.js

@@ -5,8 +5,9 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 
-const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [haiku|atris-fast|gemini|grok|codex|cursor]';
+const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [youtube-url-or-playlist...] [haiku|atris-fast|gemini|grok|codex|cursor]';
 const YTNOTES_HINT = 'zero credits, local captions + a fast engine';
+const NOTES_PLAYLIST_CAP = 10;
 
 const DEFAULT_QUERY = [
   'Create a timestamped YouTube brief for Atris.',
@@ -24,7 +25,7 @@ const ALLOWED_CAPTION_HOST_SUFFIXES = [
 
 function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
-  output(`Usage: ${commandName} notes <youtube-url> [engine]`);
+  output(`Usage: ${commandName} notes <youtube-url> [youtube-url-or-playlist...] [engine]`);
   output(`       ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} digest [--days N]`);
   output(`       ${commandName} watch add <channel-url-or-@handle>`);
@@ -33,7 +34,8 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output(`       ${commandName} watch tick`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
-  output('notes = free local notes, process = 5 credits cloud knowledge');
+  output('notes = free local notes for one url, several urls, or a playlist');
+  output('process = 5 credits cloud knowledge');
   output('digest = one decision page from this week\'s video briefs');
   output('watch = subscribed channels turn into briefs without a human');
   output('Process a YouTube video through Atris using timestamped transcript-first analysis.');
@@ -52,6 +54,8 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
   output('Examples:');
   output(`  ${commandName} notes https://www.youtube.com/watch?v=VIDEO_ID`);
+  output(`  ${commandName} notes https://www.youtube.com/watch?v=VIDEO_ID https://youtu.be/OTHER_ID`);
+  output(`  ${commandName} notes https://www.youtube.com/playlist?list=PLAYLIST_ID`);
   output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
   output(`  ${commandName} digest`);
@@ -464,6 +468,34 @@ function videoIdFromUrl(url) {
   return short ? short[1] : null;
 }
 
+function looksLikeYoutubeUrl(arg) {
+  const text = String(arg || '').trim();
+  if (!text || text.startsWith('-')) return false;
+  return /youtube\.com|youtu\.be/i.test(text);
+}
+
+function isPlaylistUrl(url) {
+  const text = String(url || '');
+  return /[?&]list=/.test(text) || /\/playlist(?:\?|$|\/)/i.test(text);
+}
+
+function parseNotesArgs(argv = []) {
+  const urls = [];
+  let engine = null;
+  let help = false;
+  for (const raw of argv) {
+    const arg = String(raw);
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      help = true;
+      continue;
+    }
+    if (arg.startsWith('-')) continue;
+    if (looksLikeYoutubeUrl(arg)) urls.push(arg);
+    else engine = arg;
+  }
+  return { urls, engine, help };
+}
+
 function dateStamp(now) {
   if (typeof now === 'string' && /^\d{4}-\d{2}-\d{2}/.test(now)) {
     return now.slice(0, 10);
@@ -512,6 +544,7 @@ function fileBriefFromNotes({ cwd, url, workDir, now } = {}) {
     fs.writeFileSync(journalPath, `${existing}${prefix}${line}\n`);
 
     console.log(`brief filed: ${relBrief}`);
+    return relBrief;
   } catch {
     // notes filing must never break the youtube command
   }
@@ -1015,37 +1048,189 @@ async function watchCommand(args = [], deps = {}) {
   return 2;
 }
 
-function runYoutubeNotes(args = [], deps = {}) {
-  const output = deps.output || ((line = '') => console.error(line));
-  const url = args[0];
-  const engine = args[1];
-  if (!url) {
-    output(YTNOTES_USAGE);
-    output(YTNOTES_HINT);
-    return 2;
+function defaultPlaylistExpander(playlistUrl, deps = {}) {
+  const spawn = deps.spawnSync || spawnSync;
+  const result = spawn('yt-dlp', [
+    '--no-update',
+    '--flat-playlist',
+    '--print',
+    '%(id)s|%(title)s',
+    playlistUrl,
+  ], {
+    encoding: 'utf8',
+    timeout: 60000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  if (result.error || (result.status != null && result.status !== 0)) {
+    const detail = String(result.stderr || result.error?.message || 'playlist expand failed').trim();
+    throw new Error(detail || 'playlist expand failed');
   }
+  return parseFlatPlaylist(result.stdout);
+}
 
+function defaultNotesItemRunner(url, engine, deps = {}) {
   const script = path.join(__dirname, '..', 'scripts', 'det', 'ytnotes');
   const spawn = deps.spawnSync || spawnSync;
   const childArgs = engine ? [url, engine] : [url];
-  const result = spawn(script, childArgs, { stdio: 'inherit' });
-  if (result.status == null) return 1;
-  if (result.status === 0) {
-    fileBriefFromNotes({
+  return spawn(script, childArgs, { stdio: 'inherit' });
+}
+
+function readNowMs(deps = {}) {
+  if (typeof deps.nowMs === 'function') return Number(deps.nowMs()) || 0;
+  if (Number.isFinite(deps.nowMs)) return Number(deps.nowMs);
+  return Date.now();
+}
+
+function notesItemLabel(item = {}) {
+  return item.id || item.url || '';
+}
+
+function expandNotesTargets(urls = [], deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const expander = deps.expander || ((playlistUrl) => defaultPlaylistExpander(playlistUrl, deps));
+  const items = [];
+  for (const url of urls) {
+    if (!isPlaylistUrl(url)) {
+      items.push({ url, id: videoIdFromUrl(url) });
+      continue;
+    }
+    let videos = [];
+    try {
+      videos = expander(url, deps);
+    } catch {
+      items.push({ url, id: videoIdFromUrl(url), failed: true });
+      continue;
+    }
+    if (!Array.isArray(videos) || videos.length === 0) {
+      items.push({ url, id: videoIdFromUrl(url), failed: true });
+      continue;
+    }
+    if (videos.length > NOTES_PLAYLIST_CAP) {
+      output(`playlist capped at ${NOTES_PLAYLIST_CAP} videos (${videos.length} found)`);
+      videos = videos.slice(0, NOTES_PLAYLIST_CAP);
+    }
+    for (const video of videos) {
+      if (!video?.id) continue;
+      items.push({
+        url: `https://www.youtube.com/watch?v=${video.id}`,
+        id: video.id,
+        title: video.title,
+      });
+    }
+  }
+  return items;
+}
+
+function invokeNotesRunner(url, engine, deps = {}) {
+  const runner = deps.runner;
+  if (runner) return runner(url, engine, deps);
+  return defaultNotesItemRunner(url, engine, deps);
+}
+
+function readRunnerStatus(result) {
+  if (typeof result === 'number') return result;
+  if (result && typeof result === 'object') {
+    return result.status == null ? 1 : result.status;
+  }
+  return 1;
+}
+
+function fileNotesBrief(url, deps = {}) {
+  const briefFiler = deps.briefFiler || fileBriefFromNotes;
+  try {
+    const filed = briefFiler({
       cwd: deps.cwd || process.cwd(),
       url,
       workDir: deps.workDir || path.join(process.env.TMPDIR || '/tmp', 'ytnotes'),
       now: deps.now || new Date(),
     });
+    return typeof filed === 'string' && filed ? filed : null;
+  } catch {
+    return null;
+  }
+}
+
+function runOneNotesItem(item, engine, deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const label = notesItemLabel(item);
+  if (item.failed) {
+    output(`${label}  0s  FAILED`);
+    return { url: item.url, id: item.id, seconds: 0, ok: false, brief: null };
+  }
+
+  const started = readNowMs(deps);
+  let status = 1;
+  try {
+    status = readRunnerStatus(invokeNotesRunner(item.url, engine, deps));
+  } catch {
+    status = 1;
+  }
+  const brief = status === 0 ? fileNotesBrief(item.url, deps) : null;
+  const seconds = Math.max(0, Math.round((readNowMs(deps) - started) / 1000));
+  const ok = status === 0;
+  output(`${label}  ${seconds}s  ${ok ? (brief || 'ok') : 'FAILED'}`);
+  return { url: item.url, id: item.id, seconds, ok, brief };
+}
+
+function formatNotesSummary(rows = []) {
+  const lines = ['url or id  seconds  result'];
+  for (const row of rows) {
+    const result = row.ok ? (row.brief || 'ok') : 'FAILED';
+    lines.push(`${notesItemLabel(row)}  ${row.seconds}s  ${result}`);
+  }
+  return lines.join('\n');
+}
+
+function runYoutubeNotesBatch({ urls, engine } = {}, deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const items = expandNotesTargets(urls || [], deps);
+  const rows = [];
+  for (const item of items) {
+    rows.push(runOneNotesItem(item, engine, deps));
+  }
+  if (rows.length) {
+    output('');
+    output(formatNotesSummary(rows));
+  }
+  if (!rows.length) return 2;
+  return rows.some((row) => row.ok) ? 0 : 2;
+}
+
+function runSingleYoutubeNotes(url, engine, deps = {}) {
+  let result;
+  try {
+    result = invokeNotesRunner(url, engine, deps);
+  } catch {
+    return 1;
+  }
+  const status = readRunnerStatus(result);
+  if (status === 0) fileNotesBrief(url, deps);
+  return status;
+}
+
+function runYoutubeNotes(args = [], deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const parsed = parseNotesArgs(args);
+  if (parsed.help) {
+    showYoutubeHelp(output, deps.commandName || 'atris youtube');
+    return 0;
+  }
+  if (!parsed.urls.length) {
+    output(YTNOTES_USAGE);
+    output(YTNOTES_HINT);
+    return 2;
+  }
+  if (parsed.urls.length === 1 && !isPlaylistUrl(parsed.urls[0])) {
+    return runSingleYoutubeNotes(parsed.urls[0], parsed.engine, deps);
   }
-  return result.status;
+  return runYoutubeNotesBatch(parsed, deps);
 }
 
 async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
   if (argv[0] === 'notes') {
     const code = runYoutubeNotes(argv.slice(1), deps);
-    if (!deps.output && !deps.spawnSync) process.exit(code);
+    if (!deps.output && !deps.spawnSync && !deps.runner && !deps.expander) process.exit(code);
     return code;
   }
   if (argv[0] === 'digest') {
@@ -1078,19 +1263,17 @@ module.exports = {
   shouldRetryWithLocalTranscript,
   formatYoutubeResult,
   fileBriefFromNotes,
+  isPlaylistUrl,
+  parseNotesArgs,
+  expandNotesTargets,
+  runYoutubeNotesBatch,
   parseDigestArgs,
   collectVideoBriefs,
   buildDigestPrompt,
-  runYoutubeDigest,
   normalizeWatchChannel,
   channelVideosUrl,
   parseFlatPlaylist,
   loadWatchState,
-  saveWatchState,
-  addWatchChannel,
-  listWatchChannels,
-  removeWatchChannel,
-  tickWatch,
   watchCommand,
   youtubeCommand,
 };

package/lib/auto-accept-certified.js

@@ -1099,7 +1099,8 @@ function evaluateAutoAccept(task, options = {}) {
       if ((tierRequiresStrictVerify && !verifyResult.ok)
         || verifyResult.reason === 'verify_failed'
         || verifyResult.reason === 'verify_unrunnable'
-        || verifyResult.reason === 'verify_worktree_missing') {
+        || verifyResult.reason === 'verify_worktree_missing'
+        || verifyResult.reason === 'verify_workdir_missing') {
         return { eligible: false, ref, reason: verifyResult.reason, verify, ...verifyResult };
       }
     }

package/lib/engine-ask.js

@@ -29,7 +29,7 @@ const MAX_ASK_PROMPT_BYTES = 16 * 1024;
 const MAX_ASK_TOTAL_PROMPT_BYTES = 64 * 1024;
 const MAX_ASK_OUTPUT_BYTES = 1024 * 1024;
 const ASK_STOP_GRACE_MS = 250;
-const ASK_MODEL_ENGINES = new Set(['claude', 'fable', 'haiku', 'codex', 'cursor', 'devin', 'grok']);
+const ASK_MODEL_ENGINES = new Set(['claude', 'fable', 'haiku', 'codex', 'cursor', 'devin', 'grok', 'agy']);
 const READ_ONLY_PREAMBLE = [
   'This is a read-only request.',
   'Do not modify files, create worktrees, start background agents, or run commands with side effects.',
@@ -241,8 +241,16 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '') {
       args: ['--no-memory', '--no-subagents', '--permission-mode', 'plan', '--sandbox', 'read-only', ...(model ? ['--model', model] : []), '-p', request],
     };
   }
-  if (engine === 'droid') {
-    return { engine, bin: profile.bin, args: ['exec', '--disable-builtin-skills', request] };
+  if (engine === 'agy') {
+    // agy prompts for tool permission even in plan mode and a headless ask
+    // has no one to answer, so it denies itself `ls` and fails every ask
+    // (verified live 2026-08-19). The sandbox keeps the run read-only while
+    // skip-permissions lets sandboxed reads proceed unattended.
+    return {
+      engine,
+      bin: profile.bin,
+      args: ['--mode', 'plan', '--sandbox', '--dangerously-skip-permissions', ...(model ? ['--model', model] : []), '-p', request],
+    };
   }
   throw new Error(`engine ask has no read-only command for ${engine}`);
 }

package/lib/engine-registry.js

@@ -34,7 +34,8 @@ function engineFailureHealthStatus(result) {
     return 'credit_out';
   }
   if (/not installed|command not found|\benoent\b/.test(signalText)) return 'not_installed';
-  if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
+  // Timeouts and unavailable models are transient: 'error' keeps the engine
+  // routable, while 'not_installed' would drop it from routing until a doctor run.
   return 'error';
 }
 
@@ -48,7 +49,19 @@ const ENGINE_SEED_META = Object.freeze({
   fable: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), models: Object.freeze(['opus 5', 'opus 4.8', 'fable', 'haiku']), duty: 'leader', fallback_order: 50 }),
   composer: Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator', 'executor']), models: Object.freeze(['composer 2.5']), fallback_order: 60 }),
   haiku: Object.freeze({ tier: 'fast', roles: Object.freeze(['validator']), models: Object.freeze(['haiku']), fallback_order: 70 }),
-  droid: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['built-in router']), duty: 'errands', fallback_order: 90 }),
+  agy: Object.freeze({
+    tier: 'pro',
+    roles: Object.freeze(['executor']),
+    models: Object.freeze([
+      'gemini-3.7-flash-high',
+      'gemini-3.1-pro-high',
+      'claude-sonnet-4-6',
+      'claude-opus-4-6-thinking',
+      'gpt-oss-120b-medium',
+    ]),
+    duty: 'errands',
+    fallback_order: 90,
+  }),
 });
 
 function engineRegistryFile(root = process.cwd()) {
@@ -144,9 +157,9 @@ function normalizeEngineEntry(id, saved = {}) {
   };
 }
 
-function seededRegistry(root = process.cwd()) {
+function seededRegistry(root = process.cwd(), preloadedRaw = null) {
   const file = engineRegistryFile(root);
-  const raw = readRawRegistry(file);
+  const raw = preloadedRaw || readRawRegistry(file);
   const savedById = new Map();
   for (const entry of raw.engines || []) {
     const id = canonicalEngineName(entry && (entry.id || entry.name));
@@ -162,7 +175,11 @@ function seededRegistry(root = process.cwd()) {
 function writeEngineRegistry(root, registry) {
   const file = engineRegistryFile(root);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+  // Atomic write: a concurrent reader must never see a torn file, because a
+  // failed parse falls back to the seed registry and erases operator policy.
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, file);
 }
 
 function setEngineOverrides(name, overrides = {}, root = process.cwd()) {
@@ -221,9 +238,17 @@ function setEngineOverrides(name, overrides = {}, root = process.cwd()) {
   return { id, ...nextOverrides };
 }
 
+// A read only writes when normalization actually changed the saved engines
+// (first seed, schema drift). Settled registries stay untouched, so read
+// paths cannot stomp a mutation another process just landed. The comparison
+// uses the same raw snapshot the seed was built from: one read, one decision.
 function readEngineRegistry(root = process.cwd(), options = {}) {
-  const registry = seededRegistry(root);
-  if (options.persist !== false) writeEngineRegistry(root, registry);
+  const raw = readRawRegistry(engineRegistryFile(root));
+  const registry = seededRegistry(root, raw);
+  const needsPersist = JSON.stringify(raw.engines || []) !== JSON.stringify(registry.engines);
+  if (options.persist !== false && needsPersist) {
+    writeEngineRegistry(root, registry);
+  }
   return registry;
 }
 

package/lib/mission-ledger-compact.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// Mission ledger compaction. Every mission save appends a full snapshot to
+// .atris/state/missions.jsonl, so a mission saved N times costs N rows and
+// every reader pays for the whole history (2,417 rows for 302 missions when
+// this shipped). Worse, old snapshots keep referencing old run receipts, so
+// the daily runs-prune can never reclaim them. Compacting to one row per
+// mission keeps exactly what every reader reconstructs anyway.
+//
+// Readers' contract (loadMissionMap in commands/mission.js): the surviving
+// row per id must carry the LATEST state but the FIRST display number ever
+// assigned, and first-appearance order must hold so numbering stays stable.
+
+const fs = require('fs');
+const path = require('path');
+const { displayNumber } = require('./short-name');
+
+const DEFAULT_MIN_ROWS = 64;
+const DEFAULT_RATIO = 4;
+
+function parseLines(text) {
+  return String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    });
+}
+
+// Latest snapshot per id, first-seen order, first assigned display number.
+// Rows without an id are not mission snapshots (cloud mission receipts land
+// here as {cloud: true, ...}); they pass through untouched, in order, after
+// the compacted snapshots so latest-row readers still find them.
+function compactRows(rows) {
+  const order = [];
+  const latest = new Map();
+  const firstNumber = new Map();
+  const passthrough = [];
+  for (const row of rows) {
+    if (!row) continue;
+    if (!row.id) {
+      passthrough.push(row);
+      continue;
+    }
+    if (!latest.has(row.id)) order.push(row.id);
+    if (!firstNumber.has(row.id) && displayNumber(row.n)) firstNumber.set(row.id, displayNumber(row.n));
+    latest.set(row.id, row);
+  }
+  const compacted = order.map((id) => {
+    const row = { ...latest.get(id) };
+    if (firstNumber.has(id)) row.n = firstNumber.get(id);
+    else delete row.n;
+    return row;
+  });
+  return compacted.concat(passthrough);
+}
+
+// Compact when history outweighs live records by `ratio`, and never bother
+// below `minRows`. Returns a receipt either way; writes atomically so a
+// concurrent reader sees the old file or the new one, never a torn one.
+function compactMissionLedger(file, options = {}) {
+  const minRows = Number.isFinite(options.minRows) ? options.minRows : DEFAULT_MIN_ROWS;
+  const ratio = Number.isFinite(options.ratio) ? options.ratio : DEFAULT_RATIO;
+  // Cheap stat gate so the every-save hook does not re-read a small healthy
+  // ledger: below this size compaction cannot be worth a full read.
+  const minBytes = Number.isFinite(options.minBytes) ? options.minBytes : 262144;
+  if (options.force !== true) {
+    try {
+      if (fs.statSync(file).size < minBytes) {
+        return { compacted: false, reason: 'below_threshold', rows_before: 0, rows_after: 0 };
+      }
+    } catch {
+      return { compacted: false, reason: 'missing', rows_before: 0, rows_after: 0 };
+    }
+  }
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return { compacted: false, reason: 'missing', rows_before: 0, rows_after: 0 };
+  }
+  const rows = parseLines(text);
+  const valid = rows.filter((row) => row && row.id);
+  const uniqueIds = new Set(valid.map((row) => row.id)).size;
+  const receipt = {
+    rows_before: rows.length,
+    unique_missions: uniqueIds,
+    bytes_before: Buffer.byteLength(text),
+  };
+  const force = options.force === true;
+  if (!force && (rows.length < minRows || rows.length < uniqueIds * ratio)) {
+    return { ...receipt, compacted: false, reason: 'below_threshold', rows_after: rows.length };
+  }
+  const compacted = compactRows(rows.filter(Boolean));
+  const nextText = compacted.length
+    ? `${compacted.map((row) => JSON.stringify(row)).join('\n')}\n`
+    : '';
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(tmp, nextText, 'utf8');
+  // The rename replaces the whole file, so an append that landed after our
+  // read would be silently lost. Re-check right before the swap and stand
+  // down if anyone wrote in between; the next save retries compaction.
+  try {
+    if (fs.statSync(file).size !== receipt.bytes_before) {
+      fs.unlinkSync(tmp);
+      return { ...receipt, compacted: false, reason: 'concurrent_write', rows_after: rows.length };
+    }
+  } catch {
+    fs.unlinkSync(tmp);
+    return { ...receipt, compacted: false, reason: 'missing', rows_after: 0 };
+  }
+  fs.renameSync(tmp, file);
+  return {
+    ...receipt,
+    compacted: true,
+    rows_after: compacted.length,
+    bytes_after: Buffer.byteLength(nextText),
+  };
+}
+
+module.exports = { compactMissionLedger, compactRows };

package/lib/mission-runtime-loop.js

@@ -121,7 +121,34 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
         ...(options.env || {}),
       },
       stdio: ['ignore', 'pipe', 'pipe'],
+      // Own process group so a timeout can kill the whole tree: the tick
+      // spawns engine workers through a shell, and killing only the direct
+      // child leaves them running (and billing) for hours after the timeout.
+      detached: process.platform !== 'win32',
     });
+    const killTree = (signal) => {
+      try {
+        if (process.platform !== 'win32' && proc.pid) process.kill(-proc.pid, signal);
+        else proc.kill(signal);
+      } catch {
+        try { proc.kill(signal); } catch {}
+      }
+    };
+    // Detached children survive the operator's Ctrl-C (they left our process
+    // group), so relay the signal to the whole tree ourselves, then let the
+    // default exit happen by re-raising after removing our handler.
+    const relaySignal = (signal) => {
+      killTree('SIGTERM');
+      setTimeout(() => killTree('SIGKILL'), 2000).unref();
+      process.removeListener(signal, relaySignal);
+      process.kill(process.pid, signal);
+    };
+    process.once('SIGINT', relaySignal);
+    process.once('SIGTERM', relaySignal);
+    const detachSignalRelay = () => {
+      process.removeListener('SIGINT', relaySignal);
+      process.removeListener('SIGTERM', relaySignal);
+    };
     let stdout = '';
     let stderr = '';
     let done = false;
@@ -130,6 +157,7 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
     const finish = (status) => {
       if (done) return;
       done = true;
+      detachSignalRelay();
       clearTimeout(timer);
       if (progressTimer) clearInterval(progressTimer);
       let payload = null;
@@ -146,8 +174,8 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
     };
     const timer = setTimeout(() => {
       killedByTimeout = true;
-      try { proc.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, 3000).unref();
+      killTree('SIGTERM');
+      setTimeout(() => killTree('SIGKILL'), 3000).unref();
     }, options.timeoutMs || 660000);
     progressTimer = options.onProgress
       ? setInterval(() => {