pi-sessions 0.12.1 → 0.13.1

package/extensions/session-index/loader.ts

@@ -0,0 +1,80 @@
+import {
+  DynamicBorder,
+  type KeybindingsManager,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  Container,
+  Loader,
+  Spacer,
+  type TUI,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+} from "@earendil-works/pi-tui";
+import { type LegendHit, LegendPointer, layoutLegend, legendHitAt } from "../shared/legend.ts";
+
+export class ReindexLoader implements Component {
+  private readonly body = new Container();
+  private readonly loader: Loader;
+  private cancelRow = 0;
+  private cancelHits: LegendHit[] = [];
+  private readonly pointer: LegendPointer;
+
+  constructor(
+    tui: TUI,
+    private readonly theme: Theme,
+    private readonly keybindings: KeybindingsManager,
+    private readonly cancel: () => void,
+  ) {
+    this.pointer = new LegendPointer(() => tui.requestRender());
+    this.loader = new Loader(
+      tui,
+      (text) => theme.fg("accent", text),
+      (text) => theme.fg("muted", text),
+      "Rebuilding session index...",
+    );
+    this.body.addChild(new DynamicBorder((text) => theme.fg("border", text)));
+    this.body.addChild(this.loader);
+    this.body.addChild(new Spacer(1));
+  }
+
+  render(width: number): string[] {
+    this.cancelHits = [];
+    const lines = this.body.render(width);
+    const legend = layoutLegend(
+      this.theme,
+      [
+        {
+          key: this.keybindings.getKeys("tui.select.cancel").join("/"),
+          description: "cancel",
+          run: this.cancel,
+        },
+      ],
+      { width: Math.max(0, width - 2), pressedId: this.pointer.pressedId },
+    );
+    this.cancelRow = lines.length;
+    this.cancelHits = legend.hits;
+    lines.push(` ${legend.text}`, "", this.theme.fg("border", "─".repeat(Math.max(0, width))));
+    return lines;
+  }
+
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    return this.pointer.handleMouse(
+      event,
+      event.y === this.cancelRow ? legendHitAt(this.cancelHits, event.x - 1) : undefined,
+    );
+  }
+
+  handleInput(data: string): void {
+    if (this.keybindings.matches(data, "tui.select.cancel")) this.cancel();
+  }
+
+  invalidate(): void {
+    this.body.invalidate();
+  }
+
+  dispose(): void {
+    this.loader.stop();
+  }
+}

package/extensions/session-index/panel.ts

@@ -0,0 +1,103 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type Focusable,
+  matchesKey,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+import { type LegendHit, LegendPointer, layoutLegend, legendHitAt } from "../shared/legend.ts";
+import type { SessionIndexStatus } from "../shared/session-index/index.ts";
+
+export type SessionIndexAction = "reindex" | undefined;
+
+export class SessionIndexPanel implements Focusable {
+  focused = false;
+  private actionRows = new Map<number, LegendHit[]>();
+  private readonly pointer: LegendPointer;
+
+  constructor(
+    private readonly theme: Theme,
+    private readonly status: SessionIndexStatus,
+    private readonly done: (result: SessionIndexAction) => void,
+    requestRender: () => void,
+  ) {
+    this.pointer = new LegendPointer(requestRender);
+  }
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "enter")) {
+      this.done(undefined);
+    } else if (data === "r" || data === "R" || matchesKey(data, "r")) {
+      this.done("reindex");
+    }
+  }
+
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    const result = this.pointer.handleMouse(
+      event,
+      legendHitAt(this.actionRows.get(event.y) ?? [], event.x - 2),
+    );
+    return event.type === "press" && result?.handled ? { ...result, focus: true } : result;
+  }
+
+  render(width: number): string[] {
+    this.actionRows.clear();
+    const innerWidth = Math.max(0, Math.min(72, width) - 2);
+    const lines: string[] = [this.theme.fg("border", `╭${"─".repeat(innerWidth)}╮`)];
+    lines.push(
+      this.renderRow(innerWidth, ` ${this.theme.bold(this.theme.fg("accent", "Session Index"))}`),
+    );
+    lines.push(this.renderRow(innerWidth, ""));
+    lines.push(
+      this.renderRow(
+        innerWidth,
+        ` Path: ${this.status.exists ? this.status.dbPath : "<no index found>"}`,
+      ),
+    );
+    lines.push(
+      this.renderRow(
+        innerWidth,
+        ` Schema version: ${this.status.schemaVersion !== undefined ? String(this.status.schemaVersion) : "n/a"}`,
+      ),
+    );
+    lines.push(
+      this.renderRow(
+        innerWidth,
+        ` Session count: ${this.status.sessionCount !== undefined ? String(this.status.sessionCount) : "n/a"}`,
+      ),
+    );
+    lines.push(
+      this.renderRow(innerWidth, ` Last full reindex: ${this.status.lastFullReindexAt ?? "n/a"}`),
+    );
+    lines.push(this.renderRow(innerWidth, ""));
+    this.renderAction(lines, innerWidth, "R", "rebuild from disk", () => this.done("reindex"));
+    this.renderAction(lines, innerWidth, "Enter / Esc", "close", () => this.done(undefined));
+    lines.push(this.theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
+    return lines;
+  }
+
+  private renderAction(
+    lines: string[],
+    innerWidth: number,
+    key: string,
+    description: string,
+    run: () => void,
+  ): void {
+    const legend = layoutLegend(this.theme, [{ key, description, run }], {
+      width: Math.max(0, innerWidth - 1),
+      pressedId: this.pointer.pressedId,
+    });
+    this.actionRows.set(lines.length, legend.hits);
+    lines.push(this.renderRow(innerWidth, ` ${legend.text}`));
+  }
+
+  private renderRow(innerWidth: number, content: string): string {
+    const text = truncateToWidth(content, innerWidth, "…");
+    const pad = Math.max(0, innerWidth - visibleWidth(text));
+    return `${this.theme.fg("border", "│")}${text}${" ".repeat(pad)}${this.theme.fg("border", "│")}`;
+  }
+}

package/extensions/session-messaging/broker/spawn.ts

@@ -1,5 +1,13 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { type ChildProcess, spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import net from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -16,6 +24,7 @@ const brokerDir = getSessionMessagingDir();
 const brokerSocketPath = getSessionMessagingSocketPath();
 const brokerPidPath = join(brokerDir, "broker.pid");
 const brokerSpawnLockPath = join(brokerDir, "broker.spawn.lock");
+const brokerLogPath = join(brokerDir, "broker.log");
 
 export async function spawnSessionMessagingBrokerIfNeeded(): Promise<void> {
   mkdirSync(brokerDir, { recursive: true, mode: 0o700 });
@@ -43,14 +52,23 @@ export async function spawnSessionMessagingBrokerIfNeeded(): Promise<void> {
         `Session messaging broker build not found: ${brokerPath}. Run npm install in the pi-sessions package directory.`,
       );
     }
-    const child = spawn(process.execPath, [brokerPath], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: process.platform === "win32",
-      env: brokerSpawnEnv(),
-    });
-    child.unref();
-    await waitForBroker();
+    const log = openSync(brokerLogPath, "w", 0o600);
+    try {
+      const child = spawn(process.execPath, [brokerPath], {
+        detached: true,
+        stdio: ["ignore", log, log],
+        windowsHide: process.platform === "win32",
+        env: brokerSpawnEnv(),
+      });
+      await new Promise<void>((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      });
+      child.unref();
+      await waitForBroker(child);
+    } finally {
+      closeSync(log);
+    }
   } finally {
     releaseSpawnLock();
   }
@@ -103,16 +121,21 @@ function canConnectToBroker(): Promise<boolean> {
   });
 }
 
-async function waitForBroker(): Promise<void> {
+async function waitForBroker(child?: ChildProcess): Promise<void> {
   const start = Date.now();
   while (Date.now() - start < BROKER_START_TIMEOUT_MS) {
     if (await canConnectToBroker()) {
       return;
     }
+    if (child && (child.exitCode !== null || child.signalCode !== null)) {
+      throw new Error(
+        `Session messaging broker exited (${child.signalCode ?? child.exitCode}). See ${brokerLogPath}.`,
+      );
+    }
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
 
-  throw new Error("Session messaging broker failed to start.");
+  throw new Error(`Session messaging broker failed to start. See ${brokerLogPath}.`);
 }
 
 function acquireSpawnLock(): boolean {

package/extensions/session-messaging/pi/reachable-tool.ts

@@ -53,6 +53,8 @@ export interface SessionReachableDeps {
         scope: Exclude<SessionReachableScope, "user">,
       ) => Promise<readonly ReachableSubagentEntry[]>)
     | undefined;
+  /** Resolved per call; the parent is unreachable from a subagent, so it stays off the menu. */
+  getParentSessionId?: (() => string | undefined) | undefined;
 }
 
 interface SessionReachableRendererState {
@@ -123,7 +125,10 @@ async function listReachableUserSessions(
     throw new Error(`Session messaging is unavailable: ${formatError(error)}`);
   }
 
-  const targetIds = liveSessionIds.filter((sessionId) => sessionId !== currentSessionId);
+  const parentSessionId = deps.getParentSessionId?.();
+  const targetIds = liveSessionIds.filter(
+    (sessionId) => sessionId !== currentSessionId && sessionId !== parentSessionId,
+  );
   return withSessionIndex(deps.indexPath, { mode: "read", required: true }, ({ db }) => {
     const sessions: ReachableUserSession[] = [];
     for (const sessionId of targetIds) {

package/extensions/session-messaging/pi/tools.ts

@@ -46,9 +46,62 @@ interface CancelSessionService {
   cancelSession(sessionId: string): Promise<CancelSessionResult | ManagedCancelSessionResult>;
 }
 
+export type SessionSendMessageRole =
+  | { kind: "plain" }
+  | { kind: "wakeCapable" }
+  | { kind: "subagent" };
+
 export interface SessionSendMessageToolOptions {
-  wakeCapable: boolean;
+  role: SessionSendMessageRole;
   getCachedRelationTo(sessionId: string | undefined): string | undefined;
+  /**
+   * Resolved on every call: subagent identity depends on the active branch, so a rewind can
+   * turn a plain session into a subagent without re-registering this tool.
+   */
+  getParentSessionId?: (() => string | undefined) | undefined;
+}
+
+export type SessionCancelRole = { kind: "plain" } | { kind: "subagent" };
+
+export interface SessionCancelToolOptions {
+  role: SessionCancelRole;
+  /**
+   * Resolved on every call: subagent identity depends on the active branch, so a rewind can
+   * turn a plain session into a subagent without re-registering this tool.
+   */
+  getParentSessionId?: (() => string | undefined) | undefined;
+}
+
+interface SendMessageToolWording {
+  description: string;
+  promptSnippet: string;
+  promptGuidelines: string[];
+}
+
+function getSendMessageWording(role: SessionSendMessageRole): SendMessageToolWording {
+  switch (role.kind) {
+    case "plain":
+      return {
+        description: "Send a message to another live pi session.",
+        promptSnippet: "Send a message to another live pi session",
+        promptGuidelines: ["Use session_reachable to list live sessions and find the target."],
+      };
+    case "wakeCapable":
+      return {
+        description: "Send a message to another live pi session or a subagent.",
+        promptSnippet: "Send a message to another pi session or a subagent",
+        promptGuidelines: ["Use session_reachable to discover live sessions and owned subagents."],
+      };
+    case "subagent":
+      return {
+        description: "Send a message to another subagent.",
+        promptSnippet: "Send a message to another subagent",
+        promptGuidelines: [
+          "Use session_reachable to discover reachable subagents.",
+          "Report to your parent with submit_task_report; it cannot be reached with session_send_message.",
+        ],
+      };
+  }
 }
 
 interface SendMessageRendererState {
@@ -59,15 +112,7 @@ export function createSessionSendMessageTool(
   service: SendMessageService,
   options: SessionSendMessageToolOptions,
 ): ToolDefinition {
-  const description = options.wakeCapable
-    ? "Send a message to another live pi session or a subagent."
-    : "Send a message to another live pi session.";
-  const promptSnippet = options.wakeCapable
-    ? "Send a message to another pi session or a subagent"
-    : "Send a message to another live pi session";
-  const promptGuidelines = options.wakeCapable
-    ? ["Use session_reachable to discover live sessions and owned subagents."]
-    : ["Use session_reachable to list live sessions and find the target."];
+  const { description, promptSnippet, promptGuidelines } = getSendMessageWording(options.role);
 
   return defineTool({
     name: "session_send_message",
@@ -109,6 +154,9 @@ export function createSessionSendMessageTool(
     },
     async execute(toolCallId, params: SendMessageParams, _signal, _onUpdate, _ctx) {
       const target = parseSessionTarget(params.session, "session_send_message");
+      if (target === options.getParentSessionId?.()) {
+        throw new Error("The parent session cannot be messaged. Use submit_task_report.");
+      }
 
       const body = params.message.trim();
       if (!body) {
@@ -147,13 +195,28 @@ export function createSessionSendMessageTool(
   });
 }
 
-export function createSessionCancelTool(service: CancelSessionService): ToolDefinition {
+function getCancelPromptGuidelines(role: SessionCancelRole): string[] {
+  switch (role.kind) {
+    case "plain":
+      return ["Only cancel a user session when the user directs it."];
+    case "subagent":
+      return [
+        "Only cancel a user session when the user directs it.",
+        "Never cancel your parent session; it is waiting on your report.",
+      ];
+  }
+}
+
+export function createSessionCancelTool(
+  service: CancelSessionService,
+  options: SessionCancelToolOptions,
+): ToolDefinition {
   return defineTool<typeof CANCEL_SESSION_PARAMS, CancelSessionToolDetails>({
     name: "session_cancel",
     label: "Cancel a running session",
     description: "Cancel another running pi session",
     promptSnippet: "Cancel another running pi session",
-    promptGuidelines: ["Only cancel a user session when the user directs it."],
+    promptGuidelines: getCancelPromptGuidelines(options.role),
     parameters: CANCEL_SESSION_PARAMS,
     renderResult(result, options, theme, context) {
       const output = getFirstText(result);
@@ -175,6 +238,10 @@ export function createSessionCancelTool(service: CancelSessionService): ToolDefi
     },
     async execute(_toolCallId, params: CancelSessionParams) {
       const target = parseSessionTarget(params.session, "session_cancel");
+      if (target === options.getParentSessionId?.()) {
+        throw new Error("The parent session cannot be cancelled. It is waiting on your report.");
+      }
+
       const result = await service.cancelSession(target);
       if (result.kind === "managed") {
         const details: CancelSessionToolDetails = {