pi-harness-delegate 0.7.0 → 0.7.2

package/extensions/index.ts

@@ -14,11 +14,24 @@
  * Legacy: { claudeDelegate: {...} } is auto-migrated.
  */
 
-import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme } from '@earendil-works/pi-coding-agent';
+import type { ImageContent, TextContent } from '@earendil-works/pi-ai';
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  getMarkdownTheme,
+  type ToolDefinition,
+} 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 +40,12 @@ 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';
@@ -42,79 +55,97 @@ import { type DelegateTemplate, loadTemplates } from './templates.ts';
 import { mapClaudeUsage } from './usage.ts';
 import { confirmDangerousCommand, confirmDangerousToolCall, confirmToolAddDirs } from './validate.ts';
 
+/** Tool-result `details` for the `delegate` tool (and its partial progress updates). */
+type DelegateToolDetails = Record<string, unknown>;
+
+const DELEGATE_TOOL_DESCRIPTION =
+  'Delegate a task to any harness (claude, codex, opencode, amp, devin) running headless in the repo and return its streamed report (cost, token usage, context %, session id). harness selects the backend (default from config, fallback claude) — pass "all" or a comma list (e.g. "claude,codex") to fan out the same task to several harnesses and get back one comparison report. mode selects a template: review, plan, implement, security-audit, docs, general, or custom — some templates run a host-side check (e.g. "bun test") after the harness exits and report pass/fail as separate evidence; that is configured on the template, not a parameter here. scope restricts work: diff for current git diff, pr for PR diff, path list, or whole repo. sessionId continues a prior session.';
+
+const DELEGATE_TOOL_GUIDELINES: readonly string[] = [
+  'delegate runs a harness headless in the working directory and returns a streamed report with cost, token usage, and a session id for follow-ups.',
+  'Pass harness (claude|codex|opencode|amp|devin) + focused task string + intent and constraints. Use scope: diff for current git diff, pr for PR diff, path list, or omit for whole repo.',
+  'mode selects the template and its permission level: review/plan/security-audit are readonly; implement/docs/general are edit. Custom template names also work. Some templates verify their own work (e.g. running tests) automatically after the harness finishes — that is not something you configure here.',
+  'harness: "all" or a comma list (e.g. "codex,opencode") fans the same task out to each detected harness and returns one synthesized comparison report — costs multiply, so only use it when the user actually wants a multi-harness comparison.',
+  'sessionId resumes a previous delegated session instead of starting fresh — pass the exact session id from a previous run\'s details (letters, digits, . _ : - only). It cannot be combined with a fan-out harness ("all" or a comma list) — a session belongs to one harness.',
+  'pr must be a PR number, an http(s) pull-request URL (https://<host>/<owner>/<repo>/pull/<n>), or owner/repo#123.',
+  'addDirs inside the working directory are accepted as-is; any entry outside it asks the human to confirm interactively and is refused in a non-interactive session.',
+  'Do not set allowDangerous unless the user explicitly asks for unrestricted access (danger permission). Setting it always asks the human to confirm interactively; in a non-interactive session it is refused outright.',
+];
+
+const DELEGATE_TOOL_PARAMS = Type.Object({
+  harness: Type.Optional(
+    Type.String({
+      description:
+        'Harness to use: claude, codex, opencode, amp (aliases: omp), devin. "all" or a comma list (e.g. "claude,codex") fans out to each detected harness. Defaults to config defaultHarness.',
+    }),
+  ),
+  task: Type.String({ description: 'The task/intent to delegate. Be specific.' }),
+  mode: Type.Optional(
+    Type.String({
+      description:
+        'Template/mode to run: review, plan, implement, security-audit, docs, general, or custom. Defaults to config defaultMode.',
+    }),
+  ),
+  scope: Type.Optional(
+    Type.String({
+      description:
+        'Restrict the work: diff (git diff), pr (PR diff), comma/space-separated path list, or omit for whole repo.',
+    }),
+  ),
+  model: Type.Optional(Type.String({ description: 'Model (e.g. sonnet, opus, gpt-5). Defaults to template/config.' })),
+  maxBudgetUsd: Type.Optional(Type.Number({ description: 'Hard spend cap in USD for the run.' })),
+  sessionId: Type.Optional(
+    Type.String({
+      description: 'Resume an existing delegated session (pass its session id from a previous run details).',
+    }),
+  ),
+  allowDangerous: Type.Optional(
+    Type.Boolean({
+      description:
+        'Escalate to danger permission (unrestricted). Always requires interactive human confirmation; refused without a UI.',
+    }),
+  ),
+  pr: Type.Optional(
+    Type.String({ description: 'GitHub PR number, http(s) PR URL, or owner/repo#123 (alternative to scope pr).' }),
+  ),
+  addDirs: Type.Optional(
+    Type.Array(Type.String(), {
+      description:
+        'Extra directories the harness may access. Relative paths resolve against the working directory. Any entry that resolves (after symlinks) outside the working directory requires interactive human confirmation and is refused without a UI. Not every harness supports this (opencode ignores it; codex ignores it on resume).',
+    }),
+  ),
+  // Deliberately no `verify` param — see the trust-model comment on DelegateToolParams/runVerify.
+});
+
+/** The text parts of a tool result, joined — images (never produced by this tool) are skipped. */
+function textOf(content: readonly (TextContent | ImageContent)[] | undefined): string {
+  return (content ?? []).flatMap(c => (c.type === 'text' ? [c.text] : [])).join('\n');
+}
+
 export default function (pi: ExtensionAPI) {
   const ui: RunUiState = { activeRunId: 0, activeOverlay: null };
 
   // ── Tools ────────────────────────────────────────────────────────────────
-  const delegateToolDef = {
-    name: 'delegate',
-    label: 'Delegate',
-    description:
-      'Delegate a task to any harness (claude, codex, opencode, amp, devin) running headless in the repo and return its streamed report (cost, token usage, context %, session id). harness selects the backend (default from config, fallback claude) — pass "all" or a comma list (e.g. "claude,codex") to fan out the same task to several harnesses and get back one comparison report. mode selects a template: review, plan, implement, security-audit, docs, general, or custom — some templates run a host-side check (e.g. "bun test") after the harness exits and report pass/fail as separate evidence; that is configured on the template, not a parameter here. scope restricts work: diff for current git diff, pr for PR diff, path list, or whole repo. sessionId continues a prior session.',
-    promptSnippet: 'Delegate a subtask to a harness and return its report',
-    promptGuidelines: [
-      'delegate runs a harness headless in the working directory and returns a streamed report with cost, token usage, and a session id for follow-ups.',
-      'Pass harness (claude|codex|opencode|amp|devin) + focused task string + intent and constraints. Use scope: diff for current git diff, pr for PR diff, path list, or omit for whole repo.',
-      'mode selects the template and its permission level: review/plan/security-audit are readonly; implement/docs/general are edit. Custom template names also work. Some templates verify their own work (e.g. running tests) automatically after the harness finishes — that is not something you configure here.',
-      'harness: "all" or a comma list (e.g. "codex,opencode") fans the same task out to each detected harness and returns one synthesized comparison report — costs multiply, so only use it when the user actually wants a multi-harness comparison.',
-      'sessionId resumes a previous delegated session instead of starting fresh — pass the exact session id from a previous run\'s details (letters, digits, . _ : - only). It cannot be combined with a fan-out harness ("all" or a comma list) — a session belongs to one harness.',
-      'pr must be a PR number, an http(s) pull-request URL (https://<host>/<owner>/<repo>/pull/<n>), or owner/repo#123.',
-      'addDirs inside the working directory are accepted as-is; any entry outside it asks the human to confirm interactively and is refused in a non-interactive session.',
-      'Do not set allowDangerous unless the user explicitly asks for unrestricted access (danger permission). Setting it always asks the human to confirm interactively; in a non-interactive session it is refused outright.',
-    ],
-    parameters: Type.Object({
-      harness: Type.Optional(
-        Type.String({
-          description:
-            'Harness to use: claude, codex, opencode, amp (aliases: omp), devin. "all" or a comma list (e.g. "claude,codex") fans out to each detected harness. Defaults to config defaultHarness.',
-        }),
-      ),
-      task: Type.String({ description: 'The task/intent to delegate. Be specific.' }),
-      mode: Type.Optional(
-        Type.String({
-          description:
-            'Template/mode to run: review, plan, implement, security-audit, docs, general, or custom. Defaults to config defaultMode.',
-        }),
-      ),
-      scope: Type.Optional(
-        Type.String({
-          description:
-            'Restrict the work: diff (git diff), pr (PR diff), comma/space-separated path list, or omit for whole repo.',
-        }),
-      ),
-      model: Type.Optional(
-        Type.String({ description: 'Model (e.g. sonnet, opus, gpt-5). Defaults to template/config.' }),
-      ),
-      maxBudgetUsd: Type.Optional(Type.Number({ description: 'Hard spend cap in USD for the run.' })),
-      sessionId: Type.Optional(
-        Type.String({
-          description: 'Resume an existing delegated session (pass its session id from a previous run details).',
-        }),
-      ),
-      allowDangerous: Type.Optional(
-        Type.Boolean({
-          description:
-            'Escalate to danger permission (unrestricted). Always requires interactive human confirmation; refused without a UI.',
-        }),
-      ),
-      pr: Type.Optional(
-        Type.String({ description: 'GitHub PR number, http(s) PR URL, or owner/repo#123 (alternative to scope pr).' }),
-      ),
-      addDirs: Type.Optional(
-        Type.Array(Type.String(), {
-          description:
-            'Extra directories the harness may access. Relative paths resolve against the working directory. Any entry that resolves (after symlinks) outside the working directory requires interactive human confirmation and is refused without a UI. Not every harness supports this (opencode ignores it; codex ignores it on resume).',
-        }),
-      ),
-      // Deliberately no `verify` param — see the trust-model comment on DelegateToolParams/runVerify.
-    }),
-    async execute(
-      _toolCallId: string,
-      params: DelegateToolParams,
-      signal: AbortSignal | undefined,
-      onUpdate: ((u: ToolProgressUpdate) => void) | undefined,
-      ctx: ExtensionContext,
-    ) {
+
+  /**
+   * Build one registration of the `delegate` tool. The primary tool and the deprecated
+   * `claude_delegate` alias are the same definition — same schema, guidelines, execute path and
+   * renderers — differing only in the fields `spec` sets (name/label/description/snippet) and, for
+   * the alias, a pinned harness applied before anything else in `execute`.
+   */
+  const makeDelegateTool = (
+    name: string,
+    spec: { label: string; description: string; promptSnippet: string; forceHarness?: string },
+  ): ToolDefinition<typeof DELEGATE_TOOL_PARAMS, DelegateToolDetails> => ({
+    name,
+    label: spec.label,
+    description: spec.description,
+    promptSnippet: spec.promptSnippet,
+    promptGuidelines: [...DELEGATE_TOOL_GUIDELINES],
+    parameters: DELEGATE_TOOL_PARAMS,
+    async execute(_toolCallId, rawParams, signal, onUpdate, ctx) {
+      // the deprecated alias pins its harness; everything below sees the effective params
+      const params: DelegateToolParams = spec.forceHarness ? { ...rawParams, harness: spec.forceHarness } : rawParams;
       const config = loadConfig();
       // A model-set allowDangerous is never honored on its own — a human confirms it (or, with no
       // UI to ask, it's refused). Checked once up front, before any fan-out. See validate.ts.
@@ -153,15 +184,14 @@ export default function (pi: ExtensionAPI) {
         : `${details.harness} ${details.mode} (${result.numTurns ?? '—'} turn(s), ${formatCost(result.totalCostUsd)})${resumed}`;
       const body = result.isError ? `\n${summary.text}` : `\n\n${summary.text}`;
       const footer = summary.truncated ? `\nFull output: ${details.file}` : `\nTranscript: ${details.file}`;
-      (details as Record<string, unknown>).markdown = summary.text;
+      details.markdown = summary.text;
       return {
         content: [{ type: 'text', text: `${head}${body}${footer}` }],
         details,
         usage: result.usage ? mapClaudeUsage({ ...result.usage, totalCostUsd: result.totalCostUsd }) : undefined,
       };
     },
-    renderCall(args: unknown, theme: { fg: (c: string, s: string) => string; bg: (c: string, s: string) => string }) {
-      const params = args as { harness?: string; mode?: string; task?: string };
+    renderCall(params, theme) {
       const harness = params.harness ?? 'delegate';
       const mode = params.mode ?? 'general';
       const task = params.task ?? '';
@@ -170,19 +200,12 @@ export default function (pi: ExtensionAPI) {
         theme.bg('toolPendingBg', s),
       );
     },
-    renderResult(
-      result: { content?: { type: string; text: string }[]; details?: Record<string, unknown> },
-      options: { isPartial: boolean },
-      theme: { fg: (c: string, s: string) => string; bg: (c: string, s: string) => string },
-    ) {
+    renderResult(result, options, theme) {
       if (options.isPartial) {
-        const text = (result.content ?? [])
-          .filter(c => c.type === 'text')
-          .map(c => c.text)
-          .join('\n');
+        const text = textOf(result.content);
         return new Text(text, 1, 1, s => theme.bg('toolPendingBg', s));
       }
-      const details = (result.details ?? {}) as Record<string, unknown>;
+      const details: DelegateToolDetails = result.details ?? {};
       const harness = typeof details.harness === 'string' ? details.harness : 'delegate';
       const mode = typeof details.mode === 'string' ? details.mode : 'delegate';
       const cost = typeof details.totalCostUsd === 'number' ? details.totalCostUsd : null;
@@ -205,10 +228,7 @@ export default function (pi: ExtensionAPI) {
       const md = typeof details.markdown === 'string' && details.markdown ? details.markdown : null;
       if (md) container.addChild(new Markdown(md, 1, 1, getMarkdownTheme()));
       else {
-        const text = (result.content ?? [])
-          .filter(c => c.type === 'text')
-          .map(c => c.text)
-          .join('\n');
+        const text = textOf(result.content);
         container.addChild(new Text(text, 1, 1));
       }
       const foot: string[] = [];
@@ -217,46 +237,25 @@ export default function (pi: ExtensionAPI) {
       if (foot.length > 0) container.addChild(new Text(theme.fg('dim', foot.join('   ')), 1, 1));
       return container;
     },
-  };
+  });
 
-  // SAFETY: delegateToolDef satisfies registerTool params via TypeBox, widened for alias registration
-  pi.registerTool(delegateToolDef as unknown as Parameters<typeof pi.registerTool>[0]); // SAFETY: delegateToolDef satisfies registerTool params
+  pi.registerTool(
+    makeDelegateTool('delegate', {
+      label: 'Delegate',
+      description: DELEGATE_TOOL_DESCRIPTION,
+      promptSnippet: 'Delegate a subtask to a harness and return its report',
+    }),
+  );
 
   // deprecated alias
-  pi.registerTool({
-    name: 'claude_delegate',
-    label: 'Claude Delegate (deprecated)',
-    description:
-      'Deprecated alias for delegate{harness:claude}. Use delegate tool with harness:claude instead. ' +
-      (delegateToolDef as { description: string }).description,
-    promptSnippet: 'Delegate a subtask to Claude Code (deprecated alias)',
-    // SAFETY: delegateToolDef promptGuidelines is string[] from literal, safe to spread
-    promptGuidelines: [...(delegateToolDef as unknown as { promptGuidelines: string[] }).promptGuidelines], // SAFETY: promptGuidelines is string[]
-    parameters: (delegateToolDef as { parameters: unknown }).parameters as never,
-    async execute(
-      toolCallId: string,
-      params: DelegateToolParams,
-      signal: AbortSignal | undefined,
-      onUpdate: never,
-      ctx: ExtensionContext,
-    ) {
-      return (
-        // SAFETY: deprecated alias delegates to primary tool, shape identical
-        (
-          delegateToolDef as unknown as {
-            // SAFETY: alias shape identical
-            execute: (a: string, b: unknown, c: unknown, d: unknown, e: unknown) => Promise<unknown>;
-          }
-        ).execute(toolCallId, { ...params, harness: 'claude' }, signal, onUpdate, ctx)
-      );
-    },
-    // SAFETY: delegateToolDef renderCall matches expected signature
-    renderCall: (delegateToolDef as unknown as { renderCall: (a: unknown, b: unknown) => unknown }).renderCall, // SAFETY: matches signature
-    // SAFETY: delegateToolDef renderResult matches expected signature
-    renderResult: (delegateToolDef as unknown as { renderResult: (a: unknown, b: unknown, c: unknown) => unknown }) // SAFETY: matches signature
-      .renderResult,
-    // SAFETY: final alias tool matches registerTool overload
-  } as unknown as Parameters<typeof pi.registerTool>[0]); // SAFETY: alias tool matches overload
+  pi.registerTool(
+    makeDelegateTool('claude_delegate', {
+      label: 'Claude Delegate (deprecated)',
+      description: `Deprecated alias for delegate{harness:claude}. Use delegate tool with harness:claude instead. ${DELEGATE_TOOL_DESCRIPTION}`,
+      promptSnippet: 'Delegate a subtask to Claude Code (deprecated alias)',
+      forceHarness: 'claude',
+    }),
+  );
 
   // ── Commands ─────────────────────────────────────────────────────────────
 
@@ -502,6 +501,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 +525,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 +536,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 +590,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 +607,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/notify.ts

@@ -14,20 +14,33 @@ export function joinBatch(lines: string[]): string {
   return `${lines.length} runs completed:\n${lines.map(l => `  · ${l}`).join('\n')}`;
 }
 
+/** The timer primitives the batcher schedules its debounce with — injectable so tests can drive a
+ *  fake clock instead of sleeping for real. */
+export interface BatcherTimers {
+  set(fn: () => void, ms: number): unknown;
+  clear(handle: unknown): void;
+}
+
+const REAL_TIMERS: BatcherTimers = {
+  set: (fn, ms) => setTimeout(fn, ms),
+  clear: handle => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
 export class NotifyBatcher {
   private pending: string[] = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
+  private timer: unknown = null;
 
   constructor(
     private readonly emit: NotifyFn,
     private readonly debounceMs = 400,
+    private readonly timers: BatcherTimers = REAL_TIMERS,
   ) {}
 
   /** Queue a successful-completion line; flushes as one combined notification after a quiet period. */
   success(line: string): void {
     this.pending.push(line);
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+    if (this.timer !== null) this.timers.clear(this.timer);
+    this.timer = this.timers.set(() => this.flush(), this.debounceMs);
   }
 
   /** Flush any pending batch immediately, then emit this failure on its own — never delayed. */
@@ -38,8 +51,8 @@ export class NotifyBatcher {
 
   /** Emit whatever is pending as one notification, then clear it. No-op when nothing is pending. */
   flush(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
+    if (this.timer !== null) {
+      this.timers.clear(this.timer);
       this.timer = null;
     }
     if (this.pending.length === 0) return;

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);
+  }
+}