pi-pier 0.1.5 → 0.2.0

package/src/index-master.ts

@@ -0,0 +1,113 @@
+/**
+ * Master-process plugin mount (cordis loader + terminal/todo/subagent).
+ *
+ * Why: worker must never load bootstrap/subagent-scope (C3). This module is
+ * dynamically imported only from the master branch of index.ts.
+ */
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import type { Context } from '@deepseek-ai/cordis';
+import type { Server } from 'node:net';
+import { PiSurface } from './pi-surface.ts';
+import { createCordisApp } from './bootstrap.ts';
+import { disposeSessionRoot } from './subagent-scope.ts';
+import terminalPlugin from './core/terminal.ts';
+import todoPlugin from './core/todo.ts';
+import subagentPlugin from './core/subagent.ts';
+import type { HerdrClientLike, HerdrEnv } from './herdr-client.ts';
+import type { TodosService } from './todos-service.ts';
+import type { TodoUiSlot } from './core/todo.ts';
+import type { SubagentPortBox } from './subagent-port.ts';
+
+export interface MasterPluginMount {
+  pi: ExtensionAPI;
+  client: HerdrClientLike;
+  env: HerdrEnv | null;
+  todos: TodosService;
+  todoUi: TodoUiSlot;
+  mirrorTodos: () => void;
+  extPath: string;
+  port: SubagentPortBox;
+  pipeServerBox: { current: Server | null };
+  deliverNotice: (content: string, paneId?: string) => Promise<void>;
+  noticePending: () => ReadonlySet<string>;
+  getSessionId: () => string;
+  getBlockedDepth: () => number;
+  reconcileOnSettlement: (description: string, outcome: 'settled' | 'failed') => string[];
+  withReconcileNotes: (base: string, notes: readonly string[]) => string;
+  claimSettleNotice: (key: string) => boolean;
+}
+
+async function loadEntry(
+  sessionRoot: Context,
+  loaderReady: boolean,
+  name: string,
+  plugin: (ctx: Context) => void,
+): Promise<void> {
+  if (loaderReady) {
+    const withLoader = sessionRoot as typeof sessionRoot & {
+      loader?: { create: (o: { name: string }) => Promise<unknown> };
+    };
+    await withLoader.loader?.create({ name });
+    return;
+  }
+  await sessionRoot.plugin(plugin);
+}
+
+export async function mountMasterPlugins(m: MasterPluginMount): Promise<void> {
+  const cordisApp = await createCordisApp();
+  const sessionRoot = cordisApp.root;
+
+  // Pipe server is created in the common segment; closing it from a core
+  // plugin would kill it on hmr reload (d87).
+  sessionRoot.effect(() => () => {
+    if (m.pipeServerBox.current) {
+      try { m.pipeServerBox.current.close(); } catch { /* already closed */ }
+      m.pipeServerBox.current = null;
+    }
+  }, 'pipe-server');
+
+  const surface = new PiSurface(m.pi as unknown as object, cordisApp.ledger);
+  sessionRoot.provide('pi-herdr.surface', surface);
+  const terminalDeps = {
+    client: m.client,
+    env: m.env,
+    state: { activePaneIds: (): Set<string> => new Set() },
+  };
+  sessionRoot.provide('pi-herdr.terminal-deps', terminalDeps);
+
+  await loadEntry(sessionRoot, cordisApp.loaderReady, './core/terminal.ts', terminalPlugin);
+
+  sessionRoot.provide('pi-herdr.todo-deps', {
+    todos: m.todos,
+    allowParallelInProgress: m.todos.config.allowParallelInProgress,
+    maxItems: 15,
+    mirrorTodos: m.mirrorTodos,
+    appendEntry: (customType: string, data: unknown) => {
+      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, data);
+    },
+    state: m.todoUi,
+  });
+  await loadEntry(sessionRoot, cordisApp.loaderReady, './core/todo.ts', todoPlugin);
+
+  sessionRoot.provide('pi-herdr.subagent-deps', {
+    client: m.client,
+    env: m.env,
+    extPath: m.extPath,
+    sessionRoot,
+    port: m.port,
+    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, cordisApp.loaderReady, './core/subagent.ts', subagentPlugin);
+
+  m.pi.on('session_shutdown', () => {
+    void disposeSessionRoot(sessionRoot);
+  });
+}

package/src/index-notices.ts

@@ -0,0 +1,43 @@
+/**
+ * D92 settlement-notice buffer (busy-run collapse).
+ *
+ * Why: `sendUserMessage(followUp)` only delivers when the agent has no more
+ * tool calls — a long master run queues every settlement and floods at the
+ * end. Buffer while busy; flush at turn_end (steer) / agent_settled (followUp).
+ */
+import { collapseNotices } from './notice-buffer.ts';
+
+export type NoticeSendMode = 'steer' | 'followUp';
+
+export interface NoticeBuffer {
+  deliverNotice(content: string, paneId?: string): Promise<void>;
+  noticePending(): ReadonlySet<string>;
+  flush(mode: NoticeSendMode): Promise<void>;
+}
+
+export function createNoticeBuffer(opts: {
+  /** True while the agent is in a turn, or after an abort that must not wake a new run. */
+  isBusy: () => boolean;
+  send: (content: string, mode: NoticeSendMode) => Promise<void>;
+}): NoticeBuffer {
+  const pending: string[] = [];
+  const pendingPaneIds = new Set<string>();
+  return {
+    async deliverNotice(content, paneId) {
+      if (content !== '' && paneId !== undefined) pendingPaneIds.add(paneId);
+      if (opts.isBusy()) {
+        pending.push(content);
+        return;
+      }
+      await opts.send(content, 'followUp');
+      if (content !== '' && paneId !== undefined) pendingPaneIds.delete(paneId);
+    },
+    noticePending: () => pendingPaneIds,
+    async flush(mode) {
+      if (pending.length === 0) return;
+      const collapsed = collapseNotices(pending.splice(0));
+      pendingPaneIds.clear();
+      if (collapsed) await opts.send(collapsed, mode);
+    },
+  };
+}

package/src/index-pipe.ts

@@ -0,0 +1,73 @@
+/**
+ * Common-segment pipe request handler (prompt / interrupt / reply).
+ *
+ * Why: index.ts owned the NDJSON switch next to session lifecycle. The
+ * dispatch is a pure-ish adapter over the subagent port and notice buffer.
+ */
+import { formatSettlementNotice } from './vocab.ts';
+import type { PipeRequest, PipeResponse } from './pipe-channel.ts';
+import type { SubagentPortBox } from './subagent-port.ts';
+
+export interface MachineRequest {
+  id: string;
+  from: string | null;
+  push: boolean;
+  sinceTs: number;
+}
+
+export interface PipeHandlerSession {
+  paneId: string;
+  port: SubagentPortBox;
+  claimSettleNotice: (key: string) => boolean;
+  deliverNotice: (content: string, paneId?: string) => Promise<void>;
+  sendUserMessageIn: (content: string) => Promise<void>;
+  sendUserMessageAs: (content: string, mode: 'steer' | 'followUp') => Promise<void>;
+  abort: () => void;
+  setPendingMachineRequest: (req: MachineRequest | null) => void;
+}
+
+export async function handlePipeRequest(
+  req: PipeRequest,
+  s: PipeHandlerSession,
+): Promise<PipeResponse> {
+  switch (req.type) {
+    case 'ping':
+      return { type: 'ok', id: req.id, detail: s.paneId };
+    case 'prompt':
+    case 'follow_up': {
+      s.setPendingMachineRequest({
+        id: req.id,
+        from: req.from ?? null,
+        push: req.push === true,
+        sinceTs: Date.now(),
+      });
+      // follow_up + steer → deliver between tool calls (B3). Initial prompt
+      // stays followUp so an idle worker starts a new run (D96).
+      if (req.steer === true) await s.sendUserMessageAs(req.text, 'steer');
+      else await s.sendUserMessageIn(req.text);
+      return { type: 'ok', id: req.id };
+    }
+    case 'interrupt':
+      s.abort();
+      s.setPendingMachineRequest(null);
+      return { type: 'ok', id: req.id };
+    case 'reply': {
+      s.port.current?.applyReplySession(req.paneId, req.sessionFile);
+      if (s.claimSettleNotice(`${req.paneId}:${req.id}`)) {
+        const notes = s.port.current?.reconcileOnReply(req.paneId) ?? [];
+        const statLine = await s.port.current?.settleStatLine(req.paneId) ?? null;
+        const head = formatSettlementNotice(`${req.paneId}`, req.text);
+        const body = (req.sessionFile ? `${head}\nSession: ${req.sessionFile}` : head)
+          + (statLine ? `\n${statLine}` : '')
+          + (notes.length ? `\n${notes.join('\n')}` : '');
+        await s.deliverNotice(body, req.paneId);
+      }
+      return { type: 'ok', id: req.id };
+    }
+    default: {
+      // PipeRequest is closed; parsePipeLine may still forward an unknown type.
+      const unknownReq: { type: string; id: string } = req;
+      return { type: 'error', id: unknownReq.id, message: `unknown type ${unknownReq.type}` };
+    }
+  }
+}

package/src/index-runtime.ts

@@ -0,0 +1,23 @@
+/**
+ * Index process-mode planner (master vs worker, master-manifest gate).
+ *
+ * Why: index.ts mixed env branching with cordis/plugin mounting. The mode
+ * decision is a pure function of process env and must stay testable without
+ * booting the composition root.
+ */
+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. */
+  readonly composeMaster: boolean;
+}
+
+export function planIndexMode(env: NodeJS.ProcessEnv = process.env): IndexMode {
+  const isSubagent = env.PI_HERDR_SUBAGENT === '1';
+  return {
+    isSubagent,
+    composeMaster: Boolean(detectHerdrEnv(env)) && !isSubagent,
+  };
+}

package/src/index-worker.ts

@@ -0,0 +1,39 @@
+/**
+ * Worker-process todo 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.
+ */
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Context } from '@deepseek-ai/cordis';
+import { PiSurface } from './pi-surface.ts';
+import todoPlugin from './core/todo.ts';
+import type { TodosService } from './todos-service.ts';
+import type { TodoUiSlot } from './core/todo.ts';
+
+export interface WorkerPluginMount {
+  pi: ExtensionAPI;
+  todos: TodosService;
+  todoUi: TodoUiSlot;
+  mirrorTodos: () => void;
+}
+
+export async function mountWorkerTodo(m: WorkerPluginMount): Promise<void> {
+  const workerRoot = new Context();
+  const workerSurface = new PiSurface(m.pi as unknown as object);
+  workerRoot.provide('pi-herdr.surface', workerSurface);
+  workerRoot.provide('pi-herdr.todo-deps', {
+    todos: m.todos,
+    allowParallelInProgress: m.todos.config.allowParallelInProgress,
+    maxItems: 15,
+    mirrorTodos: m.mirrorTodos,
+    appendEntry: (customType: string, data: unknown) => {
+      (m.pi as { appendEntry?: (t: string, d: unknown) => void }).appendEntry?.(customType, data);
+    },
+    state: m.todoUi,
+  });
+  await workerRoot.plugin(todoPlugin);
+  m.pi.on('session_shutdown', () => {
+    void workerRoot.fiber.dispose();
+  });
+}