pi-better-harness 0.40.0 → 0.40.1

package/node_modules/pi-better-background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-background-tasks",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Pi extension for durable background shell tasks, watchers, logs, and status inspection.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-background-tasks/src/navigator-provider.ts

@@ -101,8 +101,12 @@ const provider: BackgroundWorkProvider = {
   },
   onVisibleChanged: (notify) => {
     const offMeta = onMetaChanged(notify);
-    const offDurable = getObservedWaitHost(piRef)?.onDurableTaskChange(notify);
+    const offDurable = getObservedWaitHost(piRef)?.onDurableTaskChange(() => {
+      invalidateDurableProjection();
+      notify();
+    });
     return () => {
+      invalidateDurableProjection();
       offMeta();
       offDurable?.();
     };
@@ -113,13 +117,30 @@ function navigatorHost() {
   return piRef ? getObservedWaitHost(piRef) : undefined;
 }
 
+/**
+ * One refresh asks for {@link provider.visibleCount} and then {@link provider.listRows},
+ * and a detail view asks again. Rebuilding the projection re-reads every durable
+ * record, so a single paint would pay for the same list up to three times. Hold
+ * one result per paint window; a durable-change notification clears it.
+ */
+const PROJECTION_MEMO_MS = 250;
+let projectionMemo: { at: number; tasks: DurableTaskProjection[] } | undefined;
+
+function invalidateDurableProjection(): void {
+  projectionMemo = undefined;
+}
+
 function visibleDurableTasks(now = Date.now()): DurableTaskProjection[] {
   const active = activeNavigatorOrigin;
   const host = navigatorHost();
   if (!active || !host) return [];
+  if (projectionMemo && now - projectionMemo.at < PROJECTION_MEMO_MS) {
+    return projectionMemo.tasks.filter((task) => !isExpiredDurableRow(task, now));
+  }
   const listed = host.listDurableTasks(active, { retentionMs: TERMINAL_NAVIGATOR_RETENTION_MS });
-  return listed
-    .filter((task) => task.dismissedAt === undefined && !isExpiredDurableRow(task, now));
+  const tasks = listed.filter((task) => task.dismissedAt === undefined);
+  projectionMemo = { at: now, tasks };
+  return tasks.filter((task) => !isExpiredDurableRow(task, now));
 }
 
 function durableTask(id: string): DurableTaskProjection | undefined {

package/node_modules/pi-better-background-tasks/src/observed-waits.ts

@@ -1366,8 +1366,10 @@ export class ObservedWaitHost {
 
   private projectDurable(operation: OperationRecord, now: number): DurableTaskProjection | undefined {
     const context = this.launchContext(operation.taskId);
+    // Projection is the rendering path: a snapshot reads the durable records
+    // without taking the cross-process fence or spawning `ps`.
     const inspection = LOCAL_DURABLE_ID.test(operation.taskId)
-      ? (() => { try { return this.supervisor.inspect(operation.taskId, { recordLost: false }); } catch { return undefined; } })()
+      ? (() => { try { return this.supervisor.snapshot(operation.taskId); } catch { return undefined; } })()
       : undefined;
     const storeStatus = operation.terminalRevision > 0 ? this.statusOf(operation.operationId) : undefined;
     const status: SupervisorTaskStatus = inspection?.terminal ? inspection.status : storeStatus ?? inspection?.status ?? "running";

package/node_modules/pi-better-background-tasks/src/process-identity.ts

@@ -1,41 +1,118 @@
 import { execFileSync } from "node:child_process";
 
-const selfStartToken = readProcessStartToken(process.pid);
+/**
+ * Process start-token reads.
+ *
+ * `ps` is a process spawn. Reading it on a rendering path — once per task, per
+ * frame, for every terminal task kept in the panel — is a measurable CPU drain
+ * on its own, and it competes with the very commands the panel is showing.
+ *
+ * Two rules keep that bounded:
+ *
+ * 1. A pid's start token is immutable for the life of that pid, so a short-lived
+ *    memo is safe. Entries expire so a recycled pid is re-read rather than
+ *    mistaking the previous owner's token for the current one, and failures are
+ *    memoized too, so a pid that cannot be read is not retried on every frame.
+ * 2. Callers that decide to *signal* a pid can ask for a fresh read. Liveness
+ *    display may use the memo; authorization may not.
+ */
 
-export function currentProcessStartToken(): string | undefined {
-  return selfStartToken;
+/** How long one pid→token answer is trusted. Short enough to bound pid reuse. */
+const TOKEN_MEMO_TTL_MS = 1_000;
+/** Bound on memo entries; the panel is small, but a long session is not. */
+const TOKEN_MEMO_MAX_ENTRIES = 512;
+
+interface TokenMemoEntry {
+    token: string | undefined;
+    readAt: number;
+}
+
+const tokenMemo = new Map<number, TokenMemoEntry>();
+
+function readTokenUncached(pid: number): string | undefined {
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return undefined;
+    try {
+        const output = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2_000,
+        }).trim();
+        return output || undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+function remember(pid: number, token: string | undefined, now: number): void {
+    if (tokenMemo.size >= TOKEN_MEMO_MAX_ENTRIES) {
+        // Drop expired entries first; only evict live ones if that was not enough.
+        for (const [candidate, entry] of tokenMemo) {
+            if (now - entry.readAt >= TOKEN_MEMO_TTL_MS) tokenMemo.delete(candidate);
+        }
+        if (tokenMemo.size >= TOKEN_MEMO_MAX_ENTRIES) {
+            const oldest = tokenMemo.keys().next();
+            if (!oldest.done) tokenMemo.delete(oldest.value);
+        }
+    }
+    tokenMemo.set(pid, { token, readAt: now });
 }
 
+/**
+ * Start token for `pid`, memoized for {@link TOKEN_MEMO_TTL_MS}.
+ *
+ * Suitable for liveness and display. A caller that is about to send a signal
+ * must use {@link readProcessStartTokenFresh} instead.
+ */
 export function readProcessStartToken(pid: number): string | undefined {
-  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return undefined;
-  try {
-    const output = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 2_000,
-    }).trim();
-    return output || undefined;
-  } catch {
-    return undefined;
-  }
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return undefined;
+    const now = Date.now();
+    const entry = tokenMemo.get(pid);
+    if (entry && now - entry.readAt < TOKEN_MEMO_TTL_MS) return entry.token;
+    const token = readTokenUncached(pid);
+    remember(pid, token, now);
+    return token;
+}
+
+/**
+ * Start token for `pid`, always read from the OS.
+ *
+ * Used where the answer authorizes a signal, so a recycled pid cannot inherit
+ * a memoized identity.
+ */
+export function readProcessStartTokenFresh(pid: number): string | undefined {
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return undefined;
+    const token = readTokenUncached(pid);
+    remember(pid, token, Date.now());
+    return token;
+}
+
+/** Drop every memoized identity. Tests and reloads start from a clean slate. */
+export function clearProcessIdentityMemo(): void {
+    tokenMemo.clear();
+}
+
+const selfStartToken = readTokenUncached(process.pid);
+
+export function currentProcessStartToken(): string | undefined {
+    return selfStartToken;
 }
 
 export function processIdentityAlive(
-  pid: number | undefined,
-  recordedStartToken?: string,
-  recordedAt?: number,
+    pid: number | undefined,
+    recordedStartToken?: string,
+    recordedAt?: number,
 ): boolean {
-  if (!pid || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "EPERM") return false;
-  }
-  const current = readProcessStartToken(pid);
-  if (recordedStartToken && current) return recordedStartToken === current;
-  if (!recordedStartToken && current && recordedAt !== undefined) {
-    const currentStartedAt = Date.parse(current);
-    if (Number.isFinite(currentStartedAt) && currentStartedAt > recordedAt + 2_000) return false;
-  }
-  return true;
-}
+    if (!pid || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "EPERM") return false;
+    }
+    const current = readProcessStartToken(pid);
+    if (recordedStartToken && current) return recordedStartToken === current;
+    if (!recordedStartToken && current && recordedAt !== undefined) {
+        const currentStartedAt = Date.parse(current);
+        if (Number.isFinite(currentStartedAt) && currentStartedAt > recordedAt + 2_000) return false;
+    }
+    return true;
+}

package/node_modules/pi-better-background-tasks/src/supervisor/generated/process-identity.mjs

@@ -2,11 +2,28 @@
 // Do not edit: change the source and re-run the emitter (a drift test enforces this).
 
 import { execFileSync } from "node:child_process";
-const selfStartToken = readProcessStartToken(process.pid);
-export function currentProcessStartToken() {
-    return selfStartToken;
-}
-export function readProcessStartToken(pid) {
+/**
+ * Process start-token reads.
+ *
+ * `ps` is a process spawn. Reading it on a rendering path — once per task, per
+ * frame, for every terminal task kept in the panel — is a measurable CPU drain
+ * on its own, and it competes with the very commands the panel is showing.
+ *
+ * Two rules keep that bounded:
+ *
+ * 1. A pid's start token is immutable for the life of that pid, so a short-lived
+ *    memo is safe. Entries expire so a recycled pid is re-read rather than
+ *    mistaking the previous owner's token for the current one, and failures are
+ *    memoized too, so a pid that cannot be read is not retried on every frame.
+ * 2. Callers that decide to *signal* a pid can ask for a fresh read. Liveness
+ *    display may use the memo; authorization may not.
+ */
+/** How long one pid→token answer is trusted. Short enough to bound pid reuse. */
+const TOKEN_MEMO_TTL_MS = 1_000;
+/** Bound on memo entries; the panel is small, but a long session is not. */
+const TOKEN_MEMO_MAX_ENTRIES = 512;
+const tokenMemo = new Map();
+function readTokenUncached(pid) {
     if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32")
         return undefined;
     try {
@@ -21,6 +38,59 @@ export function readProcessStartToken(pid) {
         return undefined;
     }
 }
+function remember(pid, token, now) {
+    if (tokenMemo.size >= TOKEN_MEMO_MAX_ENTRIES) {
+        // Drop expired entries first; only evict live ones if that was not enough.
+        for (const [candidate, entry] of tokenMemo) {
+            if (now - entry.readAt >= TOKEN_MEMO_TTL_MS)
+                tokenMemo.delete(candidate);
+        }
+        if (tokenMemo.size >= TOKEN_MEMO_MAX_ENTRIES) {
+            const oldest = tokenMemo.keys().next();
+            if (!oldest.done)
+                tokenMemo.delete(oldest.value);
+        }
+    }
+    tokenMemo.set(pid, { token, readAt: now });
+}
+/**
+ * Start token for `pid`, memoized for {@link TOKEN_MEMO_TTL_MS}.
+ *
+ * Suitable for liveness and display. A caller that is about to send a signal
+ * must use {@link readProcessStartTokenFresh} instead.
+ */
+export function readProcessStartToken(pid) {
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32")
+        return undefined;
+    const now = Date.now();
+    const entry = tokenMemo.get(pid);
+    if (entry && now - entry.readAt < TOKEN_MEMO_TTL_MS)
+        return entry.token;
+    const token = readTokenUncached(pid);
+    remember(pid, token, now);
+    return token;
+}
+/**
+ * Start token for `pid`, always read from the OS.
+ *
+ * Used where the answer authorizes a signal, so a recycled pid cannot inherit
+ * a memoized identity.
+ */
+export function readProcessStartTokenFresh(pid) {
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32")
+        return undefined;
+    const token = readTokenUncached(pid);
+    remember(pid, token, Date.now());
+    return token;
+}
+/** Drop every memoized identity. Tests and reloads start from a clean slate. */
+export function clearProcessIdentityMemo() {
+    tokenMemo.clear();
+}
+const selfStartToken = readTokenUncached(process.pid);
+export function currentProcessStartToken() {
+    return selfStartToken;
+}
 export function processIdentityAlive(pid, recordedStartToken, recordedAt) {
     if (!pid || pid <= 0)
         return false;

package/node_modules/pi-better-background-tasks/src/supervisor/supervisor.ts

@@ -376,9 +376,22 @@ class Supervisor implements LocalSupervisor {
     const command = readCommandRecord(this.directory, taskId).value;
     const stop = readStopRequest(this.directory, taskId);
     const cleanup = readCleanupRecord(this.directory, taskId);
+    // Reading a process start token spawns `ps`. A task that already published a
+    // terminal/lost record cannot change state again, so its liveness only
+    // matters to the one caller that may still act on a surviving command group
+    // (`stop`). Every other reader would pay for an answer it does not use, once
+    // per task per panel frame. Probe only when that authority is actually needed.
+    const needsLiveness = result === undefined && lostRecord === undefined
+      ? true
+      : result !== undefined && result.groupCleanup === "unproven"
+        || lostRecord !== undefined;
     // One identity source per instance: liveness and signalling agree.
-    const claimAlive = claim ? identityAlive(claim.pid, claim.pidStartTime, claim.claimedAt, this.readToken) : false;
-    const commandAlive = command ? identityAlive(command.pid, command.pidStartTime, command.startedAt, this.readToken) : false;
+    const claimAlive = needsLiveness && claim
+      ? identityAlive(claim.pid, claim.pidStartTime, claim.claimedAt, this.readToken)
+      : false;
+    const commandAlive = needsLiveness && command
+      ? identityAlive(command.pid, command.pidStartTime, command.startedAt, this.readToken)
+      : false;
 
     // A published terminal/lost record needs no fence. Anything else is decided
     // under the fence, so a `lost` attestation and a claim cannot both win.
@@ -426,6 +439,67 @@ class Supervisor implements LocalSupervisor {
     };
   }
 
+  /**
+   * Read-only projection for rendering: no fence, no lost publication, no `ps`.
+   *
+   * `inspect` is the authoritative path and pays for that authority — a
+   * cross-process SQLite fence and a process-identity probe per recorded pid.
+   * A panel asks per task per frame, so it reads what the records already say.
+   */
+  snapshot(taskId: string): SupervisorInspection | undefined {
+    const launchRead = readLaunchRecord(this.directory, taskId);
+    if (launchRead.missing) return undefined;
+    if (!launchRead.value) {
+      throw new Error(`Unreadable supervisor launch record for ${taskId}: ${launchRead.error}`);
+    }
+    const launch = launchRead.value;
+    const paths = supervisorPaths(this.directory, taskId);
+    const result = readTerminalRecord(this.directory, taskId).value;
+    const lostRecord = readLostRecord(this.directory, taskId).value;
+    const claim = readClaimRecord(this.directory, taskId).value;
+    const command = readCommandRecord(this.directory, taskId).value;
+    const stop = readStopRequest(this.directory, taskId);
+    const cleanup = readCleanupRecord(this.directory, taskId);
+    const status: SupervisorTaskStatus = result
+      ? (result.status as SupervisorTaskStatus)
+      : lostRecord
+        ? "lost"
+        : claim
+          ? "running"
+          : "starting";
+    return {
+      taskId,
+      token: launch.token,
+      kind: launch.kind,
+      status,
+      terminal: result !== undefined || lostRecord !== undefined,
+      launch: launchSummary(launch),
+      // Liveness is deliberately not asserted here: a snapshot never spawns `ps`.
+      ...(claim === undefined
+        ? {}
+        : { claim: { pid: claim.pid, pidStartTime: claim.pidStartTime, claimedAt: claim.claimedAt, alive: false } }),
+      ...(command === undefined
+        ? {}
+        : {
+          command: {
+            pid: command.pid,
+            pgid: command.pgid,
+            pidStartTime: command.pidStartTime,
+            startedAt: command.startedAt,
+            attempt: command.attempt ?? 1,
+            alive: false,
+          },
+        }),
+      ...(result === undefined ? {} : { result }),
+      ...(lostRecord === undefined ? {} : { lost: lostRecord }),
+      ...(cleanup === undefined ? {} : { cleanup }),
+      ...(stop === undefined ? {} : { stopRequestedAt: stop.requestedAt }),
+      taskDir: paths.dir,
+      logs: { stdout: paths.stdout, stderr: paths.stderr, events: paths.events },
+      observedAt: Date.now(),
+    };
+  }
+
   /**
    * Decide the state of a launch with no terminal result, under the cross-process
    * fence. This is the only place a `lost` record is published, so it can never

package/node_modules/pi-better-background-tasks/src/supervisor/types.ts

@@ -380,5 +380,15 @@ export interface LocalSupervisorOptions {
 export interface LocalSupervisor {
   start(options: SupervisorStartOptions): Promise<SupervisorStartResult>;
   inspect(taskId: string, options?: SupervisorInspectOptions): SupervisorInspection | undefined;
+  /**
+   * Read-only projection of the durable records: no state fence, no lost
+   * publication and no process-identity probe.
+   *
+   * This is the rendering path. `inspect` may take a cross-process SQLite fence
+   * and spawn `ps` per task, which must not happen once per task per frame. A
+   * snapshot reports what the records already say — `running` for a claim,
+   * `starting` before one — and leaves reconciliation to the caller's cadence.
+   */
+  snapshot(taskId: string): SupervisorInspection | undefined;
   stop(taskId: string, options?: SupervisorStopOptions): Promise<SupervisorStopResult | undefined>;
 }

package/node_modules/pi-better-subagents/effective-settings.ts

@@ -28,19 +28,40 @@ export function effectiveSubagentSettings(
 }
 
 export function formatSubagentSettings(settings: EffectiveSubagentSettings): string {
+    const manual = settings.delegationMode === "manual";
+    const capacity = manual
+        ? "The limit is a ceiling, not a target. In manual mode it bounds only work the user or an active workflow explicitly delegates; no slot count is an invitation to launch work."
+        : "The limit is a ceiling, not a target. Launch ready, independent, useful work when a suitable subagent is available.";
+    // No occupancy counters here. This text is injected into the conversation and
+    // may only ever be appended to, so anything volatile would force either a
+    // rewrite of already-sent content (which invalidates the provider's cached
+    // prefix) or one more copy per change. Admission rechecks capacity at the
+    // spawn anyway; live counts stay available through the subagent_settings tool.
     return [
         `Subagent settings: revision ${settings.revision}`,
         `Delegation: ${settings.delegationMode} (${settings.sources.delegationMode})`,
         `Concurrency limit: ${settings.maxConcurrent} (${settings.sources.maxConcurrent})`,
-        `Running: ${settings.runningCount}; reserved: ${settings.pendingCount}`,
-        `Occupied slots: ${settings.occupiedSlots}`,
-        `Available slots: ${settings.availableSlots}`,
-        "The limit is a ceiling, not a target. Launch ready, independent, useful work within available capacity. " +
-            "This is a point-in-time snapshot; spawn admission rechecks capacity. Lowering the limit does not stop existing runs.",
+        // Mode first: the policy governs the settings that follow it.
         delegationPrompt(settings.delegationMode),
+        capacity + " Spawn admission rechecks capacity; lower the limit without stopping existing runs.",
     ].join("\n");
 }
 
+/**
+ * Append the delegation policy to the end of the system prompt.
+ *
+ * The system prompt is not part of the compaction window, so the policy survives
+ * a summary that rewrites the conversation. It is also part of the cached
+ * prefix, so it costs nothing per request while it stays unchanged.
+ *
+ * Nothing volatile goes in here: live occupancy would rewrite the cached prefix
+ * on every run, and admission rechecks capacity at spawn anyway.
+ */
+export function appendSubagentSettings(systemPrompt: string, settings: EffectiveSubagentSettings): string {
+    const policy = formatSubagentSettings(settings);
+    return systemPrompt.includes(policy) ? systemPrompt : `${systemPrompt}\n\n${policy}`;
+}
+
 export function subagentSettingsTool(Type: any, read: () => EffectiveSubagentSettings) {
     return {
         name: "subagent_settings",

package/node_modules/pi-better-subagents/index.ts

@@ -38,7 +38,7 @@ import { selectSessionByName } from "./session-selection.ts";
 import { isWithinWorkspace } from "./workspace-scope.ts";
 import { loadConfig, writeDelegationMode, writeSubagentSettings, isConcurrencyCap, normalizeConcurrencyCap, normalizeTools, resolveExtensionPath, configPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS } from "./config.ts";
 import { createSubagentSettingsPage } from "./settings-page.ts";
-import { effectiveSubagentSettings, formatSubagentSettings, subagentSettingsTool, SUBAGENT_SETTINGS_CONTEXT } from "./effective-settings.ts";
+import { appendSubagentSettings, effectiveSubagentSettings, formatSubagentSettings, subagentSettingsTool, SUBAGENT_SETTINGS_CONTEXT } from "./effective-settings.ts";
 import { STEER_FILE_ENV, readSteerReceipt } from "./child-steer.ts";
 import {
     decideTiming,
@@ -3603,18 +3603,12 @@ export default function (pi: ExtensionAPI) {
     pi.registerTool(discoveryTool as Parameters<ExtensionAPI["registerTool"]>[0]);
 
     pi.on("before_agent_start", (event) => ({
-        systemPrompt: `${appendExecutionPolicy(event.systemPrompt)}\n\nUse the latest Subagent settings context block as the authoritative delegation mode and capacity snapshot. Its delegation guidance replaces earlier mode-specific guidance, including guidance in a plan. Inspect subagent_settings when needed; never treat the concurrency limit as a target number of agents.`,
+        systemPrompt: appendSubagentSettings(
+            `${appendExecutionPolicy(event.systemPrompt)}\n\nTreat the Subagent settings block at the end of this prompt as the authoritative delegation mode and cap. Its delegation guidance replaces earlier mode-specific guidance, including guidance in a plan. Live occupancy is not pushed into context: inspect subagent_settings when it matters, and never treat the concurrency limit as a target number of agents.`,
+            effectiveSettings(),
+        ),
     }));
 
-    pi.on("context", (event) => {
-        const settings = effectiveSettings();
-        return { messages: [
-            ...event.messages.filter(message => message.role !== "custom" || message.customType !== SUBAGENT_SETTINGS_CONTEXT),
-            { role: "custom" as const, customType: SUBAGENT_SETTINGS_CONTEXT,
-                content: formatSubagentSettings(settings), display: false, details: settings, timestamp: Date.now() },
-        ] };
-    });
-
     // ---- live-status lifecycle -----------------------------------------
     pi.on("agent_start", async (_event, ctx) => {
         setCallbackBatchContext(pi, ctx);

package/node_modules/pi-better-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.40.0",
+  "version": "0.40.1",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, model routing, and Outcome & Todo.",
   "license": "MIT",
   "type": "module",
@@ -55,13 +55,13 @@
     "test": "node --import tsx --import ../../scripts/isolate-registry.mjs --test test/*.test.mjs test/*.test.ts test/task-context/*.test.ts"
   },
   "dependencies": {
-    "pi-better-background-tasks": "0.14.0",
+    "pi-better-background-tasks": "0.14.1",
     "pi-better-goal": "0.12.0",
     "pi-better-model-router": "0.1.2",
     "pi-ollama-cloud": "0.13.1",
     "pi-better-sandbox": "0.14.1",
     "pi-better-ssh": "0.1.4",
-    "pi-better-subagents": "0.27.0",
+    "pi-better-subagents": "0.27.1",
     "proper-lockfile": "^4.1.2",
     "shell-quote": "1.12.0",
     "smol-toml": "1.9.0",