amicus 1.9.1 → 2.1.0

package/src/cli-handlers-doctor.js

@@ -2,6 +2,8 @@
 'use strict';
 
 const HINTS = require('./utils/remediation-hints');
+// B14/4.3: 'mcp' + 'mcp-legacy' check bodies (mirrors the B15 tmpSweep split — see file header).
+const mcpChecks = require('./utils/doctor-mcp-checks');
 
 const MAX_CATALOG_AGE_MS = 24 * 60 * 60 * 1000; // 24h (mirrors model-catalog DEFAULT_MAX_AGE_MS)
 
@@ -39,8 +41,13 @@ function realDeps() {
     // stays separate; repair only runs when fix is requested.
     repairElectron: (opts) => require('./sidecar/electron-install').repairElectron(opts),
     fix: false,
-    discoverClaudeCodeMcps: () => require('./utils/mcp-discovery').discoverClaudeCodeMcps(),
     discoverCoworkMcps: () => require('./utils/mcp-discovery').discoverCoworkMcps(),
+    // B14: raw (unstripped) read — the PRIMARY 'mcp' check signal.
+    // discoverClaudeCodeMcps() always strips 'amicus'/'sidecar'-shaped
+    // entries (recursive-spawn guard, src/utils/mcp-self-identity.js) and so
+    // can never be used to detect a healthy registration — see
+    // utils/doctor-mcp-checks.js for the full rationale.
+    hasAmicusRegistration: () => require('./utils/mcp-discovery').hasAmicusRegistration(),
     inspectLegacyMcpEntries: () => require('./utils/legacy-mcp-migration').inspectAllLegacySidecarEntries(),
     migrateLegacyMcpEntries: () => require('./utils/legacy-mcp-migration').migrateLegacySidecar(),
     skillInstalled: () => {
@@ -48,8 +55,13 @@ function realDeps() {
       return fs.existsSync(path.join(dir, 'sidecar', 'SKILL.md'))
         && fs.existsSync(path.join(dir, 'second-opinion', 'SKILL.md'));
     },
+    now: () => Date.now(),
+    listSessionIndexTmpFiles: () => tmpSweep.listSessionIndexTmpFiles(), // B15
+    unlinkSessionIndexTmp: (n) => tmpSweep.unlinkSessionIndexTmp(n),
   };
 }
+// B15: sweep logic in utils/session-index-tmp-sweep.js (mirrors mcp-legacy's split).
+const tmpSweep = require('./utils/session-index-tmp-sweep');
 
 /** Run one guarded check; a thrown fn becomes an error line. */
 function guard(id, name, fn) {
@@ -170,59 +182,14 @@ async function runDoctorChecks(depsOverride = {}) {
       : { id: 'skills', name: 'Skills installed', status: 'warn', message: 'one or both skills missing', hint: `${HINTS.reinstall}  (re-runs the skill install)` }
   )));
 
-  checks.push(guard('mcp', 'MCP registration', () => {
-    const code = d.discoverClaudeCodeMcps();
-    const cowork = d.discoverCoworkMcps();
-    const inCode = !!(code && code.amicus);
-    const inCowork = !!(cowork && cowork.amicus);
-    // Primary signal: Claude Code MCP registration. Cowork/Desktop is reported as bonus only.
-    if (!inCode) {
-      return { id: 'mcp', name: 'MCP registration', status: 'warn', message: 'not registered in Claude Code', hint: `${HINTS.reinstall}  (or install the amicus plugin)` };
-    }
-    const extra = inCowork ? ', Cowork/Desktop' : '';
-    return { id: 'mcp', name: 'MCP registration', status: 'ok', message: `registered: Claude Code${extra}`, hint: null };
-  }));
+  checks.push(guard('mcp', 'MCP registration', () => mcpChecks.evaluateMcpRegistration(d)));
 
-  // Duplicate legacy 'sidecar' MCP registration (same server twice — doubles
-  // the client-visible tool list). Detection reads the raw config files via
-  // legacy-mcp-migration: mcp-discovery can't see it (it strips 'sidecar' as
-  // its own recursion guard). --fix removes only identical-in-effect twins.
-  checks.push(guard('mcp-legacy', 'Legacy sidecar MCP entry', () => {
-    const id = 'mcp-legacy'; const name = 'Legacy sidecar MCP entry';
-    const entries = d.inspectLegacyMcpEntries() || [];
-    const dupes = entries.filter(e => e.status === 'removable');
-    const custom = entries.filter(e => e.status === 'customized');
-    // An unreadable config is neither "no problem" nor a duplicate we can act
-    // on — reporting it as ok/'none' would hide a config doctor (and --fix)
-    // could not actually inspect. Always surface it, even alongside dupes.
-    const unreadable = entries.filter(e => e.status === 'unreadable');
-    const unreadableNote = unreadable.length
-      ? `${unreadable.map(e => e.target).join(', ')} config unreadable — skipped`
-      : null;
-    if (dupes.length === 0) {
-      if (unreadableNote) {
-        const suffix = custom.length ? `; custom 'sidecar' entry in ${custom.map(e => e.target).join(', ')} — left alone` : '';
-        return { id, name, status: 'warn', message: `${unreadableNote}${suffix}`, hint: null };
-      }
-      const message = custom.length
-        ? `custom 'sidecar' entry in ${custom.map(e => e.target).join(', ')} — left alone`
-        : 'none';
-      return { id, name, status: 'ok', message, hint: null };
-    }
-    if (d.fix) {
-      const removed = (d.migrateLegacyMcpEntries() || []).filter(r => r.result === 'removed');
-      if (removed.length >= dupes.length) {
-        const message = `removed legacy entry from: ${removed.map(r => r.target).join(', ')}`;
-        return unreadableNote
-          ? { id, name, status: 'warn', message: `${message}; ${unreadableNote}`, hint: HINTS.removeLegacySidecar }
-          : { id, name, status: 'ok', message, hint: null };
-      }
-      const message = `removed ${removed.length}/${dupes.length} duplicate(s) — could not update every config`;
-      return { id, name, status: 'warn', message: unreadableNote ? `${message}; ${unreadableNote}` : message, hint: HINTS.removeLegacySidecar };
-    }
-    const message = `duplicate 'sidecar' entry in ${dupes.map(e => e.target).join(', ')} — doubles the MCP tool list`;
-    return { id, name, status: 'warn', message: unreadableNote ? `${message}; ${unreadableNote}` : message, hint: HINTS.removeLegacySidecar };
-  }));
+  // Duplicate legacy 'sidecar' MCP registration check — logic lives in
+  // utils/doctor-mcp-checks.js (mirrors the B15 tmpSweep split) to keep this
+  // file under the 300-line size gate.
+  checks.push(guard('mcp-legacy', 'Legacy sidecar MCP entry', () => mcpChecks.evaluateLegacyMcpEntry(d)));
+
+  checks.push(guard('sessions-index-tmp', 'Session index tmp files', () => tmpSweep.evaluateSessionIndexTmpSweep(d)));
 
   // #43: OpenRouter credit/free-tier — warns (never errors); skipped when no key.
   checks.push(await guardAsync('openrouter-credit', 'OpenRouter credit', async () => {

package/src/cli-handlers-resume-continue.js

@@ -0,0 +1,103 @@
+/**
+ * CLI Resume/Continue Handlers (B21-rest extraction)
+ *
+ * Split out of src/cli-handlers-run.js (which stayed over the 300-line size
+ * gate once --json plumbing landed here) — same extraction rationale as the
+ * original WS-2 split of bin/amicus.js.
+ *
+ * Contains: handleResume, handleContinue
+ */
+
+'use strict';
+
+const { resolveModelFromArgs, validateFallbackModel } = require('./utils/start-helpers');
+const { failJson, ERROR_CODES } = require('./utils/error-doc');
+const { requireNoUiForJson, requireValidTaskId } = require('./utils/cli-preflight');
+
+/**
+ * Handle 'amicus resume' command
+ * Spec Reference: §4.3
+ */
+async function handleResume(args) {
+  const useJson = !!args.json;
+  const taskId = requireValidTaskId(args, useJson, 'resume', 'Usage: amicus resume <task_id>');
+  requireNoUiForJson(args, useJson);
+
+  const { resumeAmicus } = require('./index');
+
+  try {
+    return await resumeAmicus({
+      taskId,
+      project: args.cwd,
+      headless: args['no-ui'],
+      timeout: args.timeout,
+      json: useJson,
+    });
+  } catch (err) {
+    // resumeSidecar throws a plain Error before it has a chance to consult
+    // `json` (e.g. the session directory doesn't exist) — under --json that
+    // must still land as ONE parseable envelope on stdout, not an uncaught
+    // throw. Non-json mode is unaffected: re-throw so bin/amicus.js's
+    // existing top-level catch prints `Error: <message>` exactly as before.
+    if (!useJson) { throw err; }
+    process.exit(failJson(true, { code: ERROR_CODES.BAD_SESSION, message: err.message }));
+  }
+}
+
+/**
+ * Handle 'amicus continue' command
+ * Spec Reference: §4.4
+ */
+async function handleContinue(args) {
+  const useJson = !!args.json;
+  const taskId = requireValidTaskId(args, useJson, 'continue', 'Usage: amicus continue <task_id> --prompt "..."');
+
+  // BL-1: accept --prompt-file (XOR --prompt) so the MCP handler can pass a long
+  // follow-up prompt via file, dodging the ~32KB Windows command-line cap.
+  if (args['prompt-file'] !== undefined) {
+    const { resolvePromptSource } = require('./utils/prompt-source');
+    const promptRes = resolvePromptSource(args);
+    if (promptRes.error) {
+      process.exit(failJson(useJson, { code: ERROR_CODES.MISSING_PROMPT, message: promptRes.error }));
+    }
+    args.prompt = promptRes.prompt;
+    delete args['prompt-file'];
+  }
+
+  if (!args.prompt && !args.briefing) {
+    process.exit(failJson(useJson, { code: ERROR_CODES.MISSING_PROMPT, message: 'Error: --prompt is required for continue' }));
+  }
+
+  requireNoUiForJson(args, useJson);
+
+  // F5: an explicitly passed --model gets the same resolution+validation as start.
+  if (args.model !== undefined) {
+    const { model, alias } = resolveModelFromArgs(args);
+    args.model = model;
+    args.model = await validateFallbackModel(args, alias);
+  }
+
+  const { continueAmicus } = require('./index');
+
+  try {
+    return await continueAmicus({
+      taskId,
+      newTaskId: args['task-id'],
+      briefing: args.prompt || args.briefing,
+      model: args.model,
+      project: args.cwd,
+      contextTurns: args['context-turns'],
+      contextMaxTokens: args['context-max-tokens'],
+      headless: args['no-ui'],
+      timeout: args.timeout,
+      json: useJson,
+    });
+  } catch (err) {
+    // Same rationale as handleResume above: continueSidecar/loadPreviousSession
+    // throws before consulting `json` when the PREVIOUS session doesn't exist.
+    if (!useJson) { throw err; }
+    process.exit(failJson(true, { code: ERROR_CODES.BAD_SESSION, message: err.message }));
+  }
+}
+
+module.exports = { handleResume, handleContinue };

package/src/cli-handlers-run.js

@@ -5,7 +5,9 @@
  * size gate and to make handlers unit-testable without running main().
  *
  * Contains: handleStart, handleFanout, handleRead
- * Remaining inline in bin/amicus.js: handleList, handleResume, handleContinue
+ * See also: src/cli-handlers-resume-continue.js (handleResume, handleContinue —
+ * split out to stay under the size gate) and src/cli-handlers.js (handleList
+ * remains inline in bin/amicus.js).
  */
 
 'use strict';
@@ -14,6 +16,7 @@ const { validateStartArgs } = require('./cli');
 const { validateTaskId } = require('./utils/validators');
 const { resolveModelFromArgs, validateFallbackModel } = require('./utils/start-helpers');
 const { failJson, ERROR_CODES } = require('./utils/error-doc');
+const { requireNoUiForJson } = require('./utils/cli-preflight');
 
 /**
  * Handle 'sidecar start' command
@@ -33,9 +36,7 @@ async function handleStart(args) {
     // prompt-file set and trip its mutually-exclusive branch.
     delete args['prompt-file'];
   }
-  if (args.json && !args['no-ui']) {
-    process.exit(failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: 'Error: --json requires --no-ui' }));
-  }
+  requireNoUiForJson(args, useJson);
 
   const mc = args['max-cost'];
   if (mc !== undefined && (typeof mc !== 'number' || !Number.isFinite(mc) || mc <= 0)) {
@@ -68,9 +69,9 @@ async function handleStart(args) {
     }
   }
 
-  const { startSidecar } = require('./index');
+  const { startAmicus } = require('./index');
 
-  return await startSidecar({
+  return await startAmicus({
     taskId: args['task-id'],
     model: args.model,
     prompt: args.prompt,
@@ -212,9 +213,9 @@ async function handleRead(args) {
     process.exit(failJson(useJson, { code: ERROR_CODES.BAD_SESSION, message: taskIdCheck.error }));
   }
 
-  const { readSidecar } = require('./index');
+  const { readAmicus } = require('./index');
 
-  await readSidecar({
+  await readAmicus({
     taskId,
     conversation: args.conversation,
     metadata: args.metadata,

package/src/cli-handlers-spend.js

@@ -0,0 +1,198 @@
+// src/cli-handlers-spend.js
+'use strict';
+
+/**
+ * `amicus spend` — cross-run cost rollup over spend-ledger.jsonl (B24).
+ * Mirrors cli-handlers-doctor.js's injectable-deps shape (a `depsOverride`
+ * parameter tests can use to stub I/O/network) and cli-handlers-council.js's
+ * command-file split (kept its own file to stay well under the size gate).
+ *
+ * buildSpendDoc() lives HERE rather than in src/utils/result-schema.js: that
+ * module is at its 300-line size-gate ceiling (filled by a parallel lane in
+ * this same phase), so this module defines its own doc builder using the
+ * SAME schemaVersion convention (result-schema's SCHEMA_VERSION, imported —
+ * not a forked/independent counter) rather than adding to a full file. If
+ * result-schema.js is ever split/slimmed, buildSpendDoc is the one to fold
+ * back in alongside buildCatalogDoc/buildDoctorDoc.
+ */
+
+const { readSpendRows } = require('./utils/spend-ledger');
+const { formatCost } = require('./utils/pricing');
+const { failJson, ERROR_CODES } = require('./utils/error-doc');
+
+const CREDIT_CHECK_TIMEOUT_MS = 5000;
+
+/** @param {string} since e.g. '7d' @returns {number|null} whole days, or null if unparseable */
+function parseSinceDays(since) {
+  if (typeof since !== 'string') { return null; }
+  const m = since.trim().match(/^(\d+)d$/i);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+function emptyTokens() {
+  return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
+}
+
+function addTokens(into, tokens) {
+  if (!tokens) { return; }
+  for (const k of Object.keys(into)) { into[k] += tokens[k] || 0; }
+}
+
+/**
+ * Aggregate ledger rows into a total + per-model rollup, most-expensive-first.
+ * A row with a null cost.amount contributes 0 to totals but is still counted
+ * in `runs` and its source bucket — visibility into "how many runs are
+ * unpriced" matters as much as the dollar figure.
+ * @param {Array<object>} rows
+ */
+function aggregateSpend(rows) {
+  const total = { amount: 0, tokens: emptyTokens(), runs: rows.length, sourceMix: { reported: 0, estimated: 0, unknown: 0 } };
+  const byModelMap = new Map();
+  for (const r of rows) {
+    const model = r.model || 'unknown';
+    if (!byModelMap.has(model)) {
+      byModelMap.set(model, { model, amount: 0, tokens: emptyTokens(), runs: 0, sourceMix: { reported: 0, estimated: 0, unknown: 0 } });
+    }
+    const bucket = byModelMap.get(model);
+    bucket.runs += 1;
+    addTokens(bucket.tokens, r.tokens);
+    addTokens(total.tokens, r.tokens);
+    const cost = r.cost || {};
+    const amount = typeof cost.amount === 'number' ? cost.amount : 0;
+    bucket.amount += amount;
+    total.amount += amount;
+    // Any source string outside {reported,estimated} buckets as unknown —
+    // covers 'unknown', a missing/malformed cost block, or a future source.
+    const src = (cost.source === 'reported' || cost.source === 'estimated') ? cost.source : 'unknown';
+    bucket.sourceMix[src] += 1;
+    total.sourceMix[src] += 1;
+  }
+  const byModel = [...byModelMap.values()].sort((a, b) => b.amount - a.amount);
+  return { total, byModel };
+}
+
+/**
+ * Build the `--json` spend document. schemaVersion reuses result-schema's
+ * SCHEMA_VERSION (not a forked counter) — see module docblock for why this
+ * builder lives here instead of alongside buildCatalogDoc/buildDoctorDoc.
+ * @param {{total:object, byModel:Array, windowDays:number|null, credit:object|null}} opts
+ */
+function buildSpendDoc({ total, byModel, windowDays, credit }) {
+  const { SCHEMA_VERSION } = require('./utils/result-schema');
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    type: 'spend',
+    windowDays: windowDays !== undefined ? windowDays : null,
+    total,
+    byModel,
+    credit: credit || null,
+  };
+}
+
+/** Real deps; tests override via the second handleSpend arg. */
+function realDeps() {
+  return {
+    dir: undefined, // readSpendRows falls back to getConfigDir() itself
+    readApiKeyValues: () => require('./utils/api-key-store').readApiKeyValues(),
+    checkOpenRouterCredit: (key) => require('./utils/api-key-validation').checkOpenRouterCredit(key),
+    now: () => Date.now(),
+  };
+}
+
+/** Race a promise against a hard timeout; resolves `fallback` on timeout — never rejects, never hangs the caller. */
+function withTimeout(promise, ms, fallback) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => { if (!settled) { settled = true; resolve(fallback); } }, ms);
+    Promise.resolve(promise).then(
+      (v) => { if (!settled) { settled = true; clearTimeout(timer); resolve(v); } },
+      () => { if (!settled) { settled = true; clearTimeout(timer); resolve(fallback); } },
+    );
+  });
+}
+
+/**
+ * Best-effort OpenRouter credit footer. Never throws; never blocks past
+ * ~CREDIT_CHECK_TIMEOUT_MS; skipped (returns null) when no key is configured.
+ */
+async function fetchCreditFooter(deps) {
+  let values = {};
+  try { values = deps.readApiKeyValues() || {}; } catch { /* best-effort */ }
+  const key = values.openrouter;
+  if (!key) { return null; }
+  const res = await withTimeout(
+    Promise.resolve().then(() => deps.checkOpenRouterCredit(key)),
+    CREDIT_CHECK_TIMEOUT_MS,
+    null,
+  );
+  return res || null;
+}
+
+function renderHuman({ total, byModel, windowDays, credit }) {
+  if (total.runs === 0) { return 'No spend recorded yet.\n'; }
+  let out = windowDays ? `amicus spend (last ${windowDays}d)\n\n` : 'amicus spend (all time)\n\n';
+  out += 'model                                            runs  tokens(in/out)      cost      sources\n';
+  for (const m of byModel) {
+    const mix = `r${m.sourceMix.reported}/e${m.sourceMix.estimated}/u${m.sourceMix.unknown}`;
+    const tokCol = `${m.tokens.input}/${m.tokens.output}`;
+    out += `${String(m.model).slice(0, 48).padEnd(48)} ${String(m.runs).padStart(4)}  ` +
+      `${tokCol.padStart(15)}  ` +
+      `${formatCost({ amount: m.amount, source: dominantSource(m.sourceMix) }).padStart(9)}  ${mix}\n`;
+  }
+  out += `\nTotal: ${formatCost({ amount: total.amount, source: dominantSource(total.sourceMix) })} across ${total.runs} run(s)\n`;
+  if (credit && typeof credit.limitRemaining === 'number') {
+    out += `OpenRouter credit remaining: $${credit.limitRemaining}\n`;
+  }
+  return out;
+}
+
+/** Pick a representative source tag for formatCost's ~ prefix: mixed if >1 bucket populated. */
+function dominantSource(mix) {
+  const populated = Object.entries(mix).filter(([, n]) => n > 0).map(([k]) => k);
+  if (populated.length === 0) { return 'unknown'; }
+  if (populated.length > 1) { return 'mixed'; }
+  return populated[0];
+}
+
+/**
+ * `amicus spend [--since 7d] [--json]`
+ * @param {{_:string[], json?:boolean, since?:string}} args
+ * @param {object} [depsOverride] test seam
+ * @returns {Promise<number>} exit code
+ */
+async function handleSpend(args, depsOverride = {}) {
+  const useJson = !!args.json;
+  const deps = { ...realDeps(), ...depsOverride };
+
+  let windowDays = null;
+  if (args.since !== undefined) {
+    windowDays = parseSinceDays(args.since);
+    if (windowDays === null) {
+      return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `invalid --since '${args.since}'`,
+        hint: "amicus spend --since 7d  (an integer followed by 'd')" });
+    }
+  }
+
+  let rows = readSpendRows(deps.dir);
+  if (windowDays !== null) {
+    const cutoff = deps.now() - windowDays * 86400000;
+    rows = rows.filter(r => {
+      const t = Date.parse(r.ts);
+      return Number.isFinite(t) && t >= cutoff;
+    });
+  }
+
+  const { total, byModel } = aggregateSpend(rows);
+  // Nothing recorded (or nothing in the --since window): skip the network
+  // credit probe entirely — there's no rollup to attach it to either way.
+  const credit = total.runs === 0 ? null : await fetchCreditFooter(deps).catch(() => null);
+
+  if (useJson) {
+    process.stdout.write(JSON.stringify(buildSpendDoc({ total, byModel, windowDays, credit }), null, 2) + '\n');
+    return 0;
+  }
+  process.stdout.write(renderHuman({ total, byModel, windowDays, credit }));
+  return 0;
+}
+
+module.exports = { handleSpend, aggregateSpend, buildSpendDoc, parseSinceDays };

package/src/cli-handlers.js

@@ -5,9 +5,11 @@
  * under the 300-line limit.
  */
 
-const fs = require('fs');
-const path = require('path');
-const { validateTaskId, safeSessionDir } = require('./utils/validators');
+'use strict';
+
+// handleAbort moved to src/cli-handlers-abort.js (B21-rest: --json branch
+// needed headroom this file didn't have). Re-exported below for compatibility.
+const { handleAbort } = require('./cli-handlers-abort');
 
 /**
  * Handle 'amicus setup' command
@@ -64,123 +66,6 @@ async function handleSetup(args) {
   await runInteractiveSetup();
 }
 
-/**
- * Handle 'sidecar abort' command
- * Marks a running session as aborted
- */
-async function handleAbort(args) {
-  if (args.all) {
-    const project = args.cwd || process.cwd();
-    const { enumerateSessions } = require('./sidecar/read');
-    const { markAborted } = require('./utils/session-abort');
-    const { resolveExistingSessionDir } = require('./session-manager');
-    // A session may complete between enumeration and the write (TOCTOU); the
-    // window is tiny for a local CLI and markAborted is best-effort, so we count
-    // only sessions actually marked aborted.
-    const running = enumerateSessions(project, { status: 'running' });
-    if (running.length === 0) {
-      console.log('No running sessions to abort.');
-      return;
-    }
-    let aborted = 0;
-    for (const s of running) {
-      if (markAborted(resolveExistingSessionDir(project, s.id), 'abort --all')) {
-        aborted++;
-        console.log(`Aborted ${s.id}`);
-      }
-    }
-    console.log(`Aborted ${aborted} running session(s).`);
-    return;
-  }
-
-  const taskId = args._[1];
-
-  if (!taskId) {
-    console.error('Error: task_id is required for abort');
-    console.error('Usage: amicus abort <task_id>');
-    process.exit(1);
-  }
-
-  const taskIdCheck = validateTaskId(taskId);
-  if (!taskIdCheck.valid) {
-    console.error(taskIdCheck.error);
-    process.exit(1);
-  }
-
-  const project = args.cwd || process.cwd();
-  const sessionDir = safeSessionDir(project, taskId);
-  const metaPath = path.join(sessionDir, 'metadata.json');
-
-  if (!fs.existsSync(metaPath)) {
-    console.error(`Session ${taskId} not found`);
-    process.exit(1);
-  }
-
-  let meta;
-  try {
-    meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
-  } catch (_err) {
-    console.error(`Session ${taskId} has malformed metadata`);
-    process.exit(1);
-  }
-  // Guard against a completed/terminal session: without this, metadata.pid
-  // still holds a value forever and `amicus abort <completed-task>` would
-  // wait the grace window then TerminateProcess whatever unrelated process
-  // now owns that (possibly recycled) pid. Mirrors MCP's amicus_abort guard
-  // (src/mcp-server.js) — same wording, no re-mark, no kill.
-  if (meta.status !== 'running') {
-    console.log(`Session ${taskId} is not running (status: ${meta.status}).`);
-    return;
-  }
-
-  const { markAborted } = require('./utils/session-abort');
-
-  // F4: aborting a wave aborts every still-running leg too.
-  if (meta.type === 'wave') {
-    const { resolveExistingSessionDir } = require('./session-manager');
-    let aborted = 0;
-    for (const legId of meta.legs || []) {
-      const legDir = resolveExistingSessionDir(project, legId);
-      try {
-        const legMeta = JSON.parse(fs.readFileSync(path.join(legDir, 'metadata.json'), 'utf-8'));
-        // TOCTOU: a leg may complete between this read and markAborted —
-        // best-effort, same contract as abort --all above.
-        if (legMeta.status === 'running') {
-          if (markAborted(legDir, 'wave abort')) { aborted++; }
-        }
-      } catch { /* skip unreadable leg */ }
-    }
-    markAborted(sessionDir, 'manual abort');
-    console.log(`Wave ${taskId} marked as aborted (${aborted} running leg(s) aborted).`);
-    return;
-  }
-
-  markAborted(sessionDir, 'manual abort');
-  console.log(`Session ${taskId} marked as aborted.`);
-
-  // Phase 3: fallback direct-kill for a session that does not honor the
-  // marker. Headless loops poll the marker every ~2s and the interactive
-  // abort watch does too, so the normal outcome is a graceful exit during
-  // the grace window; only a wedged/legacy process gets SIGTERM. The wait is
-  // awaited on purpose — bin/amicus.js arms its force-exit watchdog only
-  // after this handler returns.
-  if (meta.pid) {
-    const { waitThenKill, abortGraceMs } = require('./utils/abort-coordinator');
-    const graceSec = Math.ceil(abortGraceMs() / 1000);
-    console.log(`Waiting up to ${graceSec}s for the session process (pid ${meta.pid}) to exit gracefully...`);
-    const { killed, exited } = await waitThenKill(meta.pid);
-    if (killed.length > 0) {
-      console.log(`Process ${meta.pid} did not exit in time — sent SIGTERM (a hard kill on Windows).`);
-    } else if (exited.length > 0) {
-      console.log('Process exited cleanly.');
-    } else {
-      // 3.1 contract: an EPERM-unkillable pid lands in NEITHER array —
-      // it is still alive and we could not signal it. Say so honestly.
-      console.log(`Process ${meta.pid} is still running — could not signal it (insufficient permission). It may require manual termination.`);
-    }
-  }
-}
-
 /**
  * Handle 'amicus update' command
  * Updates amicus to the latest version