pi-harness-delegate 0.6.2 → 0.7.1

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/run-registry.ts

@@ -17,7 +17,7 @@
  * `acquireRun`/`countActiveRuns` directly.
  */
 
-import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir } from './config.ts';
 
@@ -35,6 +35,23 @@ function isAlive(pid: number): boolean {
   }
 }
 
+/** A `.json.tmp` this old can't be an in-flight write — acquireRun renames it within microseconds. */
+export const STALE_TMP_MS = 60_000;
+
+/**
+ * Remove a leftover `<pid>-<harness>-<rand>.json.tmp` if its writer crashed between write and
+ * rename (embedded pid dead) or it's older than `STALE_TMP_MS`. A live writer's tmp is left alone.
+ */
+function reapTmp(full: string, name: string): void {
+  try {
+    const pid = Number(name.split('-', 1)[0]);
+    const dead = !Number.isInteger(pid) || pid <= 0 || !isAlive(pid);
+    if (dead || Date.now() - statSync(full).mtimeMs > STALE_TMP_MS) rmSync(full, { force: true });
+  } catch {
+    // best-effort (already renamed/removed by its writer, or unreadable)
+  }
+}
+
 export interface RunHandle {
   file: string;
 }
@@ -45,7 +62,17 @@ export function acquireRun(harness: string, mode: string): RunHandle | null {
     const dir = runsDir();
     mkdirSync(dir, { recursive: true });
     const file = join(dir, `${process.pid}-${harness}-${Math.random().toString(36).slice(2, 8)}.json`);
-    writeFileSync(file, JSON.stringify({ pid: process.pid, harness, mode, startedAt: Date.now() }));
+    // Write-then-rename so a concurrent countActiveRuns() never sees a half-written entry: it
+    // treats unparseable `.json` files as corrupt and deletes them, which would silently drop a
+    // live run's registration mid-write. `.tmp` files are invisible to it (it only reads `.json`).
+    const tmp = `${file}.tmp`;
+    try {
+      writeFileSync(tmp, JSON.stringify({ pid: process.pid, harness, mode, startedAt: Date.now() }));
+      renameSync(tmp, file);
+    } catch (err) {
+      rmSync(tmp, { force: true });
+      throw err;
+    }
     return { file };
   } catch {
     return null;
@@ -63,7 +90,7 @@ export function releaseRun(handle: RunHandle | null): void {
 }
 
 /** Count active runs across processes (optionally filtered to one harness), cleaning up
- *  entries left behind by dead processes. Returns 0 (never throws) if the registry is unreadable. */
+ *  entries — and abandoned `.json.tmp` writes — left behind by dead processes. Returns 0 (never throws) if the registry is unreadable. */
 export function countActiveRuns(harness?: string): number {
   let files: string[];
   try {
@@ -73,6 +100,12 @@ export function countActiveRuns(harness?: string): number {
   }
   let count = 0;
   for (const f of files) {
+    // only complete entries count — `<entry>.json.tmp` writes (see acquireRun) are skipped, but
+    // reaped once they're demonstrably abandoned (crashed writer), so they don't pile up forever
+    if (f.endsWith('.json.tmp')) {
+      reapTmp(join(runsDir(), f), f);
+      continue;
+    }
     if (!f.endsWith('.json')) continue;
     const full = join(runsDir(), f);
     try {

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;
@@ -21,12 +22,63 @@ export interface RunHarnessOptions {
 export interface HarnessResult extends StreamedResult {
   streamedText: string;
   harness: string;
+  /** Set when the runner itself killed the run for exceeding `maxBudgetUsd` (host enforcement). */
+  budgetExceeded?: boolean;
+}
+
+/**
+ * Host-side `maxBudgetUsd` enforcement for a harness with no native budget flag: true once the
+ * harness's own streamed running total (`totalCostUsd`) goes over the cap. A harness that reports
+ * no cost (`null`) can never trip this — `delegate()` flags that budget as unenforced instead.
+ */
+export function isOverBudget(
+  harness: Harness,
+  maxBudgetUsd: number | undefined,
+  r: StreamedResult | null,
+  baselineUsd = 0,
+): boolean {
+  return r !== null && isCostOverBudget(harness, maxBudgetUsd, r.totalCostUsd, baselineUsd);
+}
+
+/**
+ * The cost-only core of `isOverBudget`. `baselineUsd` is subtracted first: a harness whose reported
+ * total is *session*-cumulative (opencode over ACP) already includes every prior turn's spend on a
+ * resume, so only the delta since this run started counts against this run's cap.
+ */
+export function isCostOverBudget(
+  harness: Harness,
+  maxBudgetUsd: number | undefined,
+  costUsd: number | null | undefined,
+  baselineUsd = 0,
+): boolean {
+  return (
+    maxBudgetUsd !== undefined &&
+    harness.nativeBudget !== true &&
+    typeof costUsd === 'number' &&
+    costUsd - baselineUsd > maxBudgetUsd
+  );
+}
+
+/** The result recorded for a run the host stopped over budget. */
+export function budgetStoppedResult(r: StreamedResult, streamedText: string): StreamedResult {
+  return {
+    ...r,
+    isError: true,
+    stopReason: 'budget_exceeded',
+    result: r.result || streamedText || '(stopped: budget exceeded)',
+  };
 }
 
 import { DEFAULT_TIMEOUT_MS } from './harnesses/types.ts';
 
 export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
   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.
+    if (opts.signal?.aborted) {
+      reject(new Error('cancelled'));
+      return;
+    }
     const args = opts.harness.buildArgs({
       prompt: opts.prompt,
       cwd: opts.cwd,
@@ -45,20 +97,26 @@ 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) => {
+    const finish = (r: StreamedResult, budgetExceeded = false) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
+      opts.signal?.removeEventListener('abort', onAbort);
       const ttft = firstTokenAt !== null ? firstTokenAt - startAt : r.ttftMs;
-      resolve({ ...r, ttftMs: ttft, streamedText: state.streamedText, harness: opts.harness.name });
+      resolve({
+        ...r,
+        ttftMs: ttft,
+        streamedText: state.streamedText,
+        harness: opts.harness.name,
+        ...(budgetExceeded ? { budgetExceeded: true } : {}),
+      });
     };
     const fail = (err: Error) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
+      opts.signal?.removeEventListener('abort', onAbort);
       reject(err);
     };
 
@@ -67,29 +125,17 @@ 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;
         state.result = outcome.result;
+        if (!settled && isOverBudget(opts.harness, opts.maxBudgetUsd, state.result)) {
+          proc.kill('SIGKILL');
+          finish(budgetStoppedResult(state.result, state.streamedText), true);
+        }
       }
     });
 
@@ -120,13 +166,12 @@ export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
     }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
     timer.unref?.();
 
-    opts.signal?.addEventListener(
-      'abort',
-      () => {
-        proc.kill('SIGKILL');
-        fail(new Error('cancelled'));
-      },
-      { once: true },
-    );
+    // Removed again in finish()/fail() — a long-lived signal (e.g. one shared by a fan-out, or the
+    // tool call's own) must not accumulate a dead listener per run.
+    function onAbort(): void {
+      proc.kill('SIGKILL');
+      fail(new Error('cancelled'));
+    }
+    opts.signal?.addEventListener('abort', onAbort, { once: true });
   });
 }

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/subcommands.ts

@@ -0,0 +1,227 @@
+/** `/delegate list|status|config|config init` subcommand UIs. Split out of index.ts with no behavior change. */
+
+import { readdirSync } from 'node:fs';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { Key, matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import { aggregateSpend, formatSpend } from './activity.ts';
+import { activeCount } from './concurrency.ts';
+import {
+  buildConfigReport,
+  describeConfigSource,
+  getMaxConcurrent,
+  outputsDir as getOutputsDir,
+  legacyOutputsDir,
+  loadConfigWithSource,
+  nonDefaultConfig,
+  writeDelegateConfig,
+} from './config.ts';
+import { isProjectTrusted } from './engine.ts';
+import { ALIASES, detectAll, getHarness, HARNESS_NAMES, isKnownHarness } from './harnesses/registry.ts';
+import { readAllHistory } from './history.ts';
+import { type DelegateTemplate, loadTemplates } from './templates.ts';
+export function formatTemplateRow(t: DelegateTemplate): string {
+  const parts = [
+    t.name,
+    `[${t.permission}]`,
+    t.model ? `model=${t.model}` : '',
+    t.defaultTask ? '↳ default task' : '',
+    t.harness ? `(${t.harness})` : '',
+  ];
+  return `${parts.filter(Boolean).join('  ')}  —  ${t.description}`;
+}
+
+export async function showModes(ctx: ExtensionContext, harnessFilter?: string): Promise<void> {
+  const all = new Map<string, DelegateTemplate>();
+  const trusted = isProjectTrusted(ctx);
+  // collect from all harnesses if no filter
+  if (harnessFilter) {
+    for (const [k, v] of loadTemplates(ctx.cwd, harnessFilter, trusted)) all.set(k, v);
+  } else {
+    for (const h of [...HARNESS_NAMES, 'shared']) {
+      for (const [k, v] of loadTemplates(ctx.cwd, h, trusted)) if (!all.has(k)) all.set(k, v);
+    }
+    // also load without harness param
+    for (const [k, v] of loadTemplates(ctx.cwd, undefined, trusted)) if (!all.has(k)) all.set(k, v);
+  }
+  const rows = [...all.values()].map(formatTemplateRow);
+  if (!ctx.hasUI) {
+    process.stdout.write(`${rows.join('\n')}\n`);
+    return;
+  }
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    let offset = 0;
+    const height = 12;
+    return {
+      render(width: number): string[] {
+        const header = theme.fg(
+          'accent',
+          `delegate — modes${harnessFilter ? ` (${harnessFilter})` : ''} (↑↓ scroll · any key to close)`,
+        );
+        const visible = rows.slice(offset, offset + height);
+        return [header, ...visible.map(l => theme.fg('muted', truncateToWidth(l, width)))];
+      },
+      handleInput(data: string): void {
+        if (matchesKey(data, Key.up) && offset > 0) {
+          offset--;
+          tui.requestRender();
+        } else if (matchesKey(data, Key.down) && offset < rows.length - 1) {
+          offset++;
+          tui.requestRender();
+        } else {
+          done(undefined);
+        }
+      },
+      invalidate() {},
+    };
+  });
+}
+
+export async function showStatus(ctx: ExtensionContext, harnessFilter?: string): Promise<void> {
+  const { config: cfg, source } = loadConfigWithSource();
+  const detection = await detectAll();
+  const trusted = isProjectTrusted(ctx);
+  const allHarnesses = harnessFilter ? [harnessFilter].filter(h => isKnownHarness(h)) : HARNESS_NAMES;
+  const lines: string[] = [];
+  lines.push(`delegate — status${harnessFilter ? ` (${harnessFilter})` : ''}`);
+  lines.push(...describeConfigSource(source));
+  lines.push(`defaultHarness: ${cfg.defaultHarness} · defaultMode: ${cfg.defaultMode} · model: ${cfg.model ?? '—'}`);
+  lines.push(
+    `maxConcurrent: ${typeof cfg.maxConcurrent === 'number' ? cfg.maxConcurrent : JSON.stringify(cfg.maxConcurrent)} · maxTranscripts: ${cfg.maxTranscripts}`,
+  );
+  lines.push(
+    trusted
+      ? 'project trust: trusted — project-local templates (.pi/delegate/templates/) are loaded'
+      : "project trust: untrusted — project-local templates skipped (trust this project via pi's trust prompt, or set defaultProjectTrust, to load them)",
+  );
+  lines.push('');
+  lines.push('harness              binary   ok  version              outputs  templates  active');
+  lines.push('─'.repeat(78));
+  for (const h of harnessFilter ? allHarnesses : HARNESS_NAMES) {
+    const det = detection[h] ?? { ok: false };
+    const harness = getHarness(h);
+    const bin = harness?.binary ?? h;
+    const ver = det.version ? det.version.slice(0, 18) : det.hint ? '—' : '—';
+    const ok = det.ok ? '✓' : '✗';
+    let outputs = 0;
+    try {
+      outputs = readdirSync(getOutputsDir(h)).filter(f => f.endsWith('.md')).length;
+    } catch {}
+    let templates = 0;
+    try {
+      templates = loadTemplates(ctx.cwd, h, trusted).size;
+    } catch {}
+    // cross-process count via the file registry, combined with the in-process counter as a fallback
+    const active = activeCount(h);
+    const cap = getMaxConcurrent(cfg, h);
+    const activeCol = `${active}/${cap > 0 ? cap : '∞'}`;
+    const hint = !det.ok && det.hint ? `  ← ${det.hint}` : '';
+    lines.push(
+      `${h.padEnd(20)} ${bin.padEnd(8)} ${ok.padEnd(3)} ${ver.padEnd(20)} ${String(outputs).padEnd(8)} ${String(templates).padEnd(10)} ${activeCol}${hint}`,
+    );
+  }
+  const historyEntries = harnessFilter ? readAllHistory().filter(e => e.harness === harnessFilter) : readAllHistory();
+  const spend = aggregateSpend(historyEntries.map(e => ({ harness: e.harness, cost: e.cost })));
+  lines.push('');
+  lines.push('spend:');
+  for (const h of harnessFilter ? allHarnesses : HARNESS_NAMES) {
+    const s = spend.byHarness[h];
+    lines.push(`  ${h}: ${s ? formatSpend(s) : '$0.000 over 0 run(s)'}`);
+  }
+  if (!harnessFilter) lines.push(`  total: ${formatSpend(spend.total)}`);
+  if (!harnessFilter) {
+    const globalCap = getMaxConcurrent(cfg);
+    lines.push('');
+    lines.push(
+      `global active: ${activeCount()}/${globalCap > 0 ? globalCap : '∞'} · aliases: ${
+        Object.entries(ALIASES)
+          .map(([k, v]) => `${k}→${v}`)
+          .join(', ') || '—'
+      }`,
+    );
+    lines.push(`outputs dir: ${getOutputsDir()} (plus ${legacyOutputsDir()} legacy)`);
+  }
+  if (!ctx.hasUI) {
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return;
+  }
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    let offset = 0;
+    const height = 14;
+    return {
+      render(width: number): string[] {
+        const header = theme.fg(
+          'accent',
+          `delegate status${harnessFilter ? ` — ${harnessFilter}` : ''} (↑↓ scroll · any key to close)`,
+        );
+        const visible = lines.slice(offset, offset + height);
+        return [header, ...visible.map(l => theme.fg('muted', truncateToWidth(l, width)))];
+      },
+      handleInput(data: string): void {
+        if (matchesKey(data, Key.up) && offset > 0) {
+          offset--;
+          tui.requestRender();
+        } else if (matchesKey(data, Key.down) && offset < lines.length - 1) {
+          offset++;
+          tui.requestRender();
+        } else done(undefined);
+      },
+      invalidate() {},
+    };
+  });
+}
+
+/**
+ * `/delegate config` — the discoverability gap `/delegate status`'s provenance line only hints at:
+ * shows exactly what was read from `settings.json` (or why it wasn't) plus the effective config
+ * with defaults filled in, formatted as a paste-ready JSON block under the `delegate` key. Print-
+ * only — writing is a separate, explicit action (`/delegate config init`, below), never triggered
+ * from this default view.
+ */
+export async function showConfig(ctx: ExtensionContext): Promise<void> {
+  const result = loadConfigWithSource();
+  const lines = ['delegate — config', '', ...buildConfigReport(result)];
+  if (!ctx.hasUI) {
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return;
+  }
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    let offset = 0;
+    const height = 20;
+    return {
+      render(width: number): string[] {
+        const header = theme.fg('accent', `delegate config — ${result.source.file} (↑↓ scroll · any key to close)`);
+        const visible = lines.slice(offset, offset + height);
+        return [header, ...visible.map(l => theme.fg('muted', truncateToWidth(l, width)))];
+      },
+      handleInput(data: string): void {
+        if (matchesKey(data, Key.up) && offset > 0) {
+          offset--;
+          tui.requestRender();
+        } else if (matchesKey(data, Key.down) && offset < lines.length - 1) {
+          offset++;
+          tui.requestRender();
+        } else done(undefined);
+      },
+      invalidate() {},
+    };
+  });
+}
+
+/**
+ * `/delegate config init` — the one place this extension ever writes to `settings.json`, and only
+ * because a human explicitly typed this subcommand. Writes the current effective config (defaults
+ * merged with whatever was already on disk, minus anything still at its default — pinning defaults would
+ * stop later releases' default changes reaching the user) into the `delegate` key via `writeDelegateConfig()`
+ * (read-modify-write, atomic, refuses on an unparseable file rather than clobbering it). This is
+ * also the practical fix for the legacy-`claudeDelegate`-only gap `describeConfigSource` warns
+ * about: writing an explicit `delegate` key (with the correctly-resolved values already folded
+ * in — the legacy migration already ran before this point) makes it win from then on, without
+ * this command ever touching or deleting the old `claudeDelegate` key itself.
+ */
+export async function initConfig(ctx: ExtensionContext): Promise<void> {
+  const result = loadConfigWithSource();
+  const write = writeDelegateConfig(nonDefaultConfig(result.config));
+  const msg = write.ok ? `✓ ${write.message}` : `✗ ${write.message}`;
+  if (!ctx.hasUI) process.stdout.write(`${msg}\n`);
+  else ctx.ui.notify?.(msg, write.ok ? 'info' : 'warning');
+}

package/extensions/templates.ts

@@ -30,6 +30,8 @@ export interface DelegateTemplate {
   defaultScope?: string;
   /** Host-run shell command executed after the harness exits to check its claims (e.g. `bun test`). */
   verify?: string;
+  /** Extra directories the harness may access (`addDirs: ../shared, /opt/lib` — comma-separated). */
+  addDirs?: string[];
   prompt: string;
   harness?: string;
 }
@@ -65,6 +67,15 @@ export function normalizePermission(
   return { permission: 'edit', permissionMode: 'acceptEdits' };
 }
 
+/** Comma-separated frontmatter list (`a, b`) — undefined when absent or empty. */
+function parseList(raw: string | undefined): string[] | undefined {
+  const items = (raw ?? '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
 /** Parse a template file: frontmatter (---\nkey: value\n---) + markdown body. */
 export function parseTemplate(text: string): DelegateTemplate | null {
   const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text.trimStart());
@@ -98,6 +109,7 @@ export function parseTemplate(text: string): DelegateTemplate | null {
     defaultTask: meta.defaultTask || undefined,
     defaultScope: meta.defaultScope || undefined,
     verify: meta.verify || undefined,
+    addDirs: parseList(meta.addDirs),
     prompt: m[2].trim(),
     harness: meta.harness || undefined,
   };
@@ -212,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 {