pi-sessions 0.10.0 → 0.11.1

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,
       },
     ]),
   );

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(
@@ -51,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(
@@ -82,7 +85,9 @@ export interface AgentModelSettings {
 export interface AutoTitleSettings extends AgentModelSettings {
   refreshTurns: number;
   timeoutMs: number;
+  tokenBudget: number;
   prompt: string;
+  persistRuns: boolean;
 }
 
 export interface AskSettings extends AgentModelSettings {
@@ -123,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 {
@@ -138,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();
@@ -240,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,