pi-sessions 0.9.0 → 0.11.0

package/extensions/session-search/hooks.ts

@@ -228,7 +228,7 @@ function syncSessionFileWithDb(
   const stat = statSync(sessionFile);
 
   if (baseline && isIndexCurrent(baseline, stat, sessionOrigin)) {
-    db.transaction(() => writeHookSyncMetadata(db, eventType)).immediate();
+    db.transaction(() => writeHookSyncMetadata(db, eventType));
     return true;
   }
 
@@ -279,11 +279,6 @@ function isIndexCurrent(
   );
 }
 
-// All write transactions are immediate: they read before they write, and a
-// deferred transaction whose snapshot goes stale fails with SQLITE_BUSY on the
-// read-to-write upgrade without ever invoking the busy handler. Immediate mode
-// takes the write lock at BEGIN, where busy_timeout queues us behind concurrent
-// writers from other pi processes.
 function applyFullSync(
   db: SessionIndexDatabase,
   extracted: ExtractedSessionRecord,
@@ -312,7 +307,7 @@ function applyFullSync(
     }
 
     writeHookSyncMetadata(db, eventType);
-  }).immediate();
+  });
 }
 
 function applyTailSync(
@@ -322,60 +317,58 @@ function applyTailSync(
   eventType: string,
   sessionOrigin?: SessionOrigin,
 ): boolean {
-  return db
-    .transaction((): boolean => {
-      // Another process may have advanced the index between our baseline read
-      // and this transaction; the tail deltas would then double-count.
-      const current = getSessionRowByPath(db, baseline.sessionPath);
-      if (
-        !current ||
-        current.sessionId !== baseline.sessionId ||
-        current.indexedFileSize !== baseline.indexedFileSize
-      ) {
-        return false;
-      }
+  return db.transaction((): boolean => {
+    // Another process may have advanced the index between our baseline read
+    // and this transaction; the tail deltas would then double-count.
+    const current = getSessionRowByPath(db, baseline.sessionPath);
+    if (
+      !current ||
+      current.sessionId !== baseline.sessionId ||
+      current.indexedFileSize !== baseline.indexedFileSize
+    ) {
+      return false;
+    }
 
-      const scan = tail.scan;
-      upsertSession(db, buildTailSessionRow(baseline, tail, sessionOrigin), "hook");
-
-      if (scan.sessionName !== undefined && scan.sessionName !== baseline.sessionName) {
-        clearSessionChunksBySourceKind(db, baseline.sessionId, "session_name");
-        if (scan.sessionName && scan.sessionNameEntryId) {
-          insertTextChunk(db, {
-            sessionId: baseline.sessionId,
-            ...createSessionNameChunk(
-              scan.sessionName,
-              scan.sessionNameTs ?? baseline.startedAt,
-              scan.sessionNameEntryId,
-            ),
-          });
-        }
-      }
+    const scan = tail.scan;
+    upsertSession(db, buildTailSessionRow(baseline, tail, sessionOrigin), "hook");
 
-      if (!baseline.handoffGoal && scan.handoffMetadata) {
-        const { entryId, ts, metadata } = scan.handoffMetadata;
+    if (scan.sessionName !== undefined && scan.sessionName !== baseline.sessionName) {
+      clearSessionChunksBySourceKind(db, baseline.sessionId, "session_name");
+      if (scan.sessionName && scan.sessionNameEntryId) {
         insertTextChunk(db, {
           sessionId: baseline.sessionId,
-          entryId,
-          entryType: "custom",
-          ts,
-          sourceKind: "handoff_goal",
-          text: metadata.goal,
+          ...createSessionNameChunk(
+            scan.sessionName,
+            scan.sessionNameTs ?? baseline.startedAt,
+            scan.sessionNameEntryId,
+          ),
         });
       }
+    }
 
-      for (const chunk of scan.chunks) {
-        insertTextChunk(db, { sessionId: baseline.sessionId, ...chunk });
-      }
+    if (!baseline.handoffGoal && scan.handoffMetadata) {
+      const { entryId, ts, metadata } = scan.handoffMetadata;
+      insertTextChunk(db, {
+        sessionId: baseline.sessionId,
+        entryId,
+        entryType: "custom",
+        ts,
+        sourceKind: "handoff_goal",
+        text: metadata.goal,
+      });
+    }
 
-      for (const fileTouch of scan.fileTouches) {
-        insertSessionFileTouch(db, { sessionId: baseline.sessionId, ...fileTouch });
-      }
+    for (const chunk of scan.chunks) {
+      insertTextChunk(db, { sessionId: baseline.sessionId, ...chunk });
+    }
 
-      writeHookSyncMetadata(db, eventType);
-      return true;
-    })
-    .immediate();
+    for (const fileTouch of scan.fileTouches) {
+      insertSessionFileTouch(db, { sessionId: baseline.sessionId, ...fileTouch });
+    }
+
+    writeHookSyncMetadata(db, eventType);
+    return true;
+  });
 }
 
 function buildTailSessionRow(

package/extensions/session-search/install.ts

@@ -1,24 +1,14 @@
-import {
-  type ExtensionAPI,
-  type ExtensionContext,
-  SessionManager,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { isSessionStarting } from "../session-handoff/metadata.ts";
-import type { MessagingHandle } from "../session-messaging/install.ts";
 import type { IndexHandle } from "../shared/composition.ts";
-import { formatError } from "../shared/errors.ts";
 import { stripSearchSnippetMarkers } from "../shared/search-snippet.ts";
 import {
-  getSessionById,
   type SearchSessionsParams,
   type SessionSearchEvidence,
   searchSessions,
   withSessionIndex,
 } from "../shared/session-index/index.ts";
 import type { SessionSettings } from "../shared/settings.ts";
-import type { SubagentState } from "../subagents/classify.ts";
-import type { SubagentRoster } from "../subagents/roster.ts";
 import { renderSessionSearchResult } from "./renderer.ts";
 import type {
   SessionSearchResult,
@@ -31,8 +21,6 @@ const DEFAULT_SESSION_SEARCH_LIMIT = 6;
 export interface SearchInstallDeps {
   settings: SessionSettings;
   index: IndexHandle;
-  messaging?: MessagingHandle | undefined;
-  roster?: SubagentRoster | undefined;
 }
 
 export function installSearch(pi: ExtensionAPI, deps: SearchInstallDeps): void {
@@ -46,7 +34,6 @@ export function installSearch(pi: ExtensionAPI, deps: SearchInstallDeps): void {
     promptGuidelines: [
       "Omit queries in session_search to list matching sessions chronologically.",
       "After session_search finds a session id, switch to session_ask for questions about it.",
-      'To identify your own subagents, use session_search with relationScope: "branch".',
     ],
     parameters: Type.Object({
       query: Type.Optional(
@@ -105,22 +92,11 @@ export function installSearch(pi: ExtensionAPI, deps: SearchInstallDeps): void {
           },
         ),
       ),
-      live: Type.Optional(
-        Type.Boolean({
-          description: "When true, only return currently active sessions",
-        }),
-      ),
       kind: Type.Optional(
         Type.Union([Type.Literal("user"), Type.Literal("subagent")], {
           description: "Filter by session kind",
         }),
       ),
-      relationScope: Type.Optional(
-        Type.Union([Type.Literal("branch"), Type.Literal("tree")], {
-          description:
-            "Restrict results to subagents launched from the active branch or anywhere in this session's conversation tree",
-        }),
-      ),
       limit: Type.Optional(
         Type.Number({
           description: "Number of matches to return",
@@ -142,35 +118,9 @@ export function installSearch(pi: ExtensionAPI, deps: SearchInstallDeps): void {
         details: progressDetails,
       });
 
-      const scope = await resolveSearchScope(params, deps);
-
       return withSessionIndex(indexPath, { mode: "read", required: true }, ({ db, status }) => {
-        const results = searchSessions(
-          db,
-          buildSearchParams(params, ctx, scope.includeSessionIds),
-        ).map((result): SessionSearchResult => {
-          const annotation = scope.annotations.get(result.sessionId);
-          if (!annotation) {
-            return result;
-          }
-          if ("depth" in annotation) {
-            return {
-              ...result,
-              state: annotation.state,
-              depth: annotation.depth,
-              onActiveBranch: annotation.onActiveBranch,
-            };
-          }
-          return { ...result, state: annotation.state };
-        });
-        const details: SessionSearchToolDetails = {
-          params,
-          status,
-          results,
-          ...(scope.total === undefined
-            ? {}
-            : { scope: { matched: results.length, total: scope.total } }),
-        };
+        const results = searchSessions(db, buildSearchParams(params, ctx));
+        const details: SessionSearchToolDetails = { params, status, results };
         return {
           content: [
             {
@@ -189,7 +139,6 @@ export function installSearch(pi: ExtensionAPI, deps: SearchInstallDeps): void {
 function buildSearchParams(
   params: SessionSearchToolParams,
   ctx: ExtensionContext,
-  liveSessionIds?: string[] | undefined,
 ): SearchSessionsParams {
   const currentSessionId = ctx.sessionManager.getSessionId();
 
@@ -204,119 +153,15 @@ function buildSearchParams(
     kind: params.kind,
     sort: params.sort,
     limit: params.limit ?? DEFAULT_SESSION_SEARCH_LIMIT,
-    includeSessionIds: liveSessionIds,
     relativeToSessionId: currentSessionId,
   };
 }
 
-interface StartingSearchResultAnnotation {
-  state: "starting";
-}
-
-interface RelatedSubagentSearchResultAnnotation {
-  state: SubagentState;
-  depth: number;
-  onActiveBranch: boolean;
-}
-
-type SearchResultAnnotation =
-  | StartingSearchResultAnnotation
-  | RelatedSubagentSearchResultAnnotation;
-
-interface ResolvedSearchScope {
-  includeSessionIds: string[] | undefined;
-  annotations: ReadonlyMap<string, SearchResultAnnotation>;
-  total: number | undefined;
-}
-
-async function resolveSearchScope(
-  params: SessionSearchToolParams,
-  deps: SearchInstallDeps,
-): Promise<ResolvedSearchScope> {
-  if (params.relationScope) {
-    if (!deps.roster) {
-      throw new Error("Subagent relations are unavailable because subagents are not active.");
-    }
-    try {
-      const roster = await deps.roster.resolve(params.relationScope);
-      const entries = params.live
-        ? roster.entries.filter((entry) => entry.managedLive)
-        : roster.entries;
-      const annotations = new Map<string, SearchResultAnnotation>();
-      for (const entry of roster.entries) {
-        annotations.set(entry.sessionId, {
-          state: entry.state,
-          depth: entry.depth,
-          onActiveBranch: entry.onActiveBranch,
-        });
-      }
-      return {
-        includeSessionIds: entries.map((entry) => entry.sessionId),
-        annotations,
-        total: roster.total,
-      };
-    } catch (error) {
-      throw new Error(`Subagent relation scope is unavailable: ${formatError(error)}`);
-    }
-  }
-
-  if (!params.live) {
-    return {
-      includeSessionIds: undefined,
-      annotations: new Map(),
-      total: undefined,
-    };
-  }
-
-  const liveSessionIds = await getLiveSessionIds(deps.messaging);
-  return {
-    includeSessionIds: liveSessionIds,
-    annotations: getStartingSessionAnnotations(liveSessionIds, deps.index.path),
-    total: undefined,
-  };
-}
-
-function getStartingSessionAnnotations(
-  sessionIds: readonly string[],
-  indexPath: string,
-): ReadonlyMap<string, SearchResultAnnotation> {
-  return withSessionIndex(indexPath, { mode: "read", required: true }, ({ db }) => {
-    const annotations = new Map<string, SearchResultAnnotation>();
-    for (const sessionId of sessionIds) {
-      const session = getSessionById(db, sessionId);
-      if (!session) {
-        continue;
-      }
-      try {
-        if (isSessionStarting(SessionManager.open(session.sessionPath).getBranch())) {
-          annotations.set(sessionId, { state: "starting" });
-        }
-      } catch {}
-    }
-    return annotations;
-  });
-}
-
-async function getLiveSessionIds(messaging: MessagingHandle | undefined): Promise<string[]> {
-  if (!messaging) {
-    throw new Error(
-      "Session messaging is not active; live session search requires session messaging.",
-    );
-  }
-
-  try {
-    return await messaging.listSessions();
-  } catch (error) {
-    throw new Error(`Session messaging is unavailable: ${formatError(error)}`);
-  }
-}
-
 function formatSearchResultsForModel(details: SessionSearchToolDetails): string {
   return JSON.stringify(
     {
       params: details.params,
       status: details.status,
-      ...(details.scope ? { scope: details.scope } : {}),
       results: details.results.map(formatSearchResultForModel),
     },
     null,

package/extensions/session-search/reindex.ts

@@ -34,7 +34,7 @@ export async function rebuildSessionIndex(options: ReindexOptions): Promise<Rein
     db.transaction(() => {
       dropIndexTables(db);
       initializeSchema(db);
-    }).immediate();
+    });
 
     let sessionCount = 0;
     let chunkCount = 0;
@@ -44,7 +44,7 @@ export async function rebuildSessionIndex(options: ReindexOptions): Promise<Rein
         continue;
       }
 
-      db.transaction(() => indexSession(db, extracted)).immediate();
+      db.transaction(() => indexSession(db, extracted));
       sessionCount += 1;
       chunkCount += extracted.chunks.length;
     }
@@ -53,7 +53,7 @@ export async function rebuildSessionIndex(options: ReindexOptions): Promise<Rein
       rebuildSessionLineageRelations(db);
       setMetadata(db, "indexed_at", new Date().toISOString());
       setMetadata(db, "session_source", "SessionManager.listAll()");
-    }).immediate();
+    });
 
     return { sessionCount, chunkCount, indexPath };
   } finally {

package/extensions/session-search/renderer.ts

@@ -11,8 +11,6 @@ import {
 } from "../shared/search-snippet.ts";
 import { formatSessionTitleOrShortId } from "../shared/session-ui.ts";
 import type {
-  AnnotatedSearchResult,
-  RelatedSubagentSearchResult,
   SessionSearchResult,
   SessionSearchToolDetails,
   SessionSearchToolParams,
@@ -51,11 +49,6 @@ export function renderSessionSearchResult(
   }
 
   const lines = formatSessionSearchContextLines(details.params, theme);
-  if (details.scope) {
-    lines.push(
-      theme.fg("dim", `scope: ${details.scope.matched} matched • ${details.scope.total} total`),
-    );
-  }
   if (details.results.length === 0) {
     if (lines.length > 0) lines.push("");
     lines.push(theme.fg("warning", "No matching sessions found."));
@@ -85,9 +78,7 @@ function formatSessionSearchContextLines(
     filters.push(`files.touched: ${params.files.touched.join(", ")}`);
   if (params.files?.changed?.length)
     filters.push(`files.changed: ${params.files.changed.join(", ")}`);
-  if (params.live) filters.push("live: true");
   if (params.kind) filters.push(`kind: ${params.kind}`);
-  if (params.relationScope) filters.push(`relationScope: ${params.relationScope}`);
   if (params.sort) filters.push(`sort: ${params.sort}`);
   if (params.time?.after?.trim()) filters.push(`after: ${params.time.after.trim()}`);
   if (params.time?.before?.trim()) filters.push(`before: ${params.time.before.trim()}`);
@@ -114,9 +105,7 @@ function formatSessionSearchPanelResults(
   const lines = visibleResults.flatMap((result, index) => {
     const location = formatSearchResultLocation(result.cwd);
     const relation = result.relation ? ` ${theme.fg("dim", `[${result.relation}]`)}` : "";
-    const annotation = formatSearchResultAnnotation(result);
-    const state = annotation.length > 0 ? ` ${theme.fg("dim", `[${annotation.join(" • ")}]`)}` : "";
-    const heading = `${index + 1}. ${theme.bold(formatSearchResultLabel(result))}${relation}${state}${location ? ` ${theme.fg("dim", `(${location})`)}` : ""}`;
+    const heading = `${index + 1}. ${theme.bold(formatSearchResultLabel(result))}${relation}${location ? ` ${theme.fg("dim", `(${location})`)}` : ""}`;
     const snippets = params?.query ? formatSearchSnippets(result).slice(0, 3) : [];
     return snippets.length > 0
       ? [heading, ...snippets.map((snippet) => theme.fg("dim", `  - ${snippet}`))]
@@ -130,26 +119,6 @@ function formatSessionSearchPanelResults(
   return lines;
 }
 
-function formatSearchResultAnnotation(result: SessionSearchResult): string[] {
-  if (!isAnnotatedSearchResult(result)) {
-    return [];
-  }
-  if (!isRelatedSubagentSearchResult(result)) {
-    return [result.state];
-  }
-  return [result.state, `depth ${result.depth}`, ...(result.onActiveBranch ? [] : ["history"])];
-}
-
-function isAnnotatedSearchResult(result: SessionSearchResult): result is AnnotatedSearchResult {
-  return "state" in result;
-}
-
-function isRelatedSubagentSearchResult(
-  result: AnnotatedSearchResult,
-): result is RelatedSubagentSearchResult {
-  return "depth" in result;
-}
-
 function formatSearchResultLabel(result: SessionSearchResult): string {
   return formatSessionTitleOrShortId(result.sessionName, result.sessionId);
 }

package/extensions/session-search/tool-contract.ts

@@ -4,7 +4,6 @@ import type {
   SessionIndexStatus,
   SessionKind,
 } from "../shared/session-index/index.ts";
-import type { SubagentState } from "../subagents/classify.ts";
 
 export interface SessionSearchToolParams {
   query?: string;
@@ -20,32 +19,13 @@ export interface SessionSearchToolParams {
   };
   sort?: SearchSort;
   limit?: number;
-  live?: boolean;
   kind?: SessionKind;
-  relationScope?: "branch" | "tree";
 }
 
-export interface SessionSearchScopeDetails {
-  matched: number;
-  total: number;
-}
-
-export interface StartingSearchResult extends SearchSessionResult {
-  state: "starting";
-}
-
-export interface RelatedSubagentSearchResult extends SearchSessionResult {
-  state: SubagentState;
-  depth: number;
-  onActiveBranch: boolean;
-}
-
-export type AnnotatedSearchResult = StartingSearchResult | RelatedSubagentSearchResult;
-export type SessionSearchResult = SearchSessionResult | AnnotatedSearchResult;
+export type SessionSearchResult = SearchSessionResult;
 
 export interface SessionSearchToolDetails {
   params?: SessionSearchToolParams | undefined;
   results: SessionSearchResult[];
   status?: SessionIndexStatus | undefined;
-  scope?: SessionSearchScopeDetails | undefined;
 }

package/extensions/shared/model-runtime.ts

@@ -7,13 +7,20 @@ export type ModelRuntimeProvider = (modelRegistry: ModelRegistry) => Promise<Mod
 // ModelRuntime, but ExtensionContext only exposes the ModelRegistry compatibility facade,
 // which keeps its runtime private. Until pi exposes the runtime to extensions, build a
 // fresh one per use and mirror the registered providers (e.g. pi-claude-bridge) so their
-// configs — including live streamSimple closures — carry over by reference.
+// live stream closures carry over by reference. Extensions register either a native
+// Provider or a legacy provider config, and the facade exposes each through its own
+// accessor while listing both id sets together.
 export async function createSessionModelRuntime(
   modelRegistry: ModelRegistry,
 ): Promise<ModelRuntime> {
   const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false });
 
   for (const providerId of modelRegistry.getRegisteredProviderIds()) {
+    const native = modelRegistry.getRegisteredNativeProvider(providerId);
+    if (native) {
+      modelRuntime.registerNativeProvider(native);
+      continue;
+    }
     const config = modelRegistry.getRegisteredProviderConfig(providerId);
     if (config) {
       modelRuntime.registerProvider(providerId, config);

package/extensions/shared/session-broker/client.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import net from "node:net";
+import { parseTypeBoxValue } from "../typebox.ts";
 import { readFrames, writeFrame } from "./framing.ts";
 import {
   BROKER_FRAME_SCHEMA,
@@ -176,10 +177,8 @@ export class SessionMessagingClient extends EventEmitter {
 
   private async readSocket(socket: net.Socket): Promise<void> {
     try {
-      for await (const frame of readFrames(
-        socket,
-        BROKER_FRAME_SCHEMA,
-        "Invalid session messaging broker frame",
+      for await (const frame of readFrames(socket, (value) =>
+        parseTypeBoxValue(BROKER_FRAME_SCHEMA, value, "Invalid session messaging broker frame"),
       )) {
         this.handleFrame(frame);
       }

package/extensions/shared/session-broker/framing.ts

@@ -1,7 +1,5 @@
 import type { Socket } from "node:net";
 import { createInterface } from "node:readline";
-import type { Static, TSchema } from "typebox";
-import { parseTypeBoxValue } from "../typebox.ts";
 
 const MAX_FRAME_BYTES = 256 * 1024;
 
@@ -9,11 +7,12 @@ export function writeFrame<T>(socket: Socket, frame: T): void {
   socket.write(`${JSON.stringify(frame)}\n`);
 }
 
-export async function* readFrames<T extends TSchema>(
+// The parser is injected so the detached broker can run with no dependencies
+// installed alongside it, while Pi-side callers keep using TypeBox schemas.
+export async function* readFrames<T>(
   socket: Socket,
-  schema: T,
-  context: string,
-): AsyncGenerator<Static<T>> {
+  parseFrame: (value: unknown) => T,
+): AsyncGenerator<T> {
   const reader = createInterface({ input: socket, crlfDelay: Number.POSITIVE_INFINITY });
   const lines: string[] = [];
   const waiters: Array<() => void> = [];
@@ -64,7 +63,7 @@ export async function* readFrames<T extends TSchema>(
         throw parseError instanceof Error ? parseError : new Error(String(parseError));
       }
 
-      yield parseTypeBoxValue(schema, parsed, context);
+      yield parseFrame(parsed);
     }
   } finally {
     reader.close();

package/extensions/shared/session-index/lineage.ts

@@ -239,6 +239,7 @@ function buildSessionGraph(db: SessionIndexDatabase): SessionGraph {
     "Invalid session graph rows",
   );
 
+  const sessionIds = new Set(rows.map((row) => row.sessionId));
   const pathToId = new Map(rows.map((row) => [row.sessionPath, row.sessionId]));
   const nodes = new Map<string, SessionGraphNode>(
     rows.map((row) => [
@@ -246,8 +247,11 @@ function buildSessionGraph(db: SessionIndexDatabase): SessionGraph {
       {
         ...row,
         resolvedParentSessionId:
-          row.parentSessionId ??
-          (row.parentSessionPath ? pathToId.get(row.parentSessionPath) : undefined),
+          row.parentSessionId && sessionIds.has(row.parentSessionId)
+            ? row.parentSessionId
+            : row.parentSessionPath
+              ? pathToId.get(row.parentSessionPath)
+              : undefined,
       },
     ]),
   );