pi-pier 0.1.5 → 0.2.0

package/src/subagent-gc.ts

@@ -0,0 +1,237 @@
+/**
+ * Tab/pane collection and isolate-worktree sweep.
+ *
+ * Why: GC mixed herdr close I/O with the plugin body. Predicates stay in
+ * gc-core.ts; this adapter owns list/close, isolate git, and the ticker.
+ */
+import { appendFileSync, existsSync, rmSync } from 'node:fs';
+import type { Context } from '@deepseek-ai/cordis';
+import type { HerdrClientLike } from './herdr-client.ts';
+import { shouldClosePane, shouldCloseTaskTab } from './gc-core.ts';
+import { runtimePolicy } from './runtime-policy.ts';
+import { evaluateRelease, parseWorktreePorcelain, type SubEntry } from './subagent-core.ts';
+import type { GitIo } from './subagent-git-io.ts';
+import type { TerminalStateSlot } from './core/terminal.ts';
+
+function sleep(ms: number): Promise<void> {
+  const wait = Promise.withResolvers<void>();
+  setTimeout(wait.resolve, ms);
+  return wait.promise;
+}
+
+export interface GcHost {
+  client: HerdrClientLike;
+  env: { tabId: string } | null;
+  subs: Map<string, SubEntry>;
+  persistSubs(): void;
+  writeHistory(e: SubEntry, patch?: { outcome?: string | null; status?: SubEntry['status']; closedAt?: number }, via?: string): void;
+  terminalState: TerminalStateSlot;
+  noticePending?: () => ReadonlySet<string>;
+  pendingIsolateBranches: Set<string>;
+  git: GitIo;
+  injectNotice(content: string): Promise<void>;
+}
+
+export interface GcController {
+  runGcSafely(): Promise<void>;
+  onTurnStart(): Promise<void>;
+  startTicker(ctx: Context): void;
+}
+
+export function createGcController(h: GcHost): GcController {
+  let prevTurnStart = Date.now();
+  let gcRunning = false;
+
+  async function gcPass(): Promise<void> {
+    if (h.subs.size === 0) return;
+    const ttlMs = runtimePolicy.sessionTtlSeconds * 1000;
+    const autoCloseTabs = ttlMs > 0;
+    let panesList: Array<{ paneId: string; tabId: string; agentStatus: string }>;
+    try {
+      panesList = await h.client.listPanes();
+    } catch {
+      return;
+    }
+    const statuses = new Map(panesList.map((p) => [p.paneId, p.agentStatus]));
+    const termPaneIds = h.terminalState.activePaneIds();
+    const pendingNoticeIds = h.noticePending?.() ?? new Set<string>();
+
+    const byTab = new Map<string, SubEntry[]>();
+    for (const e of h.subs.values()) {
+      if (!e.tabId) continue;
+      const arr = byTab.get(e.tabId) ?? [];
+      arr.push(e);
+      byTab.set(e.tabId, arr);
+    }
+    const taskTabIds = new Set(byTab.keys());
+    const mainTabId = h.env?.tabId ?? '';
+
+    for (const [tabId, entries] of byTab) {
+      if (tabId === mainTabId) continue;
+      const tabPanes = panesList.filter((p) => p.tabId === tabId);
+      if (tabPanes.length === 0) {
+        for (const e of entries) {
+          if (e.status !== 'closed') {
+            e.status = 'closed';
+            h.writeHistory(e, { status: 'closed', closedAt: Date.now() }, 'gc');
+          }
+        }
+        continue;
+      }
+      const should = shouldCloseTaskTab({
+        entries,
+        paneStatuses: tabPanes.map((p) => p.agentStatus),
+        ttlMs,
+        now: Date.now(),
+      });
+      if (!autoCloseTabs || !should) continue;
+      if (tabPanes.some((p) => termPaneIds.has(p.paneId) || pendingNoticeIds.has(p.paneId))) continue;
+      try {
+        await h.client.tabClose(tabId);
+      } catch {
+        /* tab may already be gone */
+      }
+      for (const e of entries) {
+        if (e.status !== 'closed') {
+          e.status = 'closed';
+          h.writeHistory(e, { status: 'closed', closedAt: Date.now() }, 'gc');
+        }
+      }
+      await sleep(300);
+    }
+
+    const closableTaskTabIds = new Set([...taskTabIds].filter((t) => t !== mainTabId));
+    const candidates = [...h.subs.values()].filter(
+      (e) => e.status === 'consumed' && !(e.tabId && closableTaskTabIds.has(e.tabId)),
+    );
+    for (const e of candidates) {
+      if (termPaneIds.has(e.paneId) || pendingNoticeIds.has(e.paneId)) continue;
+      if (!shouldClosePane({
+        consumedAt: e.consumedAt ?? null,
+        herdrStatus: statuses.get(e.paneId),
+        prevTurnStart,
+      })) continue;
+      if (statuses.get(e.paneId) === undefined) {
+        e.status = 'closed';
+        h.writeHistory(e, { status: 'closed', closedAt: Date.now() }, 'gc');
+        continue;
+      }
+      try {
+        await h.client.closePane(e.paneId);
+      } catch {
+        /* pane may already be gone */
+      }
+      e.status = 'closed';
+      h.writeHistory(e, { status: 'closed', closedAt: Date.now() }, 'gc');
+      await sleep(300);
+    }
+    h.persistSubs();
+  }
+
+  async function isolateSweep(): Promise<void> {
+    const trace = process.env.PI_HERDR_TRACE
+      ? (msg: string) => { try { appendFileSync(process.env.PI_HERDR_TRACE!, `d98sweep ${Date.now()} ${msg}\n`); } catch { /* best-effort */ } }
+      : null;
+    const masterCwd = process.cwd();
+    const registeredBranches = new Set<string>();
+    for (const e of h.subs.values()) {
+      if (e.isolate) registeredBranches.add(e.isolate.branch);
+    }
+    const wtPorcelain = await h.git.runGit(masterCwd, ['worktree', 'list', '--porcelain']);
+    if (wtPorcelain === null) return;
+    const wtByBranch = parseWorktreePorcelain(wtPorcelain);
+    const pierBranchOut = await h.git.runGit(masterCwd, ['for-each-ref', '--format=%(refname:short)', 'refs/heads/pier/']);
+    const pierBranches = (pierBranchOut ?? '').split('\n').map((l) => l.trim()).filter(Boolean);
+    type Cand = { branch: string; wtPath: string; entry: SubEntry | null };
+    const byBranch = new Map<string, Cand>();
+    for (const branch of pierBranches) {
+      if (registeredBranches.has(branch) || h.pendingIsolateBranches.has(branch)) continue;
+      const wtPath = wtByBranch.get(branch);
+      if (wtPath) byBranch.set(branch, { branch, wtPath, entry: null });
+    }
+    for (const e of h.subs.values()) {
+      if (!e.isolate || e.isolate.releasedAt != null || e.status === 'running') continue;
+      const prev = byBranch.get(e.isolate.branch);
+      byBranch.set(e.isolate.branch, { branch: e.isolate.branch, wtPath: prev?.wtPath ?? e.isolate.worktreePath, entry: e });
+    }
+    trace?.(`cands=${[...byBranch.keys()].join(',') || 'none'} subs=${[...h.subs.values()].map((s) => `${s.status}${s.isolate ? '/iso' : ''}`).join(',') || 'none'}`);
+    let persisted = false;
+    for (const cand of byBranch.values()) {
+      const { branch, wtPath, entry } = cand;
+      if (entry && !wtByBranch.has(branch)) {
+        if (existsSync(wtPath)) {
+          try { rmSync(wtPath, { recursive: true, force: true }); } catch { continue; }
+          if (existsSync(wtPath)) continue;
+        }
+        entry.isolate!.releasedAt = Date.now();
+        persisted = true;
+        continue;
+      }
+      const mergedOut = await h.git.runGit(masterCwd, ['merge-base', '--is-ancestor', branch, 'HEAD']);
+      const merged = mergedOut !== null ? true : null;
+      let mergedFinal = merged;
+      if (merged === null) {
+        const sha = await h.git.runGit(masterCwd, ['rev-parse', branch]);
+        const headSha = await h.git.runGit(masterCwd, ['rev-parse', 'HEAD']);
+        if (sha != null && headSha != null) mergedFinal = false;
+      }
+      const dirtyOut = await h.git.runGit(wtPath, ['status', '--porcelain']);
+      const dirtyCount = dirtyOut === null ? null : dirtyOut.split('\n').filter((l) => l.trim() !== '').length;
+      const decision = evaluateRelease({ merged: mergedFinal, dirtyCount });
+      if (decision.action === 'release') {
+        const removed = await h.git.runGit(masterCwd, ['worktree', 'remove', wtPath]);
+        let ok = removed !== null;
+        if (!ok) {
+          await sleep(2000);
+          ok = (await h.git.runGit(masterCwd, ['worktree', 'remove', wtPath])) !== null;
+        }
+        if (ok) {
+          h.git.invalidateWorktreesCache();
+          if (entry) { entry.isolate!.releasedAt = Date.now(); persisted = true; }
+        }
+      } else if (entry && !entry.isolate!.retainNotified) {
+        entry.isolate!.retainNotified = true;
+        persisted = true;
+        try {
+          await h.injectNotice(`worktree ${branch} retained (${decision.reason}) — merge it (git merge --no-ff ${branch}) or remove manually (git worktree remove --force ${wtPath})`);
+        } catch {
+          /* retainNotified prevents repeated alerts */
+        }
+      }
+    }
+    if (persisted) h.persistSubs();
+  }
+
+  async function runGcSafely(): Promise<void> {
+    if (gcRunning) return;
+    gcRunning = true;
+    try {
+      await gcPass();
+    } catch {
+      /* next turn/tick retries */
+    }
+    try {
+      await isolateSweep();
+    } catch {
+      /* next turn/tick retries */
+    } finally {
+      gcRunning = false;
+    }
+  }
+
+  return {
+    runGcSafely,
+    async onTurnStart(): Promise<void> {
+      const now = Date.now();
+      await runGcSafely();
+      prevTurnStart = now;
+    },
+    startTicker(ctx: Context): void {
+      const gcTickMs = runtimePolicy.gcTickMs;
+      const gcTicker = gcTickMs > 0 ? setInterval(() => { void runGcSafely(); }, gcTickMs) : null;
+      ctx.effect(() => () => {
+        clearInterval(gcTicker ?? undefined);
+      }, 'gc-ticker');
+    },
+  };
+}

package/src/subagent-git-io.ts

@@ -0,0 +1,80 @@
+/**
+ * Git/worktree I/O used by spawn, isolate, GC, and settlement stat lines.
+ *
+ * Why: core/subagent mixed adapter calls with tool registration. Centralizing
+ * git behind one cache/timeout policy keeps placement and isolate GC consistent.
+ */
+import { defaultGitAdapter, type GitAdapter } from './git-adapter.ts';
+import { formatWorktreeStat, type SubEntry } from './subagent-core.ts';
+
+const WORKTREES_CACHE_MS = 5000;
+export interface GitIo {
+  listWorktrees(cwd: string): Promise<string[]>;
+  runGit(cwd: string, args: string[]): Promise<string | null>;
+  worktreeStatLine(entry: SubEntry): Promise<string | null>;
+  invalidateWorktreesCache(): void;
+}
+
+export function createGitIo(git: GitAdapter = defaultGitAdapter): GitIo {
+  let worktreesCache: { at: number; list: string[] } | null = null;
+  async function listWorktrees(cwd: string): Promise<string[]> {
+    if (worktreesCache && Date.now() - worktreesCache.at < WORKTREES_CACHE_MS) return worktreesCache.list;
+    let list: string[] = [];
+    try {
+      const { stdout } = await git.listWorktrees(cwd);
+      for (const line of String(stdout).split('\n')) {
+        const m = /^worktree (.+)$/.exec(line.trim());
+        if (m) list.push(m[1]);
+      }
+    } catch {
+      list = [];
+    }
+    worktreesCache = { at: Date.now(), list };
+    return list;
+  }
+
+  async function runGit(cwd: string, args: string[]): Promise<string | null> {
+    try {
+      const { stdout } = await git.run(cwd, args);
+      return stdout == null ? null : String(stdout);
+    } catch {
+      return null;
+    }
+  }
+
+  function lastStatLine(out: string | null): string | null {
+    if (!out) return null;
+    const lines = out.replace(/\r/g, '').split('\n').map((l) => l.trim()).filter(Boolean);
+    return lines.length ? lines[lines.length - 1]! : null;
+  }
+
+  async function worktreeStatLine(entry: SubEntry): Promise<string | null> {
+    const porcelain = await runGit(entry.cwd, ['status', '--porcelain']);
+    if (porcelain === null) return null;
+    const dirtyCount = porcelain.split('\n').filter((l) => l.trim() !== '').length;
+    if (entry.isolate) {
+      const statOut = await runGit(entry.cwd, ['diff', '--stat', `${entry.isolate.baseSha}...HEAD`]);
+      const commitsOut = await runGit(entry.cwd, ['rev-list', '--count', `${entry.isolate.baseSha}..HEAD`]);
+      const commits = commitsOut != null && /^\d+$/.test(commitsOut.trim()) ? Number(commitsOut.trim()) : null;
+      return formatWorktreeStat({ branch: entry.isolate.branch, commits, statLine: lastStatLine(statOut), dirtyCount });
+    }
+    return formatWorktreeStat({
+      branch: null,
+      commits: null,
+      statLine: lastStatLine(await runGit(entry.cwd, ['diff', '--stat', 'HEAD'])),
+      dirtyCount,
+    });
+  }
+
+  function invalidateWorktreesCache(): void {
+    worktreesCache = null;
+  }
+
+  return {
+    listWorktrees,
+    runGit,
+    worktreeStatLine,
+    invalidateWorktreesCache,
+  };
+}
+

package/src/subagent-launch.ts

@@ -0,0 +1,110 @@
+/**
+ * Subagent `execute` planners (validation + foreground wait).
+ *
+ * Why: execute mixed param checks, isolate git I/O, spawn, and wait-loop
+ * decisions. The decisions are pure and must stay testable without a pane.
+ */
+import { normalizeEntryKind } from './history-store.ts';
+
+export const FOREGROUND_POLL_MS = 2_000;
+
+export type LaunchParams = {
+  description?: unknown;
+  prompt?: unknown;
+  run_in_background?: unknown;
+  cwd?: unknown;
+  isolate?: unknown;
+  role?: unknown;
+  allowed_tools?: unknown;
+  tab?: unknown;
+};
+
+export type LaunchValidation =
+  | { kind: 'error'; text: string }
+  | {
+      kind: 'ok';
+      spec: SubagentSpec;
+      background: boolean;
+      isolate: boolean;
+      cwdParam: string | null;
+      roleKind: string;
+      suggested: string[];
+      tab: string | null;
+    };
+
+export function planLaunchValidation(
+  params: LaunchParams | null | undefined,
+  herdrAvailable: boolean,
+): LaunchValidation {
+  if (!herdrAvailable) {
+    return {
+      kind: 'error',
+      text: 'Error: subagent requires pi to run inside a herdr-managed pane (HERDR_ENV not set).',
+    };
+  }
+  const spec: SubagentSpec = {
+    description: String(params?.description ?? 'subagent'),
+    prompt: String(params?.prompt ?? ''),
+  };
+  if (!spec.prompt.trim()) {
+    return { kind: 'error', text: 'Error: `prompt` must be a non-empty string' };
+  }
+  const cwdParam = typeof params?.cwd === 'string' && params.cwd.trim() ? params.cwd.trim() : null;
+  const isolate = params?.isolate === true;
+  if (isolate && cwdParam) {
+    return {
+      kind: 'error',
+      text: 'Error: `isolate` and `cwd` are mutually exclusive — isolate creates a new worktree, cwd delegates into an existing one',
+    };
+  }
+  const suggested = Array.isArray(params?.allowed_tools)
+    ? params.allowed_tools.filter((t): t is string => typeof t === 'string' && t.trim() !== '')
+    : [];
+  const manifestRole =
+    typeof params?.role === 'string' && params.role.trim() ? params.role.trim() : 'worker-default';
+  const tab = typeof params?.tab === 'string' ? params.tab : null;
+  return {
+    kind: 'ok',
+    spec,
+    background: params?.run_in_background === true,
+    isolate,
+    cwdParam,
+    roleKind: normalizeEntryKind(typeof params?.role === 'string' ? params.role.trim() : undefined),
+    suggested,
+    manifestRole,
+    tab,
+  };
+}
+
+export function planIsolateRepoGuard(baseSha: string | null): { kind: 'error'; text: string } | { kind: 'ok'; sha: string } {
+  if (!baseSha) {
+    return { kind: 'error', text: 'Error: isolate requires a git repository with at least one commit' };
+  }
+  return { kind: 'ok', sha: baseSha };
+}
+
+export type ForegroundTickPlan =
+  | { kind: 'blocked' }
+  | { kind: 'settled'; text: string }
+  | { kind: 'wait'; delayMs: number }
+  | { kind: 'collect-final' }
+  | { kind: 'continue' };
+
+export function planForegroundTick(input: {
+  state: string | null;
+  session: { text: string | null; pendingTool: boolean; activity: boolean };
+}): ForegroundTickPlan {
+  if (input.state === 'blocked') return { kind: 'blocked' };
+  if (input.state === 'idle' || input.state === 'done') {
+    if (input.session.text) return { kind: 'settled', text: input.session.text };
+    if (input.session.pendingTool || !input.session.activity) {
+      return { kind: 'wait', delayMs: FOREGROUND_POLL_MS };
+    }
+    return { kind: 'collect-final' };
+  }
+  return { kind: 'continue' };
+}
+
+export function planPatienceExpiry(alive: boolean): 'move-to-background' | 'timeout' {
+  return alive ? 'move-to-background' : 'timeout';
+}