pi-pier 0.3.1 → 0.4.1

package/src/tree-view.ts

@@ -0,0 +1,162 @@
+/**
+ * Unified TUI status surface (RFC docs/rfc-unified-widget.md, D113): the resident widget shows one
+ * line per agent — self plus every running subagent — each reduced to its CURRENT item and a
+ * done/total suffix; the full todo × subagent tree lives behind /pier-tree. Pure builders only.
+ */
+import { formatAge } from './stale-core.ts';
+import { formatTodoSummary, renderTodoGroups } from './todo-window.ts';
+import type { TodoItem } from './vocab.ts';
+
+/** Minimal todo shape carried over the pipe (todo_sync); status matches TodoStatus strings. */
+export interface TodoLikeItem {
+  content: string;
+  status: string;
+  blocker?: string;
+}
+
+/** What the master caches per worker: the pushed full list, or a summary fallback after a resume. */
+export interface WorkerTodoSnapshot {
+  items?: readonly TodoLikeItem[];
+  summary?: string;
+  ts?: number;
+}
+
+/** One running worker row as the widget/tree consumes it. */
+export interface WorkerWidgetRow {
+  paneId: string;
+  slug?: string;
+  description: string;
+  kind?: string;
+  todos?: WorkerTodoSnapshot | null;
+}
+
+/** A settled (delivered) worker row for the tree view only — never in the resident widget. */
+export interface SettledWidgetRow {
+  paneId: string;
+  slug?: string;
+  description: string;
+  settledAt?: number | null;
+}
+
+const CONTENT_CLIP = 60;
+
+function clip(text: string, max = CONTENT_CLIP): string {
+  const flat = text.replace(/\s+/g, ' ').trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}
+
+function countsOf(items: readonly TodoLikeItem[]): string {
+  const done = items.filter((it) => it.status === 'completed').length;
+  return `✓${done}/${items.length}`;
+}
+
+function currentOf(items: readonly TodoLikeItem[]): TodoLikeItem | undefined {
+  return items.find((it) => it.status === 'in_progress')
+    ?? items.find((it) => it.status === 'blocked')
+    ?? items.find((it) => it.status === 'pending');
+}
+
+/** `↳ <ref> ▶ <current> ✓d/n` — blocked names the waiting TASK (the actionable identity) with the
+ * blocker as a parenthetical reason; a cold cache falls back to the summary token. */
+export function workerLine(row: WorkerWidgetRow): string {
+  const ref = row.slug ?? `${row.paneId} · ${clip(row.description, 30)}`;
+  const items = row.todos?.items;
+  if (items && items.length > 0) {
+    const cur = currentOf(items);
+    const counts = countsOf(items);
+    if (!cur) return `↳ ${ref} ${counts}`;
+    if (cur.status === 'blocked') {
+      const why = cur.blocker && cur.blocker !== cur.content ? `（${clip(cur.blocker, 24)}）` : '';
+      return `↳ ${ref} ■ ${clip(cur.content, 40)}${why} ${counts}`;
+    }
+    return `↳ ${ref} ▶ ${clip(cur.content)} ${counts}`;
+  }
+  const summary = row.todos?.summary;
+  if (summary) return `↳ ${ref} · ${clip(summary, 50)}`;
+  return `↳ ${ref}`;
+}
+
+
+/** Self line: the current item with a done/total suffix — the anchored multi-line window is retired.
+ * A finished plan (no in_progress / blocked / pending item) has no actionable row, so it renders
+ * nothing at all: a bare `✓8/8` is noise that the human cannot act on. */
+export function selfLine(items: readonly TodoItem[]): string | null {
+  if (items.length === 0) return null;
+  const cur = currentOf(items);
+  if (!cur) return null;
+  const counts = countsOf(items);
+  if (cur.status === 'blocked') return `■ 等人: ${clip(cur.blocker || cur.content, 40)} ${counts}`;
+  return `▶ ${clip(cur.content)} ${counts}`;
+}
+
+/** pi caps the resident widget at ten lines; overflow workers fold into a count tail. */
+export const WIDGET_MAX_LINES = 10;
+
+export function unifiedWidgetLines(
+  items: readonly TodoItem[],
+  workers: readonly WorkerWidgetRow[],
+  opts?: { archivedAgeMs?: number | null; blockedDepth?: number | null },
+): string[] {
+  // Human gate open: the question owns the fixed area (unchanged discipline from the old widget).
+  if ((opts?.blockedDepth ?? 0) > 0) {
+    return workers.length === 0 || items.length === 0
+      ? [`${formatTodoSummary(items)} · /todos 全量`]
+      : [`${formatTodoSummary(items)} · ↳×${workers.length} · /todos 全量`];
+  }
+  if (items.length === 0 && workers.length === 0) return [];
+  // Archived plans keep their degraded two-line form; workers stay visible underneath.
+  const self = items.length > 0 ? selfLine(items) : null;
+  const head = opts?.archivedAgeMs != null && items.length > 0
+    ? [`${formatTodoSummary(items)} · archived ${formatAge(opts.archivedAgeMs)}`]
+    : self ? [self] : [];
+  if (head.length === 0 && workers.length === 0) return [];
+  const rows = workers.map(workerLine);
+  const budget = WIDGET_MAX_LINES - head.length - 1;
+  const shown = rows.slice(0, Math.max(budget, 0));
+  const hidden = rows.length - shown.length;
+  return [...head, ...shown, ...(hidden > 0 ? [`…另 ${hidden} 个子代理 · /pier-tree`] : [])];
+}
+
+/** Full delegation tree for /pier-tree: self todos in full + per-worker full lists + settled nodes. */
+export function formatDelegationTree(opts: {
+  selfItems: readonly TodoItem[];
+  workers: readonly WorkerWidgetRow[];
+  settled?: readonly SettledWidgetRow[];
+  now?: number;
+}): string[] {
+  const now = opts.now ?? Date.now();
+  const lines: string[] = ['==================== PIER DELEGATION TREE ===================='];
+  lines.push(`● master（本 pane）· ${opts.selfItems.length} 项`);
+  lines.push(...renderTodoGroups(opts.selfItems).map((l) => `  ${l}`));
+  if (opts.workers.length > 0 || (opts.settled?.length ?? 0) > 0) lines.push('  │');
+  for (const w of opts.workers) {
+    const ref = w.slug ?? w.paneId;
+    const items = w.todos?.items;
+    const headSuffix = items && items.length > 0
+      ? `· ${items.length} 项`
+      : w.todos?.summary ? `· ${clip(w.todos.summary, 40)}` : '· todo 未同步';
+    lines.push(`  ├─ ↳ ${ref} (${w.paneId} · running${w.kind && w.kind !== 'task' ? ` · ${w.kind}` : ''}) ${headSuffix}`);
+    if (items && items.length > 0) {
+      lines.push(...renderTodoGroups(toTodoItems(items)).map((l) => `  │    ${l}`));
+    }
+  }
+  for (const s of opts.settled ?? []) {
+    const ref = s.slug ?? s.paneId;
+    const age = s.settledAt ? ` · settled ${formatAge(Math.max(now - s.settledAt, 0))} ago` : ' · settled';
+    lines.push(`  └─ ✓ ${ref} (${s.paneId}${age}) — 结果已注入结算通知`);
+  }
+  lines.push('----------------------------------------------------------------');
+  lines.push('提示: /todos 编辑自己的清单 · subagent list 交互子代理 · /dashboard ops 面板');
+  return lines;
+}
+
+/** Narrow a pipe-pushed item list back to TodoItem for the shared group renderer. */
+function toTodoItems(items: readonly TodoLikeItem[]): TodoItem[] {
+  return items.map((it) => ({
+    content: it.content,
+    status: (['pending', 'in_progress', 'blocked', 'completed', 'abandoned'].includes(it.status)
+      ? it.status
+      : 'pending') as TodoItem['status'],
+    ...(it.blocker ? { blocker: it.blocker } : {}),
+  }));
+}

package/src/worker-marker.ts

@@ -0,0 +1,76 @@
+/**
+ * Worker identity marker: a herdr 0.9.2 server restart reopens a worker pane by running pier's
+ * self-reported resume_argv — WITHOUT the spawn env (`PI_HERDR_SUBAGENT`, role manifest env). The
+ * marker file lets the restored boot re-derive worker mode from the session itself, so it mounts
+ * todo-only instead of the master composition (no subagent pipe, no stop reminders) and replays its
+ * role from the transcript as usual. Masters never write a marker; a stale marker for a dead session
+ * is inert (it is only consulted when pi boots with that exact session file).
+ */
+import type { DelegationContext } from './delegation-core.ts';
+import { delegationFromRecord } from './delegation-core.ts';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { bareSessionId } from './session-tail.ts';
+import { isValidSessionId } from './efficiency-store.ts';
+
+export interface WorkerMarker {
+  readonly v: 1;
+  readonly ts: number;
+  readonly role?: string;
+  readonly delegation?: DelegationContext;
+}
+
+/** `<sessionDir>/herdr-pi/<sessionId>/worker.json` — same per-session root as the efficiency store. */
+export function workerMarkerPath(sessionFile: string | null | undefined): string | null {
+  if (!sessionFile || typeof sessionFile !== 'string') return null;
+  const id = bareSessionId(sessionFile);
+  if (!isValidSessionId(id)) return null;
+  return join(dirname(sessionFile), 'herdr-pi', id, 'worker.json');
+}
+
+export function readWorkerMarker(sessionFile: string | null | undefined): WorkerMarker | null {
+  const file = workerMarkerPath(sessionFile);
+  if (!file) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8')) as { v?: unknown; ts?: unknown; role?: unknown; delegation?: unknown };
+    if (parsed && parsed.v === 1 && typeof parsed.ts === 'number') {
+      const delegation = delegationFromRecord(parsed.delegation);
+      return {
+        v: 1,
+        ts: parsed.ts,
+        ...(typeof parsed.role === 'string' ? { role: parsed.role } : {}),
+        ...(delegation ? { delegation } : {}),
+      };
+    }
+  } catch {
+    /* missing or torn write: no marker → boot stays env-driven */
+  }
+  return null;
+}
+
+/** Idempotent; best-effort — a failed write only loses server-restart worker detection. */
+export function writeWorkerMarker(
+  sessionFile: string | null | undefined,
+  role?: string,
+  delegation?: DelegationContext,
+): void {
+  const file = workerMarkerPath(sessionFile);
+  if (!file) return;
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify({
+      v: 1,
+      ts: Date.now(),
+      ...(role ? { role } : {}),
+      ...(delegation ? { delegation } : {}),
+    })}\n`);
+  } catch {
+    /* read-only checkout or full disk: the live session is unaffected */
+  }
+}
+
+/** Boot-time probe over env.PI_SESSION_FILE; false negatives simply keep today's behavior. */
+export function hasWorkerMarker(sessionFile: string | null | undefined): boolean {
+  const file = workerMarkerPath(sessionFile);
+  return file !== null && existsSync(file);
+}

package/src/focus-poller.ts

@@ -1,223 +0,0 @@
-/**
- * D-4: herdr 0.9.1+ delivers `pane.focused`, so default polling is off (0 ms) there — a sampler
- * would reflow a second time ~8 s after a click; older servers keep the 1500 ms sampler.
- * `PIER_FOCUS_POLL_MS` overrides either default, 0 disables.
- */
-import { spawn } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/** Poll cadence for older Herdr (< 0.9.1). */
-export const FOCUS_POLL_DEFAULT_MS = 1500;
-/** Herdr 0.9.1+: native pane.focused is authoritative; default poller off to avoid a delayed second reflow. */
-export const FOCUS_POLL_HERDR_091_MS = 0;
-
-export function isHerdr091OrLater(version?: string | null): boolean {
-  if (!version) return false;
-  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
-  if (!m) return false;
-  const major = Number(m[1]);
-  const minor = Number(m[2]);
-  const patch = Number(m[3]);
-  if (major > 0) return true;
-  if (minor > 9) return true;
-  if (minor === 9 && patch >= 1) return true;
-  return false;
-}
-
-export function resolveDefaultFocusPollMs(herdrVersion?: string | null): number {
-  return isHerdr091OrLater(herdrVersion) ? FOCUS_POLL_HERDR_091_MS : FOCUS_POLL_DEFAULT_MS;
-}
-/** Min gap between reflow triggers: re-clicking the same pane must not spawn a process per click (the
- *  workbench debounces 150 ms per tab on top of this). */
-export const FOCUS_FIRE_MIN_INTERVAL_MS = 700;
-
-export interface FocusSample {
-  /** Pane focused in the sampled tab (null when the server reported no focus). */
-  readonly focusedPaneId: string | null;
-  /** Panes currently in that tab, used to tell a click apart from a spawn auto-focus. */
-  readonly paneIds: readonly string[];
-}
-
-export interface FocusPollerState {
-  readonly lastFocusedPaneId: string | null;
-  readonly lastPaneIds: readonly string[];
-  readonly lastFireAt: number;
-}
-
-/** Minimal flatten of a herdr layout tree (`{type:'pane',pane_id}` / `{type:'split',first,second}`). */
-export function collectPaneIds(root: unknown): string[] {
-  const out: string[] = [];
-  const walk = (node: unknown): void => {
-    if (node === null || typeof node !== 'object') return;
-    const n = node as { pane_id?: unknown; first?: unknown; second?: unknown };
-    if (typeof n.pane_id === 'string') {
-      out.push(n.pane_id);
-      return;
-    }
-    walk(n.first);
-    walk(n.second);
-  };
-  walk(root);
-  return out;
-}
-
-/** `layout.export` payload → sample. `focusedPaneId` is optional for older clients. */
-export function parseFocusSample(
-  layout: { root: unknown; focusedPaneId?: string | null } | null | undefined,
-): FocusSample | null {
-  if (!layout || !('root' in layout)) return null;
-  const paneIds = collectPaneIds(layout.root);
-  const focused = typeof layout.focusedPaneId === 'string' ? layout.focusedPaneId : null;
-  return { focusedPaneId: focused, paneIds };
-}
-
-export interface FocusTick {
-  readonly fire: boolean;
-  readonly cause: 'user' | null;
-  readonly state: FocusPollerState;
-}
-
-/**
- * Decide whether one sample should trigger a reflow: only on a *transition* into "I am focused",
- * and at most once per `minIntervalMs`. `cause` is 'user' when the pane set did not change in the
- * same sample (a click moves focus and nothing else, a spawn auto-focus comes with a new pane), so
- * the workbench can keep its pane-age whitelist. Baseline sample never fires.
- */
-export function planFocusTick(opts: {
-  myPaneId: string;
-  sample: FocusSample;
-  prev: FocusPollerState | null;
-  now: number;
-  minIntervalMs?: number;
-}): FocusTick {
-  const minInterval = opts.minIntervalMs ?? FOCUS_FIRE_MIN_INTERVAL_MS;
-  const prev = opts.prev;
-  const next: FocusPollerState = {
-    lastFocusedPaneId: opts.sample.focusedPaneId,
-    lastPaneIds: opts.sample.paneIds,
-    lastFireAt: prev?.lastFireAt ?? 0,
-  };
-  const noFire = (): FocusTick => ({ fire: false, cause: null, state: next });
-
-  if (opts.myPaneId === '') return noFire();
-  // First sample only records the baseline: a pi that starts in the focused pane must not reflow on
-  // startup (that is not a click, and it would fight whatever layout the user had).
-  if (prev === null) return noFire();
-  if (opts.sample.focusedPaneId !== opts.myPaneId) return noFire();
-  if (prev.lastFocusedPaneId === opts.myPaneId) return noFire();
-  if (opts.now - prev.lastFireAt < minInterval) return noFire();
-
-  const setUnchanged =
-    prev.lastPaneIds.length === opts.sample.paneIds.length &&
-    prev.lastPaneIds.every((id, i) => id === opts.sample.paneIds[i]);
-  return {
-    fire: true,
-    cause: setUnchanged ? 'user' : null,
-    state: { ...next, lastFireAt: opts.now },
-  };
-}
-
-export interface FocusPollerDeps {
-  /** Layout of the caller's own tab (the client already exposes `layout.export`). */
-  sample(): Promise<FocusSample | null>;
-  /** Replay a pane.focused reflow for `paneId`. Must never throw. */
-  fire(paneId: string, cause: 'user' | null): void;
-  myPaneId: string;
-  intervalMs?: number;
-  minIntervalMs?: number;
-  now?: () => number;
-  /** Diagnostics only: polling failures are expected while herdr restarts. */
-  onError?: (err: unknown) => void;
-}
-
-export interface FocusPoller {
-  /** One sampling pass (exposed for tests; the interval calls the same function). */
-  tick(): Promise<void>;
-  stop(): void;
-}
-
-export function startFocusPoller(deps: FocusPollerDeps): FocusPoller {
-  const intervalMs = deps.intervalMs ?? FOCUS_POLL_DEFAULT_MS;
-  const now = deps.now ?? Date.now;
-  let state: FocusPollerState | null = null;
-  let inFlight = false;
-  let stopped = false;
-  let handle: NodeJS.Timeout | null = null;
-
-  async function tick(): Promise<void> {
-    if (stopped || inFlight) return;
-    inFlight = true;
-    try {
-      const sample = await deps.sample();
-      if (sample === null) return;
-      const decision = planFocusTick({
-        myPaneId: deps.myPaneId,
-        sample,
-        prev: state,
-        now: now(),
-        minIntervalMs: deps.minIntervalMs,
-      });
-      state = decision.state;
-      if (decision.fire) deps.fire(deps.myPaneId, decision.cause);
-    } catch (err) {
-      // A failed sample must not advance the baseline: the next tick re-reads the layout.
-      deps.onError?.(err);
-    } finally {
-      inFlight = false;
-    }
-  }
-
-  if (intervalMs > 0) {
-    handle = setInterval(() => { void tick(); }, intervalMs);
-    handle.unref?.(); // never keep pi's event loop alive on our account
-  }
-
-  return {
-    tick,
-    stop(): void {
-      stopped = true;
-      if (handle !== null) {
-        clearInterval(handle);
-        handle = null;
-      }
-    },
-  };
-}
-
-/** The workbench's reflow entry point; overridable for relocated checkouts. */
-export function reflowScriptPath(env: NodeJS.ProcessEnv = process.env): string {
-  const root = env.PIER_WORKBENCH_ROOT?.trim();
-  if (root) return join(root, 'scripts', 'heat-reflow.mjs');
-  // packages/pier-ext/src/focus-poller.ts -> packages/pier-workbench/scripts/heat-reflow.mjs
-  return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'pier-workbench', 'scripts', 'heat-reflow.mjs');
-}
-
-export interface SpawnReflowOpts {
-  paneId: string;
-  cause: 'user' | null;
-  env?: NodeJS.ProcessEnv;
-  /** Injection seam for tests (defaults to child_process.spawn). */
-  spawnFn?: typeof spawn;
-}
-
-/** Fire-and-forget replay of the `pane.focused` hook as a child process — exactly how herdr runs it,
- *  so the workbench script keeps its own event parsing, debounce and state file. */
-export function spawnReflow(opts: SpawnReflowOpts): void {
-  const env = opts.env ?? process.env;
-  const spawnFn = opts.spawnFn ?? spawn;
-  const payload = JSON.stringify({
-    event: 'pane_focused',
-    type: 'pane_focused',
-    data: { type: 'pane_focused', pane_id: opts.paneId, cause: opts.cause },
-  });
-  try {
-    const child = spawnFn(process.execPath, [reflowScriptPath(env)], {
-      env: { ...env, HERDR_PLUGIN_EVENT: 'pane.focused', HERDR_PLUGIN_EVENT_JSON: payload },
-      stdio: 'ignore',
-    });
-    child.on?.('error', () => { /* Missing script / dead exec: polling must never break pi. */ });
-    child.unref?.();
-  } catch {
-  }
-}