pi-sessions 0.14.3 → 0.16.0

package/extensions/subagents/wake.ts

@@ -1,5 +1,5 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import type { SendMessageRequest, SendMessageResult } from "../session-messaging/install.ts";
+import type { SessionWaker, WakeMessaging } from "../session-messaging/message-router.ts";
 import {
   createTmuxWindow,
   killTmuxWindow,
@@ -9,125 +9,60 @@ import {
 } from "../shared/tmux.ts";
 import { findOwnedSubagentLaunch, type SubagentLaunched } from "./ledger.ts";
 
-const SESSION_READY_TIMEOUT_MS = 30_000;
-
 export interface WakeParentSession {
   sessionId: string;
   epoch: number;
   getBranch(): readonly SessionEntry[];
 }
 
-interface WakeMessaging {
-  sendMessage(request: SendMessageRequest): Promise<SendMessageResult>;
-  listSessions(): Promise<string[]>;
-  waitForSession(sessionId: string, timeoutMs: number): Promise<boolean>;
-}
-
-export interface SubagentMessageRouterOptions {
-  readyTimeoutMs?: number;
-  onMaterialize?(launch: SubagentLaunched): void;
-  afterOwnedSend?(): Promise<void> | void;
-}
-
-export class SubagentMessageRouter {
-  private readonly wakeBySessionId = new Map<string, Promise<void>>();
-
+export class SubagentWaker implements SessionWaker {
   constructor(
     private readonly executor: TmuxExecutor,
     private readonly messaging: WakeMessaging,
     private readonly getParent: () => WakeParentSession | undefined,
     private readonly isCurrent: (epoch: number) => boolean,
-    private readonly options: SubagentMessageRouterOptions = {},
+    private readonly options: {
+      onMaterialize?(launch: SubagentLaunched): void;
+      afterSend?(): Promise<void> | void;
+    } = {},
   ) {}
 
-  async sendMessage(request: SendMessageRequest): Promise<SendMessageResult> {
-    let failedLiveSend: SendMessageResult | undefined;
-    if (await this.isLive(request.target)) {
-      const result = await this.messaging.sendMessage(request);
-      if (result.delivered || !isTargetDeparture(result)) {
-        return result;
-      }
-      failedLiveSend = result;
-    }
-
+  owns(target: string): boolean {
     const parent = this.getParent();
-    const launch = parent
-      ? findOwnedSubagentLaunch(parent.getBranch(), parent.sessionId, request.target)
-      : undefined;
-    if (!parent || !launch) {
-      return failedLiveSend ?? this.messaging.sendMessage(request);
-    }
-
-    try {
-      await this.wake(parent, launch);
-      const result = await this.sendOwned(parent, request);
-      if (result.delivered || !isTargetDeparture(result)) {
-        return result;
-      }
-
-      await this.wake(parent, launch);
-      return this.sendOwned(parent, request);
-    } finally {
-      await this.options.afterOwnedSend?.();
-    }
+    return Boolean(parent && findOwnedSubagentLaunch(parent.getBranch(), parent.sessionId, target));
   }
 
-  private async wake(parent: WakeParentSession, launch: SubagentLaunched): Promise<void> {
-    const existing = this.wakeBySessionId.get(launch.childSessionId);
-    if (existing) {
-      return existing;
-    }
-
-    const wake = this.ensureReady(parent, launch).finally(() => {
-      if (this.wakeBySessionId.get(launch.childSessionId) === wake) {
-        this.wakeBySessionId.delete(launch.childSessionId);
-      }
-    });
-    this.wakeBySessionId.set(launch.childSessionId, wake);
-    return wake;
-  }
-
-  private async ensureReady(parent: WakeParentSession, launch: SubagentLaunched): Promise<void> {
-    if (await this.isLive(launch.childSessionId)) {
-      return;
-    }
-
+  async wake(target: string): Promise<void> {
+    const { parent, launch } = this.resolve(target);
     const tmuxSession = tmuxSessionName(parent.sessionId);
     const hasWindow = (await listTmuxWindows(this.executor, tmuxSession)).some(
-      (window) => window.piSessionId === launch.childSessionId,
+      (window) => window.piSessionId === target,
     );
+    if (!hasWindow) await this.createWindow(parent, launch, tmuxSession);
+  }
 
-    if (!hasWindow) {
-      await this.createWindow(parent, launch, tmuxSession);
-    }
-    if (
-      await this.messaging.waitForSession(
-        launch.childSessionId,
-        this.options.readyTimeoutMs ?? SESSION_READY_TIMEOUT_MS,
-      )
-    ) {
-      return;
-    }
-
-    this.requireCurrent(parent);
-    const killed = await killTmuxWindow(this.executor, tmuxSession, launch.childSessionId);
+  async restart(target: string): Promise<void> {
+    const { parent, launch } = this.resolve(target);
+    const tmuxSession = tmuxSessionName(parent.sessionId);
+    const killed = await killTmuxWindow(this.executor, tmuxSession, target);
     if (!killed) {
       throw new Error(
-        `Subagent ${launch.childSessionId} did not register and its stale tmux window could not be stopped.`,
+        `Subagent ${target} did not register and its stale tmux window could not be stopped.`,
       );
     }
-
     await this.createWindow(parent, launch, tmuxSession);
-    if (
-      !(await this.messaging.waitForSession(
-        launch.childSessionId,
-        this.options.readyTimeoutMs ?? SESSION_READY_TIMEOUT_MS,
-      ))
-    ) {
-      throw new Error(
-        `Subagent ${launch.childSessionId} was restarted but did not register for messaging.`,
-      );
-    }
+  }
+
+  afterSend(): Promise<void> | void {
+    return this.options.afterSend?.();
+  }
+
+  private resolve(target: string): { parent: WakeParentSession; launch: SubagentLaunched } {
+    const parent = this.getParent();
+    const launch = parent && findOwnedSubagentLaunch(parent.getBranch(), parent.sessionId, target);
+    if (!parent || !launch) throw new Error(`No owned subagent ${target}.`);
+    this.requireCurrent(parent);
+    return { parent, launch };
   }
 
   private async createWindow(
@@ -135,9 +70,7 @@ export class SubagentMessageRouter {
     launch: SubagentLaunched,
     tmuxSession: string,
   ): Promise<void> {
-    if (await this.isLive(launch.childSessionId)) {
-      return;
-    }
+    if ((await this.messaging.listSessions()).includes(launch.childSessionId)) return;
     this.requireCurrent(parent);
     this.options.onMaterialize?.(launch);
     await createTmuxWindow(this.executor, {
@@ -149,25 +82,8 @@ export class SubagentMessageRouter {
     });
   }
 
-  private sendOwned(
-    parent: WakeParentSession,
-    request: SendMessageRequest,
-  ): Promise<SendMessageResult> {
-    this.requireCurrent(parent);
-    return this.messaging.sendMessage(request);
-  }
-
-  private async isLive(sessionId: string): Promise<boolean> {
-    return (await this.messaging.listSessions()).includes(sessionId);
-  }
-
   private requireCurrent(parent: WakeParentSession): void {
-    if (!this.isCurrent(parent.epoch)) {
+    if (!this.isCurrent(parent.epoch))
       throw new Error("The parent session changed while waking its subagent.");
-    }
   }
 }
-
-function isTargetDeparture(result: SendMessageResult): boolean {
-  return !result.delivered && (result.reason === "no_session" || result.reason === "disconnected");
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sessions",
-  "version": "0.14.3",
+  "version": "0.16.0",
   "type": "module",
   "description": "Pi session search, ask, handoff, messaging, auto-titling, and indexing tools",
   "license": "MIT",
@@ -38,10 +38,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.10",
-    "@earendil-works/pi-agent-core": "^1.0.2",
-    "@earendil-works/pi-ai": "^1.0.2",
-    "@earendil-works/pi-coding-agent": "^1.0.2",
-    "@earendil-works/pi-tui": "^1.0.2",
+    "@earendil-works/pi-agent-core": "^1.0.4",
+    "@earendil-works/pi-ai": "^1.0.4",
+    "@earendil-works/pi-coding-agent": "^1.0.4",
+    "@earendil-works/pi-tui": "^1.0.4",
     "@types/node": "^24.13.3",
     "strip-ansi": "^7.2.0",
     "typebox": "1.3.27",

package/extensions/session-search/reindex.ts

@@ -1,97 +0,0 @@
-import path from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import {
-  clearSessionIndexedData,
-  ensureIndexDir,
-  initializeSchema,
-  insertSessionFileTouch,
-  insertTextChunk,
-  openIndexDatabase,
-  rebuildSessionLineageRelations,
-  type SessionIndexDatabase,
-  setMetadata,
-  upsertSession,
-} from "../shared/session-index/index.ts";
-import { type ExtractedSessionRecord, extractSessionRecord, listSessionFiles } from "./extract.ts";
-
-export interface ReindexOptions {
-  indexPath: string;
-}
-
-export interface ReindexResult {
-  sessionCount: number;
-  chunkCount: number;
-  indexPath: string;
-}
-
-export async function rebuildSessionIndex(options: ReindexOptions): Promise<ReindexResult> {
-  const indexPath = options.indexPath;
-  ensureIndexDir(path.dirname(indexPath));
-  const sessionFiles = listSessionFiles(path.join(getAgentDir(), "sessions"));
-
-  const db = openIndexDatabase(indexPath, { create: true });
-  try {
-    db.transaction(() => {
-      dropIndexTables(db);
-      initializeSchema(db);
-    });
-
-    const indexedSessions = new Map<string, { modifiedAt: string; chunks: number }>();
-    let chunkCount = 0;
-    for (const sessionFile of sessionFiles) {
-      const extracted = extractSessionRecord(sessionFile);
-      if (!extracted) {
-        continue;
-      }
-
-      const previous = indexedSessions.get(extracted.sessionId);
-      if (previous && previous.modifiedAt > extracted.modifiedAt) continue;
-      db.transaction(() => indexSession(db, extracted));
-      chunkCount += extracted.chunks.length - (previous?.chunks ?? 0);
-      indexedSessions.set(extracted.sessionId, {
-        modifiedAt: extracted.modifiedAt,
-        chunks: extracted.chunks.length,
-      });
-    }
-
-    db.transaction(() => {
-      rebuildSessionLineageRelations(db);
-      setMetadata(db, "indexed_at", new Date().toISOString());
-      setMetadata(db, "session_source", "session files");
-    });
-
-    return { sessionCount: indexedSessions.size, chunkCount, indexPath };
-  } finally {
-    db.close();
-  }
-}
-
-function dropIndexTables(db: SessionIndexDatabase): void {
-  // Children before parents: foreign_keys is ON and DROP TABLE runs an
-  // implicit DELETE that parent-side constraints would reject.
-  db.exec(`
-    DROP TABLE IF EXISTS session_lineage_relations;
-    DROP TABLE IF EXISTS session_repo_roots;
-    DROP TABLE IF EXISTS session_text_chunks;
-    DROP TABLE IF EXISTS session_file_touches;
-    DROP TABLE IF EXISTS session_text_chunks_fts;
-    DROP TABLE IF EXISTS sessions;
-    DROP TABLE IF EXISTS metadata;
-  `);
-}
-
-function indexSession(db: SessionIndexDatabase, extracted: ExtractedSessionRecord): void {
-  clearSessionIndexedData(db, extracted.sessionId);
-  upsertSession(db, extracted, "full_reindex");
-
-  for (const chunk of extracted.chunks) {
-    insertTextChunk(db, { sessionId: extracted.sessionId, ...chunk });
-  }
-
-  for (const fileTouch of extracted.fileTouches) {
-    insertSessionFileTouch(db, {
-      sessionId: extracted.sessionId,
-      ...fileTouch,
-    });
-  }
-}