pi-pier 0.2.5 → 0.2.7

package/src/core/terminal.ts

@@ -13,6 +13,7 @@ import type { HerdrClientLike } from '../herdr-client.ts';
 import {
   READINESS_TIMEOUT_MS,
   READ_MAX_CHARS,
+  TERM_REMINDER_CUSTOM_TYPE,
   TERMINALS_CUSTOM_TYPE,
   activeTerminalPaneIds,
   classifyReadiness,
@@ -21,10 +22,12 @@ import {
   detectFullscreenTUI,
   foldTerminalsRegistry,
   makeTerminalsRegistry,
+  planIdleTerminalReminder,
   promptStrategyFor,
   registerTerminal,
   stripAnsi,
   summarizeSessions,
+  terminalReminderGraceMs,
   validateSendText,
   validateSignal,
   type ReadCursor,
@@ -95,7 +98,85 @@ export default function terminalPlugin(ctx: Context): void {
     rebuildTerminals(eventCtx);
   });
 
+  // Session teardown (quit / Ctrl+D / SIGTERM) is the last chance to reclaim resident shells:
+  // terminals are persistent by design, so a master that exits without closing them leaks live
+  // zsh panes. Session SWITCH never fires this event (only session_start/session_tree), so
+  // switching branches cannot kill shells that the registry replays on the next session_start.
+  scoped.on('session_shutdown', async () => {
+    idleReminderTimer && clearTimeout(idleReminderTimer);
+    idleReminderTimer = null;
+    const open = terminals.filter((t) => t.status === 'open');
+    if (open.length === 0) return;
+    await Promise.allSettled(open.map((t) => client.closePane(t.paneId)));
+    const now = Date.now();
+    terminals = terminals.map((t) =>
+      t.status === 'open' ? { ...t, status: 'closed' as const, closedAt: now } : t,
+    );
+    persistTerminals();
+  });
+
+  // Turn-end nudge: remind the model to close terminals idle past the threshold (wF:p7 orphan —
+  // a one-shot background compile left a dead split in the main tab forever). Same delivery
+  // shape as the todo stop reminder: grace window, cancel on agent_start, capped followUp.
+  const piSend = surface.raw as {
+    sendMessage?: (
+      message: { customType: string; content: string; display?: boolean },
+      opts?: { deliverAs?: string; triggerTurn?: boolean },
+    ) => Promise<void>;
+  };
+  let idleReminders = 0;
+  let idleReminderTimer: NodeJS.Timeout | null = null;
+  scoped.on('agent_start', () => {
+    if (idleReminderTimer !== null) {
+      clearTimeout(idleReminderTimer);
+      idleReminderTimer = null;
+    }
+  });
+  scoped.on('agent_settled', async () => {
+    if (idleReminderTimer !== null) {
+      clearTimeout(idleReminderTimer);
+      idleReminderTimer = null;
+    }
+    const plan = planIdleTerminalReminder({
+      open: terminals.filter((t) => t.status === 'open'),
+      now: Date.now(),
+      reminders: idleReminders,
+    });
+    if (!plan.due || plan.content == null) return;
+    // 01a06ae3 goodbye-loop: mark the covered terminals nudged NOW (persisted), and deliver the
+    // notice as a queued followUp WITHOUT triggerTurn — a reminder alone must never wake the
+    // agent, or a farewell exchange loops: wake → polite goodbye → settle → nudge → wake …
+    const now = Date.now();
+    const ids = new Set(plan.ids);
+    terminals = terminals.map((t) => (ids.has(t.terminalId) ? { ...t, nudgedAt: now } : t));
+    persistTerminals();
+    idleReminders += 1;
+    const content = plan.content;
+    idleReminderTimer = setTimeout(() => {
+      idleReminderTimer = null;
+      void (async () => {
+        const send = piSend.sendMessage;
+        if (typeof send !== 'function') return;
+        try {
+          await send(
+            { customType: TERM_REMINDER_CUSTOM_TYPE, content, display: true },
+            { deliverAs: 'followUp' },
+          );
+        } catch {
+          /* Delivery failure is non-fatal; the cap already bounds retries. */
+        }
+      })();
+    }, terminalReminderGraceMs());
+    idleReminderTimer.unref?.();
+  });
+
   const TERM_READ_MAX = Number(process.env.PI_HERDR_TERM_READ_MAX ?? READ_MAX_CHARS) || READ_MAX_CHARS;
+  /** wait action: default and ceiling for the blocking output wait (an LLM call must not hang forever). */
+  const WAIT_DEFAULT_MS = 120_000;
+  const WAIT_MAX_MS = 600_000;
+  /** wait action: recent-tail size handed back on timeout so the model can decide the next move. */
+  const WAIT_TAIL_CHARS = 2_000;
+
   const errText = (msg: string) => ({ content: [{ type: 'text' as const, text: `Error: ${msg}` }], details: {} });
 
   scoped.registerTool({
@@ -103,22 +184,30 @@ export default function terminalPlugin(ctx: Context): void {
     label: 'Terminal',
     description: [
       'Manage persistent interactive terminals (resident shells in dedicated herdr panes).',
-      'Operations: open (create session), send (type commands), read (capture output), signal (ctrl+c/ctrl+d/ctrl+z/esc/enter), close (kill shell), list (show all).',
+      'Operations: open (create session), send (type commands), wait (block until output matches a pattern), read (capture output), signal (ctrl+c/ctrl+d/ctrl+z/esc/enter), close (kill shell), list (show all).',
       'The shell keeps cwd, environment variables, and background processes across calls.',
       'Use for dev servers, REPLs, or multi-step shell work — not one-shot bash calls.',
+      'Close a terminal with action: "close" as soon as the work in it is done — finished terminals are never auto-reclaimed and keep occupying a pane.',
+      'Long job pattern: send "cmd; echo TERM_DONE_$?" then wait with pattern "TERM_DONE_" — the sentinel also carries the exit code; redirect verbose output to a log file and read the file, because output between two reads is lost.',
+      'After send, use read to confirm the command actually started; multi-line text executes line-by-line. send(wait_prompt: true) refuses to queue text while a previous command is still running.',
     ].join(' '),
     parameters: Type.Object({
       action: Type.Union([
         Type.Literal('open'),
         Type.Literal('send'),
+        Type.Literal('wait'),
         Type.Literal('read'),
         Type.Literal('signal'),
         Type.Literal('close'),
         Type.Literal('list'),
       ], { description: 'Terminal operation to perform' }),
       cwd: Type.Optional(Type.String({ description: '[open] Working directory for the shell (defaults to session cwd)' })),
-      terminal_id: Type.Optional(Type.String({ description: '[send|read|signal|close] Terminal id returned by open action' })),
+      terminal_id: Type.Optional(Type.String({ description: '[send|wait|read|signal|close] Terminal id returned by open action' })),
       text: Type.Optional(Type.String({ description: '[send] Command text to type and run (Enter appended automatically)' })),
+      wait_prompt: Type.Optional(Type.Boolean({ description: '[send] Verify the shell is back at a prompt before sending; refuses with the detected readiness instead of queueing text behind a running command' })),
+      pattern: Type.Optional(Type.String({ description: '[wait] Literal text or regular expression to wait for in pane output' })),
+      regex: Type.Optional(Type.Boolean({ description: '[wait] Treat pattern as a regular expression (default: literal substring)' })),
+      timeout_ms: Type.Optional(Type.Number({ description: '[wait] Give up after this many ms (default 120000, max 600000)' })),
       pane_id: Type.Optional(Type.String({ description: '[read] Direct pane read (limited to own tab panes only)' })),
       max_chars: Type.Optional(Type.Number({ description: '[read] Output cap for this read (default 10000)' })),
       key: Type.Optional(Type.String({ description: '[signal] Control key: ctrl+c | ctrl+d | ctrl+z | esc | enter' })),
@@ -128,18 +217,33 @@ export default function terminalPlugin(ctx: Context): void {
       switch (action) {
         case 'open': return executeTerminalOpen(params, ctx);
         case 'send': return executeTerminalSend(params);
+        case 'wait': return executeTerminalWait(params);
         case 'read': return executeTerminalRead(params);
         case 'signal': return executeTerminalSignal(params);
         case 'close': return executeTerminalClose(params);
         case 'list': return executeTerminalList();
         default:
           return errText(action
-            ? `unknown action "${action}" (valid: open, send, read, signal, close, list)`
-            : 'action is required (open, send, read, signal, close, list)');
+            ? `unknown action "${action}" (valid: open, send, wait, read, signal, close, list)`
+            : 'action is required (open, send, wait, read, signal, close, list)');
       }
     },
   });
 
+  /** Probe whether the shell sits at its interactive prompt (advisory: probe failures degrade to 'busy'). */
+  async function probeReadiness(paneId: string): Promise<'prompt' | 'silent' | 'busy'> {
+    const prompt = promptStrategyFor();
+    try {
+      const matched = await client.waitForOutput(paneId, { type: 'regex', value: prompt.waitPattern }, READINESS_TIMEOUT_MS);
+      if (matched) return 'prompt';
+      const read = await client.readPane(paneId, { stripAnsi: false });
+      return classifyReadiness(stripAnsi(read.text), { silentMs: 0, prompt });
+    } catch {
+      /* Readiness is advisory, so probe failures still leave a usable terminal. */
+      return 'busy';
+    }
+  }
+
   async function executeTerminalOpen(params, ctx) {
     if (!client.available || !env) return errText('terminal tools require a herdr-managed pane');
     const cwd = typeof params?.cwd === 'string' && params.cwd ? params.cwd
@@ -160,18 +264,7 @@ export default function terminalPlugin(ctx: Context): void {
     r.entry.paneId = paneId;
     terminals = r.entries;
     persistTerminals();
-    const prompt = promptStrategyFor();
-    let readiness: 'prompt' | 'silent' | 'busy' = 'busy';
-    try {
-      const matched = await client.waitForOutput(paneId, { type: 'regex', value: prompt.waitPattern }, READINESS_TIMEOUT_MS);
-      if (matched) readiness = 'prompt';
-      else {
-        const read = await client.readPane(paneId, { stripAnsi: false });
-        readiness = classifyReadiness(stripAnsi(read.text), { silentMs: 0, prompt });
-      }
-    } catch {
-      /* Readiness is advisory, so probe failures still leave a usable terminal. */
-    }
+    const readiness = await probeReadiness(paneId);
     const text = [
       `terminal ${r.entry.terminalId} open (pane ${paneId})`,
       `cwd: ${cwd}`,
@@ -185,6 +278,18 @@ export default function terminalPlugin(ctx: Context): void {
     if (!entry) return errText(`unknown or closed terminal "${String(params?.terminal_id)}" (see action list)`);
     const v = validateSendText(typeof params?.text === 'string' ? params.text : '');
     if (!v.ok) return errText(v.error);
+    if (params?.wait_prompt === true) {
+      // Orchestration convention: read before writing. Text typed while a previous command still
+      // owns the foreground gets queued and fires later, which reads as "the shell ignored me".
+      // Refuse with the observed readiness instead of guessing.
+      const readiness = await probeReadiness(entry.paneId);
+      if (readiness !== 'prompt') {
+        return errText(
+          `shell is ${readiness === 'busy' ? 'busy (a previous command may still be running)' : 'silent (no prompt detected)'} — text was NOT sent. `
+            + 'Use action read to inspect the pane, or omit wait_prompt to send anyway.',
+        );
+      }
+    }
     try {
       await client.sendPaneText(entry.paneId, v.text);
     } catch (e) {
@@ -194,6 +299,50 @@ export default function terminalPlugin(ctx: Context): void {
     return { content: [{ type: 'text', text: `sent to ${entry.terminalId} (${v.text.length} chars)` }], details: { terminal_id: entry.terminalId } };
   }
 
+  async function executeTerminalWait(params) {
+    const entry = findOpenTerminal(params?.terminal_id);
+    if (!entry) return errText(`unknown or closed terminal "${String(params?.terminal_id)}" (see action list)`);
+    const raw = typeof params?.pattern === 'string' ? params.pattern : '';
+    if (!raw) return errText('pattern is required (literal text, or a regular expression with regex: true)');
+    const useRegex = params?.regex === true;
+    if (useRegex) {
+      try {
+        new RegExp(raw);
+      } catch (e) {
+        return errText(`invalid regex: ${(e as Error).message}`);
+      }
+    }
+    const requested = typeof params?.timeout_ms === 'number' && params.timeout_ms > 0 ? params.timeout_ms : WAIT_DEFAULT_MS;
+    const timeoutMs = Math.min(Math.max(requested, 1000), WAIT_MAX_MS);
+    const matcher = useRegex ? { type: 'regex' as const, value: raw } : { type: 'substring' as const, value: raw };
+    let matched: boolean | null;
+    try {
+      matched = await client.waitForOutput(entry.paneId, matcher, timeoutMs);
+    } catch (e) {
+      return errText(`wait failed (pane may be closed): ${(e as Error).message}`);
+    }
+    if (matched !== true) {
+      // wait-for-text convention: on timeout, hand back the recent tail so the model can decide
+      // the next move instead of re-polling blind.
+      let tail = '';
+      try {
+        const read = await client.readPane(entry.paneId, { stripAnsi: false });
+        tail = stripAnsi(read.text).slice(-WAIT_TAIL_CHARS);
+      } catch {
+        /* The pane is gone; the timeout text alone still tells the model it is stuck. */
+      }
+      const reason = matched === false ? 'no match' : 'wait unavailable';
+      return {
+        content: [{ type: 'text', text: `no match within ${timeoutMs}ms (${reason}).${tail ? `\nrecent output tail:\n${tail}` : ''}` }],
+        details: { terminal_id: entry.terminalId, matched: false, pattern: raw },
+      };
+    }
+    return {
+      content: [{ type: 'text', text: `matched in ${entry.terminalId} — output is ready, use action read to inspect it` }],
+      details: { terminal_id: entry.terminalId, matched: true, pattern: raw },
+    };
+  }
+
   async function executeTerminalRead(params) {
     let paneId: string | null = null;
     let entry: TerminalEntry | null = null;

package/src/core/todo.ts

@@ -3,15 +3,16 @@
  *
  * A Cordis plugin keeps the master surface hot-swappable while allowing workers to mount the
  * one-shot subset directly. Injected services preserve the D79 registration boundary and keep
- * session-owned todo state in index. This module owns the tool, command, widget, and read hook;
- * reconciliation, mirroring, and agent reporting stay with the session state layer to avoid a
- * dependency cycle.
+ * session-owned todo state in index. This module owns the tool, command, widget, read hook,
+ * and master stop reminder; reconciliation, mirroring, and agent reporting stay with the
+ * session state layer to avoid a dependency cycle.
  */
 import { Context } from '@deepseek-ai/cordis';
 import { Type } from 'typebox';
 import type { PiSurface } from '../pi-surface.ts';
 import type { TodosService } from '../todos-service.ts';
 import { planTodoReadHook } from '../todo-read-hook.ts';
+import { TODO_REMINDER_CUSTOM_TYPE, planStopTodoReminder, todoReminderGraceMs } from '../todo-reminder-core.ts';
 import { makeProgressUpdate } from '../subagent-core.ts';
 import { TODO_DETAILS_KEY, TODO_TOOL_NAME, formatTodoConfirmation, type TodoItem } from '../vocab.ts';
 import { formatAge, isArchived } from '../stale-core.ts';
@@ -30,6 +31,8 @@ import { anchorTodoRange, formatTodoSummary, renderTodoGroups } from '../todo-wi
 export interface TodoUiSlot {
   /** Lets index lifecycle events render through the currently mounted plugin. */
   renderWidget: (ctx: unknown) => void;
+  /** Re-render from the last seen context without a fresh event (human-gate open/close). */
+  rerenderWidget?: () => void;
 }
 
 interface TodoDeps {
@@ -40,6 +43,13 @@ interface TodoDeps {
   mirrorTodos: () => void;
   appendEntry: (customType: string, data: unknown) => void;
   state: TodoUiSlot;
+  /** Human-gate depth (ask_user_question / herdr:blocked); >0 collapses the widget to one line. */
+  getBlockedDepth?: () => number;
+  /** Master-only unfinished-todo reminder; omitted on worker panes. */
+  stopReminder?: {
+    getBlockedDepth: () => number;
+    getRunningSubs: () => number;
+  };
 }
 
 const TOOL_DESCRIPTION = [
@@ -61,8 +71,18 @@ export const WIDGET_MAX_LINES = 10;
  * completions. A +N line points to /todos when the full plan cannot fit. This fixes 01a03c0d,
  * where active work scrolled out while only the final entries remained visible.
  */
-export function widgetLines(items: readonly TodoItem[], opts?: { archivedAgeMs?: number | null }): string[] {
+export function widgetLines(
+  items: readonly TodoItem[],
+  opts?: { archivedAgeMs?: number | null; blockedDepth?: number | null },
+): string[] {
   if (items.length === 0) return [];
+  // Human gate open (ask_user_question waiting): the question + editor own the fixed area, so the
+  // widget collapses to the one-line summary — /todos still reaches the full list. Without this,
+  // a 10-line widget plus a multi-line question leaves almost no scrollable transcript
+  // (user-reported: both blocks visible ⇒ history range too small).
+  if ((opts?.blockedDepth ?? 0) > 0) {
+    return [`${formatTodoSummary(items)} · /todos 全量`];
+  }
   // Collapse archived plans to two lines so stale work cannot monopolize the widget.
   if (opts?.archivedAgeMs != null) {
     return [
@@ -89,7 +109,7 @@ export function widgetLines(items: readonly TodoItem[], opts?: { archivedAgeMs?:
 
 export default function todoPlugin(ctx: Context): void {
   const surface = ctx.get('pi-herdr.surface') as PiSurface<object>;
-  const { todos, allowParallelInProgress, maxItems, mirrorTodos, appendEntry, state } =
+  const { todos, allowParallelInProgress, maxItems, mirrorTodos, appendEntry, state, stopReminder, getBlockedDepth } =
     ctx.get('pi-herdr.todo-deps') as TodoDeps;
   const scoped = surface.forModule(import.meta.url);
 
@@ -109,9 +129,15 @@ export default function todoPlugin(ctx: Context): void {
       : undefined;
   }
 
+  /** Gate transitions fire outside lifecycle events; remember one ctx so rerenderWidget can target the live ui. */
+  let lastEventCtx: unknown = null;
   function renderWidget(eventCtx: unknown): void {
+    if (eventCtx !== null && eventCtx !== undefined) lastEventCtx = eventCtx;
     try {
-      widgetUi(eventCtx)?.setWidget?.('todos', widgetLines(todos.items, { archivedAgeMs: archivedAgeMs() }));
+      widgetUi(eventCtx)?.setWidget?.('todos', widgetLines(todos.items, {
+        archivedAgeMs: archivedAgeMs(),
+        blockedDepth: getBlockedDepth?.() ?? 0,
+      }));
     } catch {
       /* Older pi versions may omit widget support without disabling todo tracking. */
     }
@@ -119,6 +145,7 @@ export default function todoPlugin(ctx: Context): void {
 
   // Let index lifecycle hooks call the current plugin implementation.
   state.renderWidget = renderWidget;
+  state.rerenderWidget = () => renderWidget(lastEventCtx);
 
   /* ── Read hook: D39 reminders and stale-plan thawing ────────────── */
   let todoReadTurn = 0;
@@ -178,6 +205,64 @@ export default function todoPlugin(ctx: Context): void {
     };
   });
 
+  if (stopReminder) {
+    const pi = surface.raw as {
+      sendMessage?: (
+        message: { customType: string; content: string; display?: boolean; details?: Record<string, unknown> },
+        opts?: { deliverAs?: string; triggerTurn?: boolean },
+      ) => Promise<void>;
+    };
+    let todoReminders = 0;
+    let lastAssistantStopReason: string | null = null;
+    let todoReminderTimer: NodeJS.Timeout | null = null;
+    function cancelTodoReminder(): void {
+      if (todoReminderTimer !== null) {
+        clearTimeout(todoReminderTimer);
+        todoReminderTimer = null;
+      }
+    }
+    scoped.on('turn_end', async (event: unknown) => {
+      if (event === null || typeof event !== 'object' || !('message' in event)) return;
+      const msg = (event as { message: unknown }).message;
+      if (msg === null || typeof msg !== 'object') return;
+      const { role, stopReason } = msg as { role?: unknown; stopReason?: unknown };
+      if (role === 'assistant' && typeof stopReason === 'string') {
+        lastAssistantStopReason = stopReason;
+      }
+    });
+    scoped.on('agent_start', () => cancelTodoReminder());
+    scoped.on('session_shutdown', () => cancelTodoReminder());
+    scoped.on('agent_settled', async () => {
+      cancelTodoReminder();
+      const plan = planStopTodoReminder({
+        lastStopReason: lastAssistantStopReason,
+        reminders: todoReminders,
+        runningSubs: stopReminder.getRunningSubs(),
+        blockedDepth: stopReminder.getBlockedDepth(),
+        items: todos.items,
+      });
+      if (!plan.due || plan.content == null) return;
+      const content = plan.content;
+      todoReminderTimer = setTimeout(() => {
+        todoReminderTimer = null;
+        void (async () => {
+          const send = pi.sendMessage;
+          if (typeof send !== 'function') return;
+          try {
+            await send(
+              { customType: TODO_REMINDER_CUSTOM_TYPE, content, display: true },
+              { deliverAs: 'followUp', triggerTurn: true },
+            );
+            todoReminders += 1;
+          } catch {
+            /* Delivery failure is non-fatal. */
+          }
+        })();
+      }, todoReminderGraceMs());
+      todoReminderTimer.unref?.();
+    });
+  }
+
   /* ── todo_write tool ───────────────────────────────────────────── */
   scoped.registerTool({
     name: TODO_TOOL_NAME,

package/src/index-master.ts

@@ -86,9 +86,14 @@ export async function mountMasterPlugins(m: MasterPluginMount): Promise<void> {
     maxItems: 15,
     mirrorTodos: m.mirrorTodos,
     appendEntry: (customType: string, data: unknown) => {
-      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, data);
+      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, d);
     },
     state: m.todoUi,
+    getBlockedDepth: m.getBlockedDepth,
+    stopReminder: {
+      getBlockedDepth: m.getBlockedDepth,
+      getRunningSubs: () => m.port.current?.listRunningSubs().length ?? 0,
+    },
   });
   await loadEntry(sessionRoot, useLoader, './core/todo.ts', todoPlugin);
 
@@ -101,12 +106,10 @@ export async function mountMasterPlugins(m: MasterPluginMount): Promise<void> {
     deliverNotice: m.deliverNotice,
     noticePending: m.noticePending,
     getSessionId: m.getSessionId,
-    getBlockedDepth: m.getBlockedDepth,
     reconcileOnSettlement: m.reconcileOnSettlement,
     withReconcileNotes: m.withReconcileNotes,
     claimSettleNotice: m.claimSettleNotice,
     terminalState: terminalDeps.state,
-    todos: m.todos,
   });
   await loadEntry(sessionRoot, useLoader, './core/subagent.ts', subagentPlugin);
 

package/src/index-runtime.ts

@@ -10,14 +10,18 @@ import { detectHerdrEnv } from './herdr-client.ts';
 export interface IndexMode {
   /** PI_HERDR_SUBAGENT=1 → worker pane (no subagent tools, no cordis loader). */
   readonly isSubagent: boolean;
-  /** herdr pane that is not a worker → apply builtin master manifest. */
+  /** HERDR_ENV + socket + pane are present. */
+  readonly hasHerdr: boolean;
+  /** herdr pane that is not a worker → apply builtin master manifest and mount workbench plugins. */
   readonly composeMaster: boolean;
 }
 
 export function planIndexMode(env: NodeJS.ProcessEnv = process.env): IndexMode {
   const isSubagent = env.PI_HERDR_SUBAGENT === '1';
+  const hasHerdr = Boolean(detectHerdrEnv(env));
   return {
     isSubagent,
-    composeMaster: Boolean(detectHerdrEnv(env)) && !isSubagent,
+    hasHerdr,
+    composeMaster: hasHerdr && !isSubagent,
   };
 }

package/src/index-worker.ts

@@ -1,8 +1,8 @@
 /**
- * Worker-process todo plugin mount (bare cordis root, no loader/hmr).
+ * Todo-only plugin mount (bare cordis root, no loader/hmr).
  *
- * Why: short-lived worker panes only need the todo coordination plugin.
- * Dynamically imported from the worker branch so bootstrap/loader stay out.
+ * Used by worker panes and by standalone pi outside herdr, so bootstrap/subagent/terminal
+ * stay out of those processes.
  */
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Context } from '@deepseek-ai/cordis';
@@ -11,14 +11,21 @@ import todoPlugin from './core/todo.ts';
 import type { TodosService } from './todos-service.ts';
 import type { TodoUiSlot } from './core/todo.ts';
 
-export interface WorkerPluginMount {
+export interface TodoOnlyMount {
   pi: ExtensionAPI;
   todos: TodosService;
   todoUi: TodoUiSlot;
   mirrorTodos: () => void;
+  /** Human-gate depth source; collapses the todo widget to one line while a gate is open. */
+  getBlockedDepth?: () => number;
+  /** Master-only stop reminder; omit on worker panes. */
+  stopReminder?: {
+    getBlockedDepth: () => number;
+    getRunningSubs: () => number;
+  };
 }
 
-export async function mountWorkerTodo(m: WorkerPluginMount): Promise<void> {
+export async function mountTodoOnly(m: TodoOnlyMount): Promise<void> {
   const workerRoot = new Context();
   const workerSurface = new PiSurface(m.pi as unknown as object);
   workerRoot.provide('pi-herdr.surface', workerSurface);
@@ -28,9 +35,11 @@ export async function mountWorkerTodo(m: WorkerPluginMount): Promise<void> {
     maxItems: 15,
     mirrorTodos: m.mirrorTodos,
     appendEntry: (customType: string, data: unknown) => {
-      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, data);
+      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, d);
     },
     state: m.todoUi,
+    ...(m.getBlockedDepth ? { getBlockedDepth: m.getBlockedDepth } : {}),
+    ...(m.stopReminder ? { stopReminder: m.stopReminder } : {}),
   });
   await workerRoot.plugin(todoPlugin);
   m.pi.on('session_shutdown', () => {