pi-sessions 0.9.0 → 0.11.0

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

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 
 const requireModule = createRequire(import.meta.url);
@@ -18,32 +19,30 @@ export interface SqliteStatement {
   run(...params: SqliteBindValue[]): SqliteRunResult;
 }
 
-export interface SqliteTransaction<Args extends unknown[], Result> {
-  (...args: Args): Result;
-  immediate(...args: Args): Result;
-}
-
-export interface SqliteDatabase {
+// The surface this module consumes from a native driver. Transactions are
+// implemented inline
+interface SqliteDriver {
   prepare(sql: string): SqliteStatement;
   exec(sql: string): void;
-  transaction<Args extends unknown[], Result>(
-    fn: (...args: Args) => Result,
-  ): SqliteTransaction<Args, Result>;
   close(): void;
 }
 
+export interface SqliteDatabase extends SqliteDriver {
+  transaction<Result>(fn: () => Result): Result;
+}
+
 interface SqliteConstructor {
-  new (path: string, options?: Record<string, unknown>): SqliteDatabase;
+  new (path: string, options?: Record<string, unknown>): SqliteDriver;
 }
 
-// The driver is resolved at runtime so Bun never loads the native better-sqlite3
-// addon (unsupported) and Node never loads the bun:sqlite builtin. The require
-// result is untyped, so the cast to our structural contract is unavoidable here.
+// Each runtime gets its own built-in SQLite, resolved at runtime because neither
+// module is importable from the other. The require result is untyped, so the
+// cast to our structural contract is unavoidable here.
 function loadDatabaseConstructor(): SqliteConstructor {
   if (isBun) {
     return (requireModule("bun:sqlite") as { Database: SqliteConstructor }).Database;
   }
-  return requireModule("better-sqlite3") as SqliteConstructor;
+  return (requireModule("node:sqlite") as { DatabaseSync: SqliteConstructor }).DatabaseSync;
 }
 
 export function openSqlite(
@@ -52,13 +51,20 @@ export function openSqlite(
 ): SqliteDatabase {
   const Database = loadDatabaseConstructor();
   const readonly = options.readonly ?? false;
+
+  // node:sqlite has no fileMustExist equivalent and would otherwise create an
+  // empty database where the caller demanded an existing one.
+  if (!options.create && !existsSync(dbPath)) {
+    throw new Error(`SQLite database does not exist: ${dbPath}`);
+  }
+
   const db = isBun
     ? new Database(dbPath, {
         create: readonly ? false : options.create,
         readonly,
         readwrite: !readonly,
       })
-    : new Database(dbPath, { fileMustExist: readonly || !options.create, readonly });
+    : new Database(dbPath, { readOnly: readonly });
 
   db.exec(`PRAGMA busy_timeout = ${options.timeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS}`);
   db.exec("PRAGMA foreign_keys = ON");
@@ -77,8 +83,9 @@ export function openSqlite(
 // Neither driver memoizes prepare(), and the write paths prepare the same
 // statements once per row. SQLite re-prepares cached statements transparently
 // when the schema changes, so reusing them across DDL is safe.
-function withStatementCache(db: SqliteDatabase): SqliteDatabase {
+function withStatementCache(db: SqliteDriver): SqliteDatabase {
   const statements = new Map<string, SqliteStatement>();
+  let inTransaction = false;
 
   return {
     prepare(sql) {
@@ -94,8 +101,28 @@ function withStatementCache(db: SqliteDatabase): SqliteDatabase {
     exec(sql) {
       db.exec(sql);
     },
+    // Immediate rather than deferred: these callbacks read before they write, and
+    // a deferred transaction's read-to-write upgrade fails SQLITE_BUSY outright
+    // instead of waiting on busy_timeout.
     transaction(fn) {
-      return db.transaction(fn);
+      if (inTransaction) {
+        throw new Error(
+          "Cannot nest transactions: the outer BEGIN IMMEDIATE already holds the write lock",
+        );
+      }
+
+      inTransaction = true;
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = fn();
+        db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      } finally {
+        inTransaction = false;
+      }
     },
     close() {
       statements.clear();

package/extensions/shared/settings.ts

@@ -1,7 +1,7 @@
 import os from "node:os";
 import path from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
 import type { KeyId } from "@earendil-works/pi-tui";
 import { type Static, Type } from "typebox";
 import { isThinkingLevel } from "./thinking-levels.ts";
@@ -9,6 +9,7 @@ import { parseTypeBoxValue } from "./typebox.ts";
 
 export const DEFAULT_AUTO_TITLE_REFRESH_TURNS = 4;
 export const DEFAULT_AUTO_TITLE_TIMEOUT_SECONDS = 15;
+export const DEFAULT_AUTO_TITLE_TOKEN_BUDGET = 64;
 export const DEFAULT_AUTO_TITLE_PROMPT = `Name this coding session (under 80 chars). Be specific to what is being discussed. Your exact output will be displayed to the user, so make sure that it contains ONLY the title itself and nothing else.`;
 const SESSION_FILE_SETTINGS_SCHEMA = Type.Object({
   messaging: Type.Optional(
@@ -27,6 +28,8 @@ const SESSION_FILE_SETTINGS_SCHEMA = Type.Object({
       enable: Type.Optional(Type.Boolean()),
       pickerShortcut: Type.Optional(Type.String()),
       persistRuns: Type.Optional(Type.Boolean()),
+      model: Type.Optional(Type.String()),
+      thinkingLevel: Type.Optional(Type.String()),
       deferred: Type.Optional(
         Type.Object({
           copyToClipboard: Type.Optional(Type.Boolean()),
@@ -49,9 +52,11 @@ const SESSION_FILE_SETTINGS_SCHEMA = Type.Object({
       enable: Type.Optional(Type.Boolean()),
       refreshTurns: Type.Optional(Type.Integer({ minimum: 1 })),
       timeoutSecs: Type.Optional(Type.Integer({ minimum: 1 })),
+      tokenBudget: Type.Optional(Type.Integer({ minimum: 1 })),
       model: Type.Optional(Type.String()),
       thinkingLevel: Type.Optional(Type.String()),
       prompt: Type.Optional(Type.String()),
+      persistRuns: Type.Optional(Type.Boolean()),
     }),
   ),
   ask: Type.Optional(
@@ -80,13 +85,23 @@ export interface AgentModelSettings {
 export interface AutoTitleSettings extends AgentModelSettings {
   refreshTurns: number;
   timeoutMs: number;
+  tokenBudget: number;
   prompt: string;
+  persistRuns: boolean;
 }
 
 export interface AskSettings extends AgentModelSettings {
   persistRuns: boolean;
 }
 
+export interface HandoffSettings extends AgentModelSettings {
+  pickerShortcut: KeyId;
+  persistRuns: boolean;
+  deferred: {
+    copyToClipboard: boolean;
+  };
+}
+
 export interface FeatureToggles {
   messaging: boolean;
   subagents: boolean;
@@ -102,13 +117,7 @@ export interface SessionSettings {
   subagents: {
     maxDepth: number;
   };
-  handoff: {
-    pickerShortcut: KeyId;
-    persistRuns: boolean;
-    deferred: {
-      copyToClipboard: boolean;
-    };
-  };
+  handoff: HandoffSettings;
   index: {
     path: string;
   };
@@ -119,7 +128,7 @@ export interface SessionSettings {
 type SessionFileSettings = Static<typeof SESSION_FILE_SETTINGS_SCHEMA>;
 
 export function getDefaultIndexDir(): string {
-  return path.join(os.homedir(), ".pi", "agent", "pi-sessions");
+  return path.join(getAgentDir(), "pi-sessions");
 }
 
 export function getDefaultIndexPath(): string {
@@ -134,6 +143,10 @@ export function getDefaultHandoffRunsDir(): string {
   return path.join(getDefaultIndexDir(), "session-handoff");
 }
 
+export function getDefaultAutoTitleRunsDir(): string {
+  return path.join(getDefaultIndexDir(), "session-auto-title");
+}
+
 function expandHome(rawPath: string): string {
   if (rawPath === "~") {
     return os.homedir();
@@ -222,6 +235,7 @@ function resolveSessionSettings(fileSettings: SessionFileSettings): SessionSetti
       maxDepth: fileSettings.subagents?.maxDepth ?? 2,
     },
     handoff: {
+      ...resolveAgentModelSettings(fileSettings.handoff),
       pickerShortcut: normalizePickerShortcut(fileSettings.handoff?.pickerShortcut),
       persistRuns: fileSettings.handoff?.persistRuns ?? false,
       deferred: {
@@ -235,7 +249,9 @@ function resolveSessionSettings(fileSettings: SessionFileSettings): SessionSetti
       ...resolveAgentModelSettings(fileSettings.autoTitle),
       refreshTurns: fileSettings.autoTitle?.refreshTurns ?? DEFAULT_AUTO_TITLE_REFRESH_TURNS,
       timeoutMs: (fileSettings.autoTitle?.timeoutSecs ?? DEFAULT_AUTO_TITLE_TIMEOUT_SECONDS) * 1000,
+      tokenBudget: fileSettings.autoTitle?.tokenBudget ?? DEFAULT_AUTO_TITLE_TOKEN_BUDGET,
       prompt: normalizeAutoTitlePrompt(fileSettings.autoTitle?.prompt),
+      persistRuns: fileSettings.autoTitle?.persistRuns ?? false,
     },
     ask: {
       ...resolveAgentModelSettings(fileSettings.ask),

package/extensions/shared/tmux.ts

@@ -81,9 +81,31 @@ export async function hasAttachedTmuxClients(
   return result.stdout.split("\n").some((line) => line.trim().length > 0);
 }
 
+const pendingCreations = new Map<string, Promise<unknown>>();
+
+// Creating a window is check-then-act: it asks whether the tmux session exists and then either
+// creates it or adds to it. Sibling subagents launched in one turn share a session name and race,
+// so all but the winner get `duplicate session`. Only the parent's process ever creates its own
+// session name, so serializing here is enough to close the window.
 export async function createTmuxWindow(
   executor: TmuxExecutor,
   options: CreateTmuxWindowOptions,
+): Promise<TmuxWindow> {
+  const preceding = pendingCreations.get(options.tmuxSession) ?? Promise.resolve();
+  const creation = preceding.catch(() => {}).then(() => createWindow(executor, options));
+  pendingCreations.set(options.tmuxSession, creation);
+  try {
+    return await creation;
+  } finally {
+    if (pendingCreations.get(options.tmuxSession) === creation) {
+      pendingCreations.delete(options.tmuxSession);
+    }
+  }
+}
+
+async function createWindow(
+  executor: TmuxExecutor,
+  options: CreateTmuxWindowOptions,
 ): Promise<TmuxWindow> {
   const existing = (await listTmuxWindows(executor, options.tmuxSession)).find(
     (window) => window.piSessionId === options.piSessionId,

package/extensions/subagents/classify.ts

@@ -9,6 +9,8 @@ export type SubagentState =
   | "interrupted"
   | "unknown";
 
+const RUNNING_SUBAGENT_STATES: ReadonlySet<SubagentState> = new Set(["starting", "busy", "active"]);
+
 export interface SubagentEvidence {
   hasWindow: boolean;
   brokerLive: boolean;
@@ -20,6 +22,10 @@ export interface SubagentEvidence {
   childReadable: boolean;
 }
 
+export function isRunningSubagentState(state: SubagentState): boolean {
+  return RUNNING_SUBAGENT_STATES.has(state);
+}
+
 export function classifySubagent(evidence: SubagentEvidence): SubagentState {
   if (!evidence.childReadable) {
     return "unknown";

package/extensions/subagents/install.ts

@@ -1,9 +1,5 @@
-import type { ExtensionAPI, SessionEntry, SessionTreeNode } from "@earendil-works/pi-coding-agent";
-import { type HandoffLaunchTarget, SUBAGENT_LAUNCH } from "../session-handoff/launch-target.ts";
-import {
-  getHandoffMetadataFromEntries,
-  type HandoffSubagent,
-} from "../session-handoff/metadata.ts";
+import type { ExtensionAPI, SessionTreeNode } from "@earendil-works/pi-coding-agent";
+import type { HandoffLaunchTarget } from "../session-handoff/launch-target.ts";
 import type {
   MessagingHandle,
   SendMessageRequest,
@@ -11,17 +7,14 @@ import type {
 } from "../session-messaging/install.ts";
 import type { SessionLifecycle } from "../shared/composition.ts";
 import type { SessionSettings } from "../shared/settings.ts";
-import { hasAttachedTmuxClients, isTmuxInstalled, tmuxSessionName } from "../shared/tmux.ts";
+import { isTmuxInstalled } from "../shared/tmux.ts";
 import { SubagentCancellationRouter, type SubagentCancelResult } from "./cancel.ts";
 import { createSubagentLaunchTarget, type SubagentLaunchState } from "./launch-target.ts";
 import {
-  getChildSubagentLifecycle,
   hasSubagentLaunchEntries,
-  SUBAGENT_CLOSED_CUSTOM_TYPE,
   SUBAGENT_LAUNCHED_CUSTOM_TYPE,
   SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
   SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE,
-  SUBAGENT_REPORT_REMINDER_MESSAGE_CUSTOM_TYPE,
 } from "./ledger.ts";
 import { openReconcileSession, SubagentReconciler } from "./reconcile.ts";
 import {
@@ -31,10 +24,14 @@ import {
 } from "./report.ts";
 import { renderSubagentReportMessage } from "./report-message-renderer.ts";
 import { openRosterSession, type SubagentRoster, TranscriptSubagentRoster } from "./roster.ts";
+import {
+  countSubagentReports,
+  createSettledChildLifecycle,
+  findSelfSubagentIdentity,
+  type SubagentChildSessionState,
+} from "./settle.ts";
 import { SubagentMessageRouter } from "./wake.ts";
 
-const LINGER_POLL_MS = 1_000;
-
 interface ParentSessionState extends SubagentParentSession {
   getSessionName(): string | undefined;
   launchState: SubagentLaunchState;
@@ -44,15 +41,9 @@ interface ParentSessionState extends SubagentParentSession {
   shutdown(): void;
 }
 
-interface ChildSessionState {
-  identity: HandoffSubagent;
-  requestResponse: boolean;
-  reportsAtTurnStart: number;
-}
-
 interface CurrentSubagentSession {
   parent: ParentSessionState;
-  child?: ChildSessionState | undefined;
+  child?: SubagentChildSessionState | undefined;
 }
 
 export interface SubagentsHandle extends SessionLifecycle {
@@ -70,16 +61,9 @@ export function installSubagents(
 
   let epoch = 0;
   let current: CurrentSubagentSession | undefined;
-  let lingerTimer: NodeJS.Timeout | undefined;
 
   const isCurrentSession = (candidateEpoch: number): boolean =>
     current?.parent.epoch === candidateEpoch;
-  const clearLinger = (): void => {
-    if (lingerTimer) {
-      clearTimeout(lingerTimer);
-      lingerTimer = undefined;
-    }
-  };
   const reconciler = new SubagentReconciler({
     executor: pi,
     messaging: deps.messaging,
@@ -87,6 +71,7 @@ export function installSubagents(
     isCurrent: isCurrentSession,
     openSession: openReconcileSession,
   });
+  const settledChildLifecycle = createSettledChildLifecycle(pi, reconciler, isCurrentSession);
   const roster = new TranscriptSubagentRoster({
     executor: pi,
     messaging: deps.messaging,
@@ -150,9 +135,9 @@ You are working as a subagent on one task delegated by a parent session. The han
   });
 
   pi.on("agent_start", (_event, ctx) => {
-    clearLinger();
+    settledChildLifecycle.cancel();
     if (current?.child) {
-      current.child.reportsAtTurnStart = countReports(ctx.sessionManager.getBranch());
+      current.child.reportsAtTurnStart = countSubagentReports(ctx.sessionManager.getBranch());
     }
   });
 
@@ -161,28 +146,11 @@ You are working as a subagent on one task delegated by a parent session. The han
     if (!session || session.parent.sessionId !== ctx.sessionManager.getSessionId()) {
       return;
     }
-    if (hasSubagentLaunchEntries(session.parent.getBranch())) {
-      await reconciler.reconcile();
-    }
+    const reconciliation = hasSubagentLaunchEntries(session.parent.getBranch())
+      ? await reconciler.reconcile()
+      : undefined;
     if (session.child) {
-      if (ctx.hasPendingMessages()) {
-        return;
-      }
-      const shouldExit = settleChild(pi, session.child, ctx.sessionManager.getBranch());
-      if (!shouldExit) {
-        return;
-      }
-      await exitWhenUnobserved(
-        pi,
-        session.parent,
-        session.child.identity,
-        isCurrentSession,
-        (timer) => {
-          clearLinger();
-          lingerTimer = timer;
-        },
-      );
-      return;
+      await settledChildLifecycle.settle(session.parent, session.child, reconciliation);
     }
   });
 
@@ -202,11 +170,12 @@ You are working as a subagent on one task delegated by a parent session. The han
       return [createSubagentLaunchTarget(pi, parent.launchState, isCurrentSession)];
     },
     async onSessionStart(_event, ctx) {
-      clearLinger();
+      settledChildLifecycle.cancel();
       epoch += 1;
       const sessionId = ctx.sessionManager.getSessionId();
-      const identity = findSelfSubagentIdentity(ctx.sessionManager);
       const sessionManager = ctx.sessionManager;
+      const sessionStartBranch = sessionManager.getBranch();
+      const identity = findSelfSubagentIdentity(sessionId, sessionStartBranch);
       const parent: ParentSessionState = {
         sessionId,
         getSessionName: () => sessionManager.getSessionName(),
@@ -227,7 +196,7 @@ You are working as a subagent on one task delegated by a parent session. The han
               child: {
                 identity,
                 requestResponse: identity.requestResponse,
-                reportsAtTurnStart: countReports(sessionManager.getBranch()),
+                reportsAtTurnStart: countSubagentReports(sessionStartBranch),
               },
             }
           : {}),
@@ -249,7 +218,7 @@ You are working as a subagent on one task delegated by a parent session. The han
       }
     },
     async onSessionShutdown(event) {
-      clearLinger();
+      settledChildLifecycle.cancel();
       if (current && event.reason !== "reload") {
         await reconciler.suspendForShutdown();
       }
@@ -258,87 +227,3 @@ You are working as a subagent on one task delegated by a parent session. The han
     },
   };
 }
-
-function settleChild(
-  pi: ExtensionAPI,
-  child: ChildSessionState,
-  branch: readonly SessionEntry[],
-): boolean {
-  const lifecycle = getChildSubagentLifecycle(branch);
-  const reports = lifecycle.reports.length;
-  if (reports > child.reportsAtTurnStart) {
-    return true;
-  }
-  if (!child.requestResponse) {
-    pi.appendEntry(SUBAGENT_CLOSED_CUSTOM_TYPE, {
-      reason: "no_response_expected",
-    });
-    return true;
-  }
-
-  if (lifecycle.hasReminder) {
-    pi.appendEntry(SUBAGENT_CLOSED_CUSTOM_TYPE, {
-      reason: "no_report_after_reminder",
-    });
-    return true;
-  }
-
-  pi.sendMessage(
-    {
-      customType: SUBAGENT_REPORT_REMINDER_MESSAGE_CUSTOM_TYPE,
-      content:
-        "[system] Your delegated turn settled without a task report. Call submit_task_report now with done, blocked, or incomplete status.",
-      display: true,
-    },
-    { triggerTurn: true },
-  );
-  return false;
-}
-
-function countReports(branch: readonly SessionEntry[]): number {
-  return getChildSubagentLifecycle(branch).reports.length;
-}
-
-function findSelfSubagentIdentity(session: {
-  getSessionId(): string;
-  getBranch(): readonly SessionEntry[];
-}): HandoffSubagent | undefined {
-  const metadata = getHandoffMetadataFromEntries(session.getBranch());
-  if (metadata?.launch !== SUBAGENT_LAUNCH) {
-    return undefined;
-  }
-  return metadata.subagent.childSessionId === session.getSessionId()
-    ? metadata.subagent
-    : undefined;
-}
-
-async function exitWhenUnobserved(
-  executor: ExtensionAPI,
-  parent: ParentSessionState,
-  identity: HandoffSubagent,
-  isCurrentSession: (epoch: number) => boolean,
-  setTimer: (timer: NodeJS.Timeout) => void,
-): Promise<void> {
-  const check = async (): Promise<void> => {
-    if (!isCurrentSession(parent.epoch) || parent.hasPendingMessages() || !parent.isIdle()) {
-      return;
-    }
-
-    let attached = false;
-    try {
-      attached = await hasAttachedTmuxClients(executor, tmuxSessionName(identity.ownerSessionId));
-    } catch {
-      attached = false;
-    }
-    if (!isCurrentSession(parent.epoch)) {
-      return;
-    }
-    if (!attached) {
-      parent.shutdown();
-      return;
-    }
-    setTimer(setTimeout(() => void check(), LINGER_POLL_MS));
-  };
-
-  await check();
-}

package/extensions/subagents/report-message-renderer.ts

@@ -5,7 +5,7 @@ import { SUBAGENT_REPORT_MESSAGE_SCHEMA } from "./ledger.ts";
 import { presentSubagentReportMessage } from "./report-message-presenter.ts";
 import { buildSubagentReportMessageView } from "./report-message-view-model.ts";
 
-export const renderSubagentReportMessage: MessageRenderer = (message, _options, theme) => {
+export const renderSubagentReportMessage: MessageRenderer = (message, options, theme) => {
   const details = safeParseTypeBoxValue(SUBAGENT_REPORT_MESSAGE_SCHEMA, message.details);
   if (!details) {
     return undefined;
@@ -15,7 +15,7 @@ export const renderSubagentReportMessage: MessageRenderer = (message, _options,
     return undefined;
   }
 
-  const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+  const box = new Box(options.outputPad, 1, (text) => theme.bg("customMessageBg", text));
   box.addChild(new Text(presentSubagentReportMessage(report, theme), 0, 0));
   return box;
 };