pi-harness-delegate 0.7.0 → 0.7.1

package/README.md

@@ -247,7 +247,7 @@ Config lives as a key inside pi's own `~/.pi/agent/settings.json` rather than a
 A per-run cap, resolved call → template → global config → per-harness config. How it's enforced depends on the harness, and the outcome is always recorded (tool result `details.budget`, a `- budget:` line in the transcript):
 
 - **Native** — `claude` gets `--max-budget-usd` and enforces it itself.
-- **Host-enforced (best-effort)** — harnesses with no budget flag that *do* stream a running cost (`opencode`, `amp`/`omp`, and `opencode` over ACP): the host checks the reported total each time the harness reports one and kills the run once it's over the cap, recording `budget exceeded` (`stopReason: budget_exceeded`, a `⛔ budget exceeded … run stopped` line at the top of the result, `(host-enforced, best-effort)` in the transcript). This is **not a hard cap**: cost is only visible at the step/turn boundaries the harness reports, so spend already incurred within the step that crossed the line can't be prevented — a run can overshoot by up to one step/turn (more if a single step is expensive). Use a native-budget harness (`claude`) when the cap must be strict. For `opencode` over ACP the reported cost is a session running total, so on a resumed session only the spend since this run started counts against the cap (the reported cost still includes prior turns).
+- **Host-enforced (best-effort)** — harnesses with no budget flag that *do* stream a running cost (`opencode`, `amp`/`omp`, and `opencode` over ACP): the host checks the reported total each time the harness reports one and kills the run once it's over the cap, recording `budget exceeded` (`stopReason: budget_exceeded`, a `⛔ budget exceeded … run stopped` line at the top of the result, `(host-enforced, best-effort)` in the transcript). This is **not a hard cap**: cost is only visible at the step/turn boundaries the harness reports, so spend already incurred within the step that crossed the line can't be prevented — a run can overshoot by up to one step/turn (more if a single step is expensive). Use a native-budget harness (`claude`) when the cap must be strict. For `opencode` over ACP the reported cost is a session running total, so on a resumed session only the spend since this run started counts against the cap, and the reported cost is just this run's share — or `—` (unmeasured) when the session didn't report its prior total before the new prompt, rather than an under-count.
 - **Not enforceable** — `codex` (no `$` cost on ChatGPT-plan auth) and `devin` report no cost and have no flag, so a budget can't be applied; the run proceeds and the result starts with `⚠ maxBudgetUsd … was not enforced`, never silently.
 
 ## Metrics recorded

package/extensions/acp-runner.ts

@@ -28,6 +28,7 @@ import {
   isOverBudget,
   type RunHarnessOptions,
 } from './runner.ts';
+import { appendActivities, appendStreamed } from './stream-caps.ts';
 
 /** Bound on the initial handshake (initialize / session/new / session/set_mode) so a hung agent
  *  doesn't wedge the whole `timeoutMs` budget before `session/prompt` — the actual work — even starts. */
@@ -66,6 +67,37 @@ function supportsSessionModes(sessionResult: unknown): boolean {
   return false;
 }
 
+/**
+ * The cost to report for *this* run of a session whose harness reports a session-cumulative running
+ * total (opencode over ACP: `usage_update.cost.amount`). On a fresh session that total is this run's
+ * spend as-is. On a resume it also includes every prior turn — reporting it unchanged would make
+ * `/delegate status`'s spend rollup count those turns again on every resume — so the delta since
+ * `baselineUsd` (the same baseline the host budget check uses; see `costBaseline` in
+ * `runAcpHarness`) is reported instead.
+ *
+ * When the baseline wasn't replayed before the prompt (`baselineFromReplay: false`) it is the first
+ * running total seen *after* the prompt, so any delta silently omits that first step's spend — an
+ * under-report that looks measured (with one sample it's even a fake "$0"). That case is reported
+ * as `null` (unmeasured), per the honest-metrics convention. The host budget check still uses that
+ * first-sample baseline on purpose (biased toward never killing a resumed run for prior turns'
+ * spend); only the *reported* figure refuses to guess. Pure.
+ */
+export function resumedRunCost(opts: {
+  totalCostUsd: number | null;
+  resumed: boolean;
+  baselineUsd: number | undefined;
+  baselineFromReplay: boolean;
+  postPromptCostSamples: number;
+}): number | null {
+  const { totalCostUsd, resumed, baselineUsd, baselineFromReplay, postPromptCostSamples } = opts;
+  if (!resumed || totalCostUsd === null) return totalCostUsd;
+  // no cost reported during this run at all — whatever total we hold is prior turns' spend
+  if (baselineUsd === undefined || postPromptCostSamples === 0) return null;
+  // baseline is this run's own first sample: the true spend is unknowable, not "the delta"
+  if (!baselineFromReplay) return null;
+  return Math.max(0, totalCostUsd - baselineUsd);
+}
+
 /** Placeholder for a run the host stops mid-turn before the harness produced anything result-shaped. */
 function emptyResult(): StreamedResult {
   return {
@@ -92,7 +124,14 @@ interface PendingRequest {
   timer?: ReturnType<typeof setTimeout>;
 }
 
-export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
+/** Test-only knobs — production callers pass only `opts`. */
+export interface AcpRunnerInternals {
+  /** Overrides `HANDSHAKE_TIMEOUT_MS` so a hung-handshake test doesn't take 30s. */
+  handshakeTimeoutMs?: number;
+}
+
+export function runAcpHarness(opts: RunHarnessOptions, internals: AcpRunnerInternals = {}): Promise<HarnessResult> {
+  const handshakeTimeoutMs = internals.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
     // Already cancelled (e.g. the user hit cancel while this run was still being set up) —
     // never spawn a process just to kill it.
@@ -112,6 +151,10 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
     });
 
     const proc = spawn(opts.harness.binary, args, { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+    // A write to a child that already exited surfaces as an async EPIPE 'error' on stdin — not as a
+    // throw from write() (writeLine's try/catch can't see it). Unhandled, that event would crash the
+    // host process; the run itself already ends through the 'close'/timeout/abort paths.
+    proc.stdin.on('error', () => {});
 
     const state: ParseState = { streamedText: '', activities: [], result: null, _harness: {} };
     let stderr = '';
@@ -129,9 +172,8 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
     // never killing a resumed run for spend it didn't incur.
     let prePromptCost: number | undefined;
     let costBaseline: number | undefined;
+    let postPromptCostSamples = 0;
     const startAt = Date.now();
-    const MAX_STREAMED = 5 * 1024 * 1024; // 5MB cap to prevent OOM on compromised harness
-    const MAX_ACTIVITIES = 5000;
 
     let nextId = 1;
     const pending = new Map<number, PendingRequest>();
@@ -145,6 +187,14 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
       const ttft = firstTokenAt !== null ? firstTokenAt - startAt : r.ttftMs;
       resolve({
         ...r,
+        // a resumed session's running total includes prior turns — report only this run's share
+        totalCostUsd: resumedRunCost({
+          totalCostUsd: r.totalCostUsd,
+          resumed: Boolean(opts.resumeSessionId),
+          baselineUsd: costBaseline,
+          baselineFromReplay: prePromptCost !== undefined,
+          postPromptCostSamples,
+        }),
         ttftMs: ttft,
         streamedText: state.streamedText,
         harness: opts.harness.name,
@@ -261,6 +311,7 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
       if (typeof outcome.runningCostUsd === 'number') {
         if (!promptSent) prePromptCost = outcome.runningCostUsd;
         else {
+          postPromptCostSamples++;
           costBaseline ??= outcome.runningCostUsd;
           if (!settled && isCostOverBudget(opts.harness, opts.maxBudgetUsd, outcome.runningCostUsd, costBaseline)) {
             proc.kill('SIGKILL');
@@ -285,24 +336,9 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
       // is sent — on a resume that's the replayed prior conversation, not the new turn's own output.
       if (promptSent && outcome.streamedText) {
         if (firstTokenAt === null) firstTokenAt = Date.now();
-        if (state.streamedText.length < MAX_STREAMED) {
-          const remaining = MAX_STREAMED - state.streamedText.length;
-          const chunk =
-            outcome.streamedText.length > remaining
-              ? `${outcome.streamedText.slice(0, remaining)} [truncated ${outcome.streamedText.length - remaining} chars]`
-              : outcome.streamedText;
-          state.streamedText += chunk;
-          opts.onStream?.(chunk);
-        }
-      }
-      if (promptSent && outcome.activities) {
-        for (const a of outcome.activities) {
-          if (state.activities.length < MAX_ACTIVITIES) {
-            state.activities.push(a);
-            opts.onActivity?.(a);
-          }
-        }
+        appendStreamed(state, outcome.streamedText, opts.onStream); // capped — see stream-caps.ts
       }
+      if (promptSent && outcome.activities) appendActivities(state, outcome.activities, opts.onActivity);
       if (outcome.result) {
         if (!outcome.result.result) outcome.result.result = state.streamedText;
         state.result = outcome.result;
@@ -370,7 +406,7 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
           protocolVersion: PROTOCOL_VERSION,
           clientCapabilities: {}, // no fs/terminal proxying — decline those requests if asked (see handleServerRequest)
         },
-        HANDSHAKE_TIMEOUT_MS,
+        handshakeTimeoutMs,
       );
       if (settled) return;
       // The client "should disconnect" (spec text) if the agent didn't echo back the version we
@@ -398,11 +434,11 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
         sessionResult = await sendRequest(
           'session/load',
           { sessionId: opts.resumeSessionId, ...sessionParams },
-          HANDSHAKE_TIMEOUT_MS,
+          handshakeTimeoutMs,
         );
         sessionId = opts.resumeSessionId;
       } else {
-        sessionResult = await sendRequest('session/new', sessionParams, HANDSHAKE_TIMEOUT_MS);
+        sessionResult = await sendRequest('session/new', sessionParams, handshakeTimeoutMs);
         sessionId =
           isRecord(sessionResult) && typeof sessionResult.sessionId === 'string' ? sessionResult.sessionId : null;
       }
@@ -428,7 +464,7 @@ export function runAcpHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
             `cannot verify the "${opts.permission}" permission tier would be honored over ACP`,
         );
       }
-      await sendRequest('session/set_mode', { sessionId, modeId }, HANDSHAKE_TIMEOUT_MS);
+      await sendRequest('session/set_mode', { sessionId, modeId }, handshakeTimeoutMs);
       if (settled) return;
       promptSent = true;
       costBaseline = opts.resumeSessionId ? prePromptCost : 0;

package/extensions/command.ts

@@ -26,20 +26,91 @@ export interface DelegateCommandArgs {
    * — never inherited from config, never applied headless. Absent unless explicitly true.
    */
   allowDangerous?: boolean;
+  /** Flag values that were given but are unusable (e.g. `--budget=0`) — the handler reports these
+   *  and runs nothing, rather than silently dropping the flag. Absent when there are none. */
+  errors?: string[];
+  /** Non-fatal heads-ups the handler shows before running — e.g. a recognized `--flag=` that sat
+   *  inside a double-quoted span and so was kept as prompt text, not applied. Absent when none. */
+  notices?: string[];
 }
 
 export type ClaudeCommandArgs = DelegateCommandArgs;
 
-const KNOWN_HARNESSES = new Set(['claude', 'codex', 'opencode', 'amp', 'omp']);
+/**
+ * The flag set every `/delegate`-family command accepts after the harness — the single source for
+ * the `/delegate` description, its usage warning, and every alias command's (`/claude`, `/omp`, …)
+ * description, so the hints can't drift from what `parseDelegateCommand` actually parses.
+ */
+export const COMMAND_FLAGS_HINT =
+  '[--mode=review|plan|implement|security-audit|docs|general] [--model=…] [--scope=diff|pr|paths] [--pr=<n|url>] [--budget=<usd>] [--verify=<cmd>] [--resume=<id>] [--add-dir=<path>] [--allow-dangerous] <prompt>';
+
+/** Usage line for `/delegate` itself. */
+export function delegateUsage(): string {
+  return `/delegate [--harness=claude|codex|opencode|amp|devin|all|<a,b>] ${COMMAND_FLAGS_HINT}`;
+}
+
+/** Usage line for an alias command (`/claude`, `/omp`, …) — same flags, harness fixed. */
+export function aliasUsage(command: string): string {
+  return `/${command} ${COMMAND_FLAGS_HINT}`;
+}
 
-/** True when `word` is `all`, a single known harness/alias, or a comma-separated list of them. */
+const KNOWN_HARNESSES = new Set(['claude', 'codex', 'opencode', 'amp', 'omp', 'devin']);
+const HARNESS_ALIASES: Readonly<Record<string, string>> = { omp: 'amp' };
+
+/** True when `word` is `all`, a single known harness/alias, or a comma-separated list of them
+ *  (a stray empty element, e.g. the trailing comma in `claude,`, is ignored). */
 function looksLikeHarnessSpec(word: string, knownHarnesses: ReadonlySet<string>): boolean {
   const lower = word.toLowerCase();
   if (lower === 'all' || knownHarnesses.has(lower)) return true;
+  if (!lower.includes(',')) return false;
   const parts = lower.split(',').filter(Boolean);
-  return parts.length > 1 && parts.every(p => knownHarnesses.has(p));
+  return parts.length > 0 && parts.every(p => knownHarnesses.has(p));
+}
+
+/**
+ * Normalize a harness spec the same way whether it came from `--harness=` or the first word:
+ * lowercased, empty list elements dropped (`claude,` -> `claude`, `,` -> none), and a single name
+ * alias-normalized (`omp` -> `amp`). A real list / `all` is left for `resolveHarnessList`.
+ */
+function normalizeHarnessSpec(spec: string): string | undefined {
+  const parts = spec
+    .toLowerCase()
+    .split(',')
+    .map(p => p.trim())
+    .filter(Boolean);
+  if (parts.length === 0) return undefined;
+  if (parts.length === 1) return HARNESS_ALIASES[parts[0]] ?? parts[0];
+  return parts.join(',');
 }
 
+/**
+ * One pass over the raw command: a backticked or double-quoted prose span is skipped verbatim (so
+ * `explain "--mode=x"` or `` `--allow-dangerous` `` in the prompt is never eaten as a flag); a
+ * `--key=value` (value bare, "double" or 'single' quoted, or empty) or bare `--allow-dangerous` /
+ * `--budget` token that starts a word is a flag. Every other `--word` stays in the text untouched.
+ */
+const FLAG_OR_PROSE = /`[^`]*`|"[^"]*"|(^|\s)--([a-zA-Z][a-zA-Z-]*)(?:=(?:"([^"]*)"|'([^']*)'|(\S*))|(?=\s|$))/g;
+
+/** Every flag `parseDelegateCommand` acts on — used to notice one stranded inside quoted prose. */
+const RECOGNIZED_FLAGS = new Set([
+  'harness',
+  'mode',
+  'model',
+  'scope',
+  'budget',
+  'resume',
+  'pr',
+  'verify',
+  'add-dir',
+  'allow-dangerous',
+]);
+
+/** A recognized flag token starting a word inside a prose span (quote/backtick counts as a word start). */
+const FLAG_IN_PROSE = /(?:^|[\s"`])--([a-zA-Z][a-zA-Z-]*)(?==|[\s"`]|$)/g;
+
+/** Prose spans as FLAG_OR_PROSE pairs them; whatever delimiter is left over afterwards is unmatched. */
+const PROSE_SPAN = /`[^`]*`|"[^"]*"/g;
+
 export function parseDelegateCommand(
   raw: string,
   knownModes: ReadonlySet<string>,
@@ -47,27 +118,76 @@ export function parseDelegateCommand(
 ): DelegateCommandArgs {
   const flags: Record<string, string> = {};
   const addDirs: string[] = [];
-  // supports quoted values ("…"/'…') so multi-word flags like --verify="bun test" survive intact
-  let rest = raw.replace(
-    /--([a-zA-Z-]+)=(?:"([^"]*)"|'([^']*)'|(\S+))/g,
-    (_m, k: string, dq: string | undefined, sq: string | undefined, bare: string | undefined) => {
+  const errors: string[] = [];
+  const notices: string[] = [];
+  let allowDangerousBare = false;
+  let budgetWithoutValue = false;
+  const rest = raw.replace(
+    FLAG_OR_PROSE,
+    (
+      m: string,
+      lead: string | undefined,
+      k: string | undefined,
+      dq: string | undefined,
+      sq: string | undefined,
+      bare: string | undefined,
+    ) => {
+      if (k === undefined) {
+        // quoted/backticked prose — left alone. A double-quoted span holding a recognized flag is
+        // most likely an accident (`fix "bug --budget=5 and "more`): say so instead of dropping it
+        // silently. Backticks are the deliberate "this is literal" marker, so they stay quiet.
+        if (m.startsWith('"')) {
+          for (const [, name] of m.matchAll(FLAG_IN_PROSE)) {
+            if (!RECOGNIZED_FLAGS.has(name)) continue;
+            notices.push(
+              `--${name} inside double quotes was kept as prompt text, not applied — move it outside the quotes to use it as a flag`,
+            );
+          }
+        }
+        return m;
+      }
+      const hasValue = dq !== undefined || sq !== undefined || bare !== undefined;
+      if (!hasValue) {
+        // bare boolean flag: only `--allow-dangerous`. A bare `--budget` (e.g. the space form
+        // `--budget 5`) is an explicit cap we can't honor — an error, never silently "no cap".
+        // Any other bare `--word` is prose.
+        if (k === 'budget') {
+          budgetWithoutValue = true;
+          return m;
+        }
+        if (k !== 'allow-dangerous') return m;
+        allowDangerousBare = true;
+        return lead ?? '';
+      }
       const value = dq ?? sq ?? bare ?? '';
       // --add-dir is the one repeatable flag — every occurrence is kept, in order
       if (k === 'add-dir') {
         if (value) addDirs.push(value);
       } else flags[k] = value;
-      return '';
+      return lead ?? '';
     },
   );
-  // bare boolean flag(s): `--allow-dangerous` with no `=value`. Run after the `--key=value` pass, so
-  // a quoted flag value (e.g. --verify="echo --allow-dangerous") is already gone and can't match.
-  let allowDangerousBare = false;
-  rest = rest.replace(/(^|\s)--allow-dangerous(?=\s|$)/g, (_m, lead: string) => {
-    allowDangerousBare = true;
-    return lead;
-  });
 
-  let harness = flags.harness?.toLowerCase();
+  // An unmatched `"` or backtick makes the pairing above a guess: in `fix "x --verify="echo ok"` the
+  // stray quote pairs with the flag's own opening quote, so the real flag is eaten as prose and
+  // whatever followed it is parsed as flags instead. Text before the first delimiter is outside any
+  // span however the quotes pair, so only a flag-shaped token at or after it is in play; when one
+  // is, refuse rather than guess — the result must not depend on quote parity.
+  const strayDelimiter = /["`]/.test(rest.replace(PROSE_SPAN, ''));
+  const firstDelimiter = raw.search(/["`]/);
+  const ambiguous = strayDelimiter && firstDelimiter >= 0 && /--[a-zA-Z]/.test(raw.slice(firstDelimiter));
+  if (ambiguous) {
+    errors.push(
+      'unbalanced " or ` in the command — flags around it can\'t be told apart from prompt text; close the quote (or remove it) and try again',
+    );
+  }
+  if (budgetWithoutValue && flags.budget === undefined) {
+    errors.push(
+      '--budget needs a value: use --budget=<usd> (or wrap the text in backticks if it is part of the prompt)',
+    );
+  }
+
+  let harness = flags.harness !== undefined ? normalizeHarnessSpec(flags.harness) : undefined;
   let mode = flags.mode;
   let task = rest.trim();
 
@@ -75,9 +195,7 @@ export function parseDelegateCommand(
   const words = task.split(/\s+/).filter(Boolean);
   let idx = 0;
   if (!harness && words[idx] && looksLikeHarnessSpec(words[idx], knownHarnesses)) {
-    harness = words[idx].toLowerCase();
-    // single-name alias normalization only — a list/`all` is resolved later by resolveHarnessList
-    if (harness === 'omp') harness = 'amp';
+    harness = normalizeHarnessSpec(words[idx]);
     idx++;
   }
   if (!mode && words[idx] && knownModes.has(words[idx])) {
@@ -93,14 +211,20 @@ export function parseDelegateCommand(
   if (flags.scope) out.scope = flags.scope;
   if (flags.budget !== undefined) {
     const budget = Number(flags.budget);
-    if (Number.isFinite(budget) && budget > 0) out.budget = budget;
+    // an explicit spend cap that can't be honored is an error, never silently "no cap"
+    if (flags.budget.trim() !== '' && Number.isFinite(budget) && budget > 0) out.budget = budget;
+    else errors.push(`--budget must be a positive number of USD (got "${flags.budget}")`);
   }
   if (flags.resume) out.sessionId = flags.resume;
   if (flags.pr) out.pr = flags.pr;
   if (flags.verify) out.verify = flags.verify;
   if (addDirs.length > 0) out.addDirs = addDirs;
   // `=true` is tolerated; any other explicit value (`=false`, `=yes`, …) means off — fail closed
-  if (allowDangerousBare || flags['allow-dangerous']?.toLowerCase() === 'true') out.allowDangerous = true;
+  // never grant danger off an ambiguous parse — the error above stops the run anyway, but fail closed
+  if (!ambiguous && (allowDangerousBare || flags['allow-dangerous']?.toLowerCase() === 'true'))
+    out.allowDangerous = true;
+  if (errors.length > 0) out.errors = errors;
+  if (notices.length > 0) out.notices = [...new Set(notices)];
   return out;
 }
 

package/extensions/concurrency.ts

@@ -39,6 +39,29 @@ export interface AcquireSlotOptions {
   /** Aborts a `wait: true` poll early. */
   signal?: AbortSignal;
   pollIntervalMs?: number;
+  /** Source of the poll jitter (see `pollDelayMs`) — injectable so tests stay deterministic. */
+  random?: () => number;
+  /** How a poll waits (default: an abortable `setTimeout`) — injectable so tests can observe the
+   *  actual delay each poll is given. */
+  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+
+/** Max extra delay added to each poll, as a fraction of `pollIntervalMs`. */
+export const POLL_JITTER_FRACTION = 0.25;
+
+/**
+ * One poll's wait: `pollIntervalMs` plus up to `POLL_JITTER_FRACTION` of it, at random. Without the
+ * jitter, every waiter of a fan-out (all launched in the same tick) re-checks in lockstep, so they
+ * keep hitting `acquireRunWithinLimits`'s write-then-recheck together — exactly the tight multi-way
+ * race that makes contenders all back off at once (a transient under-admission). Spreading the
+ * re-checks out breaks the lockstep. Pure given `random`.
+ */
+export function pollDelayMs(pollIntervalMs: number, random: () => number = Math.random): number {
+  // a non-finite draw (NaN would otherwise survive the clamp and make setTimeout fire at 0ms, i.e.
+  // a hot poll loop) gets no jitter
+  const raw = random();
+  const r = Number.isFinite(raw) ? Math.min(1, Math.max(0, raw)) : 0;
+  return pollIntervalMs + Math.floor(pollIntervalMs * POLL_JITTER_FRACTION * r);
 }
 
 function abortError(): Error {
@@ -77,21 +100,31 @@ function sleep(ms: number, signal?: AbortSignal): Promise<void> {
  * that race is handled exactly like losing the check above: throw (wait:false) or poll (wait:true).
  */
 export async function acquireSlot(opts: AcquireSlotOptions): Promise<() => void> {
-  const { harness, mode, config, wait, signal, pollIntervalMs = 200 } = opts;
+  const {
+    harness,
+    mode,
+    config,
+    wait,
+    signal,
+    pollIntervalMs = 200,
+    random = Math.random,
+    sleep: sleepFn = sleep,
+  } = opts;
+  const pause = () => sleepFn(pollDelayMs(pollIntervalMs, random), signal);
   for (;;) {
     if (signal?.aborted) throw abortError();
     const maxGlobal = getMaxConcurrent(config);
     const globalCount = activeCount();
     if (maxGlobal > 0 && globalCount >= maxGlobal) {
       if (!wait) throw new ConcurrencyLimitError('another delegate run is already in progress (global limit)');
-      await sleep(pollIntervalMs, signal);
+      await pause();
       continue;
     }
     const perHarnessLimit = getMaxConcurrent(config, harness);
     const perHarnessCount = activeCount(harness);
     if (perHarnessLimit > 0 && perHarnessCount >= perHarnessLimit) {
       if (!wait) throw new ConcurrencyLimitError(`another ${harness} run is already in progress`);
-      await sleep(pollIntervalMs, signal);
+      await pause();
       continue;
     }
 
@@ -100,7 +133,7 @@ export async function acquireSlot(opts: AcquireSlotOptions): Promise<() => void>
       // the check above passed, but another racer's write landed first and used up the slot —
       // handled exactly like hitting the cap on the check itself.
       if (!wait) throw new ConcurrencyLimitError(`another delegate run claimed the last available slot for ${harness}`);
-      await sleep(pollIntervalMs, signal);
+      await pause();
       continue;
     }
 

package/extensions/engine.ts

@@ -13,6 +13,7 @@ import {
   buildVerifyResult,
   collectActivityLog,
   describeBudget,
+  formatMetrics,
   formatToolUse,
   pruneOutputs,
   resolveVerifyPlan,
@@ -135,7 +136,7 @@ const warnedUntrustedProjects = new Set<string>();
 
 export function warnIfProjectTemplatesSkipped(ctx: ExtensionContext, trusted: boolean): void {
   if (trusted || warnedUntrustedProjects.has(ctx.cwd)) return;
-  const lines = describeSkippedProjectTemplates(projectTemplatePresence(ctx.cwd));
+  const lines = describeSkippedProjectTemplates(projectTemplatePresence(ctx.cwd, HARNESS_NAMES));
   if (lines.length === 0) return;
   warnedUntrustedProjects.add(ctx.cwd);
   const msg = lines.join('\n');
@@ -454,6 +455,23 @@ export async function delegate(
   };
 }
 
+/**
+ * The one-line metrics summary (`N turn(s) · $X · Nk tok · N% ctx · Ns`) for a finished `delegate()`
+ * run, read from its `details`. Shared by the single-run command path and both fan-out paths so a
+ * comparison row reports the same real prompt-token figure the single run does (it used to be a
+ * hard-coded 0 there, which silently dropped the `tok` column from every fan-out row).
+ */
+export function runMetrics(details: Record<string, unknown>): string {
+  const num = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+  return formatMetrics({
+    numTurns: num(details.numTurns),
+    totalCostUsd: num(details.totalCostUsd),
+    promptTokens: num(details.promptTokens) ?? 0,
+    contextPercent: num(details.contextPercent),
+    durationMs: num(details.durationMs),
+  });
+}
+
 export function summarize(content: string, max = 30_000): { text: string; truncated: boolean } {
   if (content.length <= max) return { text: content, truncated: false };
   return { text: `${content.slice(0, max)}\n…[truncated — full output saved to file]`, truncated: true };

package/extensions/fanout.ts

@@ -6,13 +6,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { OverlayHandle } from '@earendil-works/pi-tui';
-import {
-  buildFanoutReport,
-  type FanoutRunSummary,
-  formatMetrics,
-  formatToolUse,
-  orderFanoutResults,
-} from './activity.ts';
+import { buildFanoutReport, type FanoutRunSummary, formatToolUse, orderFanoutResults } from './activity.ts';
 import { fanoutResumeError, type parseDelegateCommand, resolveDefaults, resolveHarnessList } from './command.ts';
 import { type DelegateConfig, loadConfig } from './config.ts';
 import {
@@ -21,10 +15,17 @@ import {
   injectReport,
   isProjectTrusted,
   runDelegateForTool,
+  runMetrics,
   summarize,
   type ToolProgressUpdate,
 } from './engine.ts';
-import { detectAll, HARNESS_NAMES, isKnownHarness, resolveHarnessName } from './harnesses/registry.ts';
+import {
+  detectAll,
+  HARNESS_NAMES,
+  isKnownHarness,
+  isTemplateDanger,
+  resolveHarnessName,
+} from './harnesses/registry.ts';
 import type { ActivityEvent } from './harnesses/types.ts';
 import { NotifyBatcher } from './notify.ts';
 import { formatFanoutChip, multiProgressWindow, type RunRow } from './progress-multi.ts';
@@ -124,13 +125,7 @@ export async function runFanoutTool(
       return {
         harness: h,
         ok: !run.result.isError,
-        metrics: formatMetrics({
-          numTurns: run.result.numTurns,
-          totalCostUsd: run.result.totalCostUsd,
-          promptTokens: 0,
-          contextPercent: typeof run.details.contextPercent === 'number' ? run.details.contextPercent : null,
-          durationMs: run.result.durationMs,
-        }),
+        metrics: runMetrics(run.details),
         cost: run.result.totalCostUsd,
         body: summary.text,
         file: (run.details.file as string) ?? undefined,
@@ -437,18 +432,15 @@ export async function runFanoutCommand(
   for (const h of resolved) {
     const templates = loadTemplates(ctx.cwd, h, trusted);
     const resolvedTaskScope = resolveDefaults(parsed, templates);
-    const template = parsed.mode ? templates.get(parsed.mode) : undefined;
     if (!resolvedTaskScope) {
       const message = `mode "${parsed.mode ?? 'general'}" needs a prompt`;
       immediateFailures.push({ harness: h, ok: false, cost: null, error: message });
       batcher.failure(`${h}: ${message}`);
       continue;
     }
-    const isDanger =
-      template?.permission === 'danger' ||
-      (template?.nativePermission
-        ? ['bypassPermissions', 'danger-full-access', 'danger'].includes(template.nativePermission)
-        : false);
+    // the template delegate() will actually run for this harness (default mode when none given),
+    // judged by the engine's own danger gate — so the banner can't disagree with the engine
+    const isDanger = isTemplateDanger(h, templates.get(modeForReport));
     specs.push({
       harnessName: h,
       task: resolvedTaskScope.task,
@@ -493,13 +485,7 @@ export async function runFanoutCommand(
     }
     const { content, details, result, verify } = outcome.result;
     const summary = summarize(content);
-    const metrics = formatMetrics({
-      numTurns: result.numTurns,
-      totalCostUsd: result.totalCostUsd,
-      promptTokens: 0,
-      contextPercent: typeof details.contextPercent === 'number' ? details.contextPercent : null,
-      durationMs: typeof details.durationMs === 'number' ? details.durationMs : null,
-    });
+    const metrics = runMetrics(details);
     batcher.success(`${outcome.harnessName} ${parsed.mode ?? 'general'} — ${metrics}`);
     return {
       harness: outcome.harnessName,

package/extensions/harnesses/registry.ts

@@ -78,3 +78,19 @@ export function isNativeDangerPermission(harness: Harness | undefined, nativePer
   const danger = harness?.permissionMap?.danger;
   return Array.isArray(danger) && danger.length > 0 && native === danger.join(' ');
 }
+
+/**
+ * Will running `template` on `harnessName` be a danger-tier run? The same test `delegate()` gates on
+ * (normalized `danger`, or a native permission that is this harness's own danger mode — see
+ * `isNativeDangerPermission`), exposed so the command paths' danger banner can't disagree with the
+ * engine about what is actually dangerous.
+ */
+export function isTemplateDanger(
+  harnessName: string,
+  template: { permission: string; nativePermission?: string } | undefined,
+): boolean {
+  if (!template) return false;
+  return (
+    template.permission === 'danger' || isNativeDangerPermission(getHarness(harnessName), template.nativePermission)
+  );
+}

package/extensions/harnesses/types.ts

@@ -52,12 +52,6 @@ export interface ParseOutcome {
   runningCostUsd?: number;
 }
 
-export interface StreamParseOutcome {
-  streamedText: string;
-  result: StreamedResult | null;
-  activities: ActivityEvent[];
-}
-
 export interface BuildArgsOpts {
   prompt: string;
   cwd: string;
@@ -70,8 +64,6 @@ export interface BuildArgsOpts {
   resumeId?: string;
 }
 
-export type HarnessBuildOpts = BuildArgsOpts;
-
 export interface DetectResult {
   ok: boolean;
   version?: string;

package/extensions/index.ts

@@ -17,8 +17,15 @@
 import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme } from '@earendil-works/pi-coding-agent';
 import { Container, Markdown, type OverlayHandle, Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
-import { formatMetrics, formatToolUse, ToolCallIndex } from './activity.ts';
-import { isFanoutSpec, parseDelegateCommand, resolveDefaults, resolveHarnessFilter } from './command.ts';
+import { formatToolUse, ToolCallIndex } from './activity.ts';
+import {
+  aliasUsage,
+  delegateUsage,
+  isFanoutSpec,
+  parseDelegateCommand,
+  resolveDefaults,
+  resolveHarnessFilter,
+} from './command.ts';
 import { loadConfig } from './config.ts';
 import {
   type DelegateToolParams,
@@ -27,12 +34,13 @@ import {
   injectReport,
   isProjectTrusted,
   runDelegateForTool,
+  runMetrics,
   summarize,
   type ToolProgressUpdate,
   takePendingReport,
 } from './engine.ts';
 import { closeWhenMounted, type RunUiState, runFanoutCommand, runFanoutTool } from './fanout.ts';
-import { ALIASES, HARNESS_NAMES, isKnownHarness, resolveHarnessName } from './harnesses/registry.ts';
+import { ALIASES, HARNESS_NAMES, isKnownHarness, isTemplateDanger, resolveHarnessName } from './harnesses/registry.ts';
 import type { ActivityEvent } from './harnesses/types.ts';
 import { delegationHint, stripMarker } from './hint.ts';
 import { showHistory } from './history.ts';
@@ -502,6 +510,19 @@ export default function (pi: ExtensionAPI) {
     const parsed = parseDelegateCommand(rawForParse, allModes, knownHarnessesSet);
     // if forcedHarness provided, it wins
     if (forcedHarness) parsed.harness = forcedHarness;
+    // a flag that was given but can't be honored (e.g. --budget=0) runs nothing — never silently dropped
+    if (parsed.errors && parsed.errors.length > 0) {
+      const msg = `${parsed.errors.join('; ')}\nUsage: ${forcedHarness ? aliasUsage(forcedHarness) : delegateUsage()}`;
+      if (ctx.hasUI) ctx.ui.notify(msg, 'error');
+      else process.stderr.write(`${msg}\n`);
+      return;
+    }
+    // non-fatal: e.g. a --flag= that sat inside "quoted" prompt text and so wasn't applied
+    if (parsed.notices && parsed.notices.length > 0) {
+      const msg = parsed.notices.join('\n');
+      if (ctx.hasUI) ctx.ui.notify(msg, 'warning');
+      else process.stderr.write(`${msg}\n`);
+    }
 
     // fan-out: harness field is `all` or a comma list — resolve to detected harnesses and run
     // the engine once per harness instead of the single-harness flow below.
@@ -513,12 +534,10 @@ export default function (pi: ExtensionAPI) {
     const harnessName = parsed.harness ?? loadConfig().defaultHarness ?? 'claude';
     const templates = loadTemplates(ctx.cwd, harnessName, trusted);
     const resolved = resolveDefaults(parsed, templates);
-    const template = parsed.mode ? templates.get(parsed.mode) : undefined;
-    const isDanger =
-      template?.permission === 'danger' ||
-      (template?.nativePermission
-        ? ['bypassPermissions', 'danger-full-access', 'danger'].includes(template.nativePermission)
-        : false);
+    // the template delegate() will actually run — the default mode when none was given — so the
+    // danger banner agrees with the engine's own gate (isTemplateDanger, same check)
+    const template = templates.get(parsed.mode || loadConfig().defaultMode);
+    const isDanger = isTemplateDanger(harnessName, template);
 
     if (!resolved) {
       if (parsed.mode)
@@ -526,11 +545,7 @@ export default function (pi: ExtensionAPI) {
           `/delegate ${parsed.mode} <what to do> — give a prompt for the "${parsed.mode}" mode`,
           'warning',
         );
-      else
-        ctx.ui.notify?.(
-          'Usage: /delegate [--harness=claude|codex|opencode|amp|devin|all] [--mode=…] [--model=…] [--scope=…] [--pr=…] [--budget=…] [--verify=…] [--resume=…] [--allow-dangerous] <prompt>',
-          'warning',
-        );
+      else ctx.ui.notify?.(`Usage: ${forcedHarness ? aliasUsage(forcedHarness) : delegateUsage()}`, 'warning');
       return;
     }
 
@@ -584,25 +599,7 @@ export default function (pi: ExtensionAPI) {
     const file = (details.file as string) ?? null;
     const sessionId = (details.sessionId as string) ?? null;
     const resumeHint = sessionId ? ` · resume: /delegate --resume=${sessionId} <prompt>` : '';
-    const usage = details.usage as
-      | {
-          inputTokens?: number;
-          outputTokens?: number;
-          cacheCreationInputTokens?: number;
-          cacheReadInputTokens?: number;
-        }
-      | undefined;
-    const promptTokens = usage
-      ? (usage.inputTokens ?? 0) + (usage.cacheCreationInputTokens ?? 0) + (usage.cacheReadInputTokens ?? 0)
-      : 0;
-    const metrics = formatMetrics({
-      numTurns: typeof details.numTurns === 'number' ? details.numTurns : null,
-      totalCostUsd: typeof details.totalCostUsd === 'number' ? details.totalCostUsd : null,
-      promptTokens,
-      contextPercent: typeof details.contextPercent === 'number' ? (details.contextPercent as number) : null,
-      durationMs:
-        typeof details.durationMs === 'number' && details.durationMs !== null ? (details.durationMs as number) : null,
-    });
+    const metrics = runMetrics(details);
     injectReport(ctx, {
       harness: details.harness as string,
       mode: details.mode as string,
@@ -619,34 +616,24 @@ export default function (pi: ExtensionAPI) {
   };
 
   pi.registerCommand('delegate', {
-    description:
-      'Delegate a task to any harness. Usage: /delegate [--harness=claude|codex|opencode|amp|devin|all] [--mode=review|plan|implement|security-audit|docs|general] [--model=...] [--scope=diff|pr|paths] [--pr=<n|url>] [--budget=<usd>] [--verify=<cmd>] [--resume=<id>] [--allow-dangerous] <prompt> — or use harness as first word: /delegate codex review <prompt>. harness=all or a comma list (e.g. claude,codex) fans out to every detected harness and returns one comparison report. --allow-dangerous runs this one invocation with danger (unrestricted) permission after an interactive confirm; refused headless.',
+    description: `Delegate a task to any harness. Usage: ${delegateUsage()} — or use harness as first word: /delegate codex review <prompt>. harness=all or a comma list (e.g. claude,codex) fans out to every detected harness and returns one comparison report. --allow-dangerous runs this one invocation with danger (unrestricted) permission after an interactive confirm; refused headless.`,
     handler: makeHandler(),
   });
-  pi.registerCommand('claude', {
-    description: 'Alias for /delegate --harness=claude. Usage: /claude [--mode=...] <prompt>',
-    handler: makeHandler('claude'),
-  });
-  pi.registerCommand('codex', {
-    description: 'Alias for /delegate --harness=codex. Usage: /codex [--mode=...] <prompt>',
-    handler: makeHandler('codex'),
-  });
-  pi.registerCommand('opencode', {
-    description: 'Alias for /delegate --harness=opencode. Usage: /opencode [--mode=...] <prompt>',
-    handler: makeHandler('opencode'),
-  });
-  pi.registerCommand('amp', {
-    description: 'Alias for /delegate --harness=amp. Usage: /amp [--mode=...] <prompt>',
-    handler: makeHandler('amp'),
-  });
-  pi.registerCommand('omp', {
-    description: 'Alias for /delegate --harness=amp (omp compat). Usage: /omp [--mode=...] <prompt>',
-    handler: makeHandler('amp'),
-  });
-  pi.registerCommand('devin', {
-    description: 'Alias for /delegate --harness=devin. Usage: /devin [--mode=...] <prompt>',
-    handler: makeHandler('devin'),
-  });
+  // alias commands: same flag set as /delegate (one source — COMMAND_FLAGS_HINT), harness fixed
+  const aliasCommands: [command: string, harness: string, note: string][] = [
+    ['claude', 'claude', ''],
+    ['codex', 'codex', ''],
+    ['opencode', 'opencode', ''],
+    ['amp', 'amp', ''],
+    ['omp', 'amp', ' (omp compat)'],
+    ['devin', 'devin', ''],
+  ];
+  for (const [command, harness, note] of aliasCommands) {
+    pi.registerCommand(command, {
+      description: `Alias for /delegate --harness=${harness}${note}. Usage: ${aliasUsage(command)}`,
+      handler: makeHandler(harness),
+    });
+  }
 
   pi.on('input', async (event, _ctx) => {
     if (event.source === 'extension') return { action: 'continue' };

package/extensions/progress.ts

@@ -47,12 +47,18 @@ export function fmtElapsed(ms: number): string {
 }
 
 /**
- * Slice a feed down to its last `max` entries, reporting how many were dropped so the caller can
+ * Fit a feed into `max` rendered lines, reporting how many entries were dropped so the caller can
  * show a "+N earlier" marker instead of silently truncating with no hint older entries existed.
- * Pure — testable without a TUI.
+ * The marker itself takes one of the `max` lines: when anything is dropped only the last `max - 1`
+ * entries are visible, so marker + entries never exceed `max` (for `max >= 1`). `max <= 0` shows no entries (and
+ * reports everything hidden) — never `slice(-0)`'s "everything". Pure — testable without a TUI.
  */
 export function truncateFeed<T>(entries: T[], max: number): { visible: T[]; hiddenCount: number } {
-  return { visible: entries.slice(-max), hiddenCount: Math.max(0, entries.length - max) };
+  const cap = Math.max(0, Math.floor(max));
+  if (entries.length <= cap) return { visible: [...entries], hiddenCount: 0 };
+  // one line goes to the marker; with a cap of 0 or 1 there's no room for entries at all
+  const keep = Math.max(0, cap - 1);
+  return { visible: keep > 0 ? entries.slice(-keep) : [], hiddenCount: entries.length - keep };
 }
 
 /** Style one feed entry; the returned string may contain ANSI colors. */

package/extensions/runner.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import type { Harness, ParseState, StreamedResult } from './harnesses/types.ts';
+import { appendActivities, appendStreamed } from './stream-caps.ts';
 
 export interface RunHarnessOptions {
   harness: Harness;
@@ -96,8 +97,6 @@ export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
     let settled = false;
     let firstTokenAt: number | null = null;
     const startAt = Date.now();
-    const MAX_STREAMED = 5 * 1024 * 1024; // 5MB cap to prevent OOM on compromised harness
-    const MAX_ACTIVITIES = 5000;
 
     const finish = (r: StreamedResult, budgetExceeded = false) => {
       if (settled) return;
@@ -126,25 +125,9 @@ export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
       const outcome = opts.harness.parseLine(line, state);
       if (outcome.streamedText) {
         if (firstTokenAt === null) firstTokenAt = Date.now();
-        // Cap streamedText to prevent OOM on compromised harness
-        if (state.streamedText.length < MAX_STREAMED) {
-          const remaining = MAX_STREAMED - state.streamedText.length;
-          const chunk =
-            outcome.streamedText.length > remaining
-              ? `${outcome.streamedText.slice(0, remaining)} [truncated ${outcome.streamedText.length - remaining} chars]`
-              : outcome.streamedText;
-          state.streamedText += chunk;
-          opts.onStream?.(chunk);
-        }
-      }
-      if (outcome.activities) {
-        for (const a of outcome.activities) {
-          if (state.activities.length < MAX_ACTIVITIES) {
-            state.activities.push(a);
-            opts.onActivity?.(a);
-          }
-        }
+        appendStreamed(state, outcome.streamedText, opts.onStream); // capped — see stream-caps.ts
       }
+      if (outcome.activities) appendActivities(state, outcome.activities, opts.onActivity);
       if (outcome.result) {
         // merge streamedText into result if empty
         if (!outcome.result.result) outcome.result.result = state.streamedText;

package/extensions/stream-caps.ts

@@ -0,0 +1,46 @@
+/**
+ * Memory caps shared by both runners (`runner.ts` for stdout harnesses, `acp-runner.ts` for ACP):
+ * a misbehaving or compromised harness can stream without bound, so accumulated text and activity
+ * events are capped here, once, instead of in two hand-copied blocks that could drift.
+ */
+import type { ActivityEvent, ParseState } from './harnesses/types.ts';
+
+/** Max characters of streamed text kept per run (5MB) — beyond this the stream is truncated. */
+export const MAX_STREAMED_CHARS = 5 * 1024 * 1024;
+/** Max activity events kept (and forwarded to `onActivity`) per run. */
+export const MAX_ACTIVITIES = 5000;
+
+/**
+ * Append a streamed chunk to `state.streamedText`, truncating at `max` with a
+ * `[truncated N chars]` marker, and forward exactly what was kept to `onStream`. Once the cap has
+ * been reached, further chunks are dropped (and not forwarded). Returns the appended chunk, or
+ * `null` when nothing was appended.
+ */
+export function appendStreamed(
+  state: ParseState,
+  text: string,
+  onStream?: (chunk: string) => void,
+  max: number = MAX_STREAMED_CHARS,
+): string | null {
+  if (!text || state.streamedText.length >= max) return null;
+  const remaining = max - state.streamedText.length;
+  const chunk =
+    text.length > remaining ? `${text.slice(0, remaining)} [truncated ${text.length - remaining} chars]` : text;
+  state.streamedText += chunk;
+  onStream?.(chunk);
+  return chunk;
+}
+
+/** Append activity events to `state.activities` up to `max`, forwarding each kept one to `onActivity`. */
+export function appendActivities(
+  state: ParseState,
+  activities: readonly ActivityEvent[],
+  onActivity?: (ev: ActivityEvent) => void,
+  max: number = MAX_ACTIVITIES,
+): void {
+  for (const a of activities) {
+    if (state.activities.length >= max) return;
+    state.activities.push(a);
+    onActivity?.(a);
+  }
+}

package/extensions/templates.ts

@@ -224,13 +224,32 @@ export function resolveNativePermission(
  *
  * Pure filesystem inspection — no trust logic. The caller supplies the trust decision.
  */
-export function projectTemplatePresence(cwd: string): {
+export function projectTemplatePresence(
+  cwd: string,
+  /** Canonical harness names — the only partitions `loadTemplates` ever reads (callers pass the
+   *  registry's `HARNESS_NAMES`; injected so this module stays free of the harness registry). */
+  harnessNames: readonly string[],
+): {
   /** Template dirs that exist and would load if the project were trusted. */
   dirs: string[];
   /** A leftover `.pi/trusted` file — strong evidence the user relied on the removed mechanism. */
   staleTrustFile: boolean;
 } {
-  const candidates = [projectTemplatesDir(cwd), legacyProjectTemplatesDir(cwd)];
+  // the per-harness partitions (`.pi/delegate/templates/<harness>/`) load too — see loadTemplates —
+  // so they count as skipped content just like the shared root does. Only real harness partitions:
+  // loadTemplates is always called with a canonical name, so `omp/` (an alias), `archive/`,
+  // `shared/` etc. are never read and must not trigger the warning either.
+  const known = new Set(harnessNames);
+  let partitions: string[] = [];
+  try {
+    partitions = readdirSync(projectTemplatesDir(cwd), { withFileTypes: true })
+      .filter(e => e.isDirectory() && known.has(e.name))
+      .map(e => projectTemplatesDir(cwd, e.name))
+      .sort();
+  } catch {
+    // absent or unreadable
+  }
+  const candidates = [projectTemplatesDir(cwd), ...partitions, legacyProjectTemplatesDir(cwd)];
   const dirs: string[] = [];
   for (const dir of candidates) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-delegate",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Delegate work to any harness (Claude Code, Muse, OpenCode, Amp, Devin) from the pi coding agent \u2014 code reviews, plans, implementation, security audits, docs, or your own custom templates.",
   "type": "module",
   "packageManager": "bun@1.3.14",

package/extensions/run-claude.ts

@@ -1,61 +0,0 @@
-/** @deprecated use extensions/runner.ts + harnesses/claude.ts directly */
-
-import { claudeHarness } from './harnesses/claude.ts';
-import type { ActivityEvent, StreamedResult } from './harnesses/types.ts';
-import { runHarness } from './runner.ts';
-
-export interface RunClaudeOptions {
-  prompt: string;
-  cwd: string;
-  permissionMode: string;
-  model?: string;
-  maxBudgetUsd?: number;
-  addDirs?: string[];
-  signal?: AbortSignal;
-  timeoutMs?: number;
-  resumeSessionId?: string;
-  onStream?: (text: string) => void;
-  onActivity?: (ev: ActivityEvent) => void;
-}
-
-export interface ClaudeResult extends StreamedResult {
-  streamedText: string;
-}
-
-export const DEFAULT_TIMEOUT_MS = 600_000;
-
-function mapPerm(mode: string): 'readonly' | 'edit' | 'danger' {
-  if (mode === 'plan') return 'readonly';
-  if (mode === 'bypassPermissions') return 'danger';
-  return 'edit';
-}
-
-export function runClaude(opts: RunClaudeOptions): Promise<ClaudeResult> {
-  const perm = mapPerm(opts.permissionMode);
-  const _nativePerm =
-    perm === 'readonly' && opts.permissionMode !== 'plan'
-      ? opts.permissionMode
-      : perm === 'danger' && opts.permissionMode !== 'bypassPermissions'
-        ? opts.permissionMode
-        : undefined;
-  // normalize: if caller passed a non-standard mode, preserve as native
-  const isStandard =
-    opts.permissionMode === 'plan' ||
-    opts.permissionMode === 'acceptEdits' ||
-    opts.permissionMode === 'bypassPermissions';
-  return runHarness({
-    harness: claudeHarness,
-    prompt: opts.prompt,
-    cwd: opts.cwd,
-    permission: perm,
-    nativePermission: isStandard ? undefined : opts.permissionMode,
-    model: opts.model,
-    maxBudgetUsd: opts.maxBudgetUsd,
-    addDirs: opts.addDirs,
-    signal: opts.signal,
-    timeoutMs: opts.timeoutMs,
-    resumeSessionId: opts.resumeSessionId,
-    onStream: opts.onStream,
-    onActivity: opts.onActivity,
-  }).then(r => ({ ...r, streamedText: r.streamedText }));
-}

package/extensions/stream-parse.ts

@@ -1,37 +0,0 @@
-/** @deprecated use extensions/harnesses/claude.ts parse directly */
-export type {
-  ActivityEvent,
-  ParseOutcome,
-  ParseState,
-  StreamedResult,
-  StreamedUsage,
-  StreamParseOutcome,
-} from './harnesses/types.ts';
-
-import { parseClaudeLine } from './harnesses/claude.ts';
-import type { ParseState, StreamParseOutcome } from './harnesses/types.ts';
-
-export function parseStreamLines(lines: Iterable<string>): StreamParseOutcome {
-  const state: ParseState = { streamedText: '', activities: [], result: null };
-  let streamedText = '';
-  const activities: StreamParseOutcome['activities'] = [];
-  let result: StreamParseOutcome['result'] = null;
-  for (const line of lines) {
-    const out = parseClaudeLine(line, state);
-    if (out.streamedText) {
-      streamedText += out.streamedText;
-      state.streamedText += out.streamedText;
-    }
-    if (out.activities) {
-      for (const a of out.activities) {
-        activities.push(a);
-        state.activities.push(a);
-      }
-    }
-    if (out.result) {
-      result = out.result;
-      state.result = out.result;
-    }
-  }
-  return { streamedText, result, activities };
-}