@daniel156161/prism 0.2.90 → 0.2.92

package/node_modules/@earendil-works/pi-coding-agent/dist/cli.js

@@ -8,7 +8,7 @@
 import { APP_NAME } from "./config.js";
 import { configureHttpDispatcher } from "./core/http-dispatcher.js";
 import { main } from "./main.js";
-process.title = APP_NAME;
+process.title = "▲";
 process.env.PI_CODING_AGENT = "true";
 process.env.AI_AGENT = "pi";
 process.emitWarning = (() => { });

package/node_modules/@earendil-works/pi-coding-agent/dist/config.js

@@ -321,10 +321,9 @@ export function getThemesDir() {
     if (isBunBinary) {
         return join(getPackageDir(), "theme");
     }
-    // Theme is in modes/interactive/theme/ relative to src/ or dist/
-    const packageDir = getPackageDir();
-    const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
-    return join(packageDir, srcOrDist, "modes", "interactive", "theme");
+    // Prism: use __dirname so built-in themes resolve from the actual dist/,
+    // not PI_PACKAGE_DIR which may point to a config-only dir without dist/.
+    return join(__dirname, "modes", "interactive", "theme");
 }
 /**
  * Get path to HTML export template directory (shipped with package)
@@ -336,9 +335,7 @@ export function getExportTemplateDir() {
     if (isBunBinary) {
         return join(getPackageDir(), "export-html");
     }
-    const packageDir = getPackageDir();
-    const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
-    return join(packageDir, srcOrDist, "core", "export-html");
+    return join(__dirname, "core", "export-html");
 }
 /** Get path to package.json */
 export function getPackageJsonPath() {
@@ -370,9 +367,7 @@ export function getInteractiveAssetsDir() {
     if (isBunBinary) {
         return join(getPackageDir(), "assets");
     }
-    const packageDir = getPackageDir();
-    const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
-    return join(packageDir, srcOrDist, "modes", "interactive", "assets");
+    return join(__dirname, "modes", "interactive", "assets");
 }
 /** Get path to a bundled interactive asset */
 export function getBundledInteractiveAssetPath(name) {
@@ -426,7 +421,7 @@ export function getModelsPath() {
 }
 /** Get path to auth.json */
 export function getAuthPath() {
-    return join(getAgentDir(), "auth.json");
+    return process.env.PRISM_AUTH_PATH || process.env.PI_AUTH_PATH || join(getAgentDir(), "auth.json");
 }
 /** Get path to settings.json */
 export function getSettingsPath() {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session-services.js

@@ -55,7 +55,7 @@ export async function createAgentSessionServices(options) {
     const agentDir = options.agentDir ? resolvePath(options.agentDir) : getAgentDir();
     const modelRuntime = options.modelRuntime ??
         (await ModelRuntime.create({
-            authPath: join(agentDir, "auth.json"),
+            authPath: process.env.PRISM_AUTH_PATH || process.env.PI_AUTH_PATH || join(agentDir, "auth.json"),
             modelsPath: join(agentDir, "models.json"),
             signal: options.modelRuntimeSignal,
         }));

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session.js

@@ -2084,6 +2084,11 @@ export class AgentSession {
         // Context overflow is handled by compaction, not retry.
         if (isContextOverflow(message, this.model?.contextWindow ?? 0))
             return false;
+        // Prism: provider account/quota usage limits need a user decision (wait, switch model, or cancel).
+        // Do not auto-retry them with the generic exponential backoff, because provider reset
+        // windows are often much longer than the retry delay.
+        if (/GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing|usage[_\s-]*limit|usage_limit_reached/i.test(message.errorMessage || ""))
+            return false;
         return isRetryableAssistantError(message);
     }
     /**

package/node_modules/@earendil-works/pi-coding-agent/dist/core/auth-storage.js

@@ -14,7 +14,7 @@ const AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 0o600 };
 let sharedAuthFileReadState;
 export class FileAuthStorageBackend {
     authPath;
-    constructor(authPath = join(getAgentDir(), "auth.json")) {
+    constructor(authPath = (process.env.PRISM_AUTH_PATH || process.env.PI_AUTH_PATH || join(getAgentDir(), "auth.json"))) {
         this.authPath = normalizePath(authPath);
     }
     ensureParentDir() {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/loader.js

@@ -9,6 +9,8 @@ import { fileURLToPath } from "node:url";
 import * as _bundledPiAgentCore from "@earendil-works/pi-agent-core";
 import * as _bundledPiAiCompat from "@earendil-works/pi-ai/compat";
 import * as _bundledPiAiOauth from "@earendil-works/pi-ai/oauth";
+import * as _prismPiAiOpenAICompletions from "@earendil-works/pi-ai/api/openai-completions";
+import * as _prismPiAiOpenAIResponses from "@earendil-works/pi-ai/api/openai-responses";
 import * as _bundledPiAiProviders from "@earendil-works/pi-ai/providers/all";
 import * as _bundledPiTui from "@earendil-works/pi-tui";
 import { createJiti } from "jiti/static";
@@ -21,12 +23,14 @@ import * as _bundledTypeboxValue from "typebox/value";
 import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.js";
 // NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
 // avoiding a circular dependency. Extensions can import from @earendil-works/pi-coding-agent.
-import * as _bundledPiCodingAgent from "../../index.js";
+import * as _bundledPiCodingAgent from "./index.js";
 import { resolvePath } from "../../utils/paths.js";
 import { createEventBus } from "../event-bus.js";
 import { execCommand } from "../exec.js";
 import { readPiManifest } from "../pi-manifest.js";
 import { createSyntheticSourceInfo } from "../source-info.js";
+globalThis.__PRISM_PI_AI_OPENAI_COMPLETIONS__ = _prismPiAiOpenAICompletions;
+globalThis.__PRISM_PI_AI_OPENAI_RESPONSES__ = _prismPiAiOpenAIResponses;
 import { time } from "../timings.js";
 /** Modules available to extensions via virtualModules (for compiled Bun binary) */
 const VIRTUAL_MODULES = {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/prism-session-db.js

@@ -0,0 +1,128 @@
+import { createRequire } from "node:module";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+const require = createRequire(import.meta.url);
+export function getSessionBackend() {
+  return process.env.PRISM_SESSION_BACKEND || "db";
+}
+export function findMostRecentSessionFromDb(sessionDir) {
+  try {
+    const db = openDb();
+    const row = db.prepare("SELECT file_path FROM sessions WHERE session_dir = ? ORDER BY updated_at DESC LIMIT 1").get(sessionDir);
+    db.close();
+    return row?.file_path || null;
+  } catch { return null; }
+}
+export function deleteSessionFromDb(filePath) {
+  if (!filePath) return;
+  try {
+    const db = openDb();
+    db.prepare("DELETE FROM sessions WHERE file_path = ?").run(filePath);
+    db.close();
+  } catch { }
+}
+function openDb() {
+  const prismDir = process.env.PRISM_CODING_AGENT_DIR || process.env.PI_CODING_AGENT_DIR || join(homedir(), ".prism");
+  const dbPath = join(prismDir, "sessions.db");
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const { DatabaseSync } = require("node:sqlite");
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA synchronous=NORMAL");
+  db.exec("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, file_path TEXT UNIQUE, cwd TEXT, session_dir TEXT, created_at TEXT, updated_at TEXT, parent_session TEXT, version INTEGER, header_json TEXT NOT NULL)");
+  db.exec("CREATE TABLE IF NOT EXISTS entries (session_id TEXT NOT NULL, entry_id TEXT NOT NULL, idx INTEGER NOT NULL, parent_id TEXT, type TEXT, timestamp TEXT, data_json TEXT NOT NULL, PRIMARY KEY (session_id, entry_id), FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_entries_session_idx ON entries(session_id, idx)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at)");
+  return db;
+}
+export function mirrorSessionFileToDb(filePath, entries, cwd, sessionDir) {
+  if (!filePath) return;
+  const header = entries.find((entry) => entry?.type === "session" && typeof entry.id === "string");
+  if (!header) return;
+  const rows = entries.filter((entry) => entry !== header);
+  const db = openDb();
+  const updatedAt = rows.at(-1)?.timestamp || header.timestamp || new Date().toISOString();
+  const insertSession = db.prepare("INSERT INTO sessions (id, file_path, cwd, session_dir, created_at, updated_at, parent_session, version, header_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET file_path=excluded.file_path, cwd=excluded.cwd, session_dir=excluded.session_dir, updated_at=excluded.updated_at, parent_session=excluded.parent_session, version=excluded.version, header_json=excluded.header_json");
+  const insertEntry = db.prepare("INSERT INTO entries (session_id, entry_id, idx, parent_id, type, timestamp, data_json) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(session_id, entry_id) DO UPDATE SET idx=excluded.idx, parent_id=excluded.parent_id, type=excluded.type, timestamp=excluded.timestamp, data_json=excluded.data_json");
+  const deleteEntries = db.prepare("DELETE FROM entries WHERE session_id = ?");
+  db.exec("BEGIN");
+  try {
+    insertSession.run(header.id, filePath, header.cwd || cwd || "", sessionDir || dirname(filePath), header.timestamp || "", updatedAt, header.parentSession || null, header.version || null, JSON.stringify(header));
+    deleteEntries.run(header.id);
+    rows.forEach((entry, idx) => insertEntry.run(header.id, typeof entry.id === "string" ? entry.id : String(idx), idx, entry.parentId ?? null, entry.type || null, entry.timestamp || null, JSON.stringify(entry)));
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    db.close();
+    throw error;
+  }
+  db.close();
+}
+export function mirrorEntryToDb(filePath, header, entry, cwd, sessionDir, index) {
+  if (!filePath || !header?.id || !entry) return;
+  const db = openDb();
+  const insertSession = db.prepare("INSERT INTO sessions (id, file_path, cwd, session_dir, created_at, updated_at, parent_session, version, header_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET file_path=excluded.file_path, cwd=excluded.cwd, session_dir=excluded.session_dir, updated_at=excluded.updated_at, parent_session=excluded.parent_session, version=excluded.version, header_json=excluded.header_json");
+  const insertEntry = db.prepare("INSERT INTO entries (session_id, entry_id, idx, parent_id, type, timestamp, data_json) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(session_id, entry_id) DO UPDATE SET idx=excluded.idx, parent_id=excluded.parent_id, type=excluded.type, timestamp=excluded.timestamp, data_json=excluded.data_json");
+  insertSession.run(header.id, filePath, header.cwd || cwd || "", sessionDir || dirname(filePath), header.timestamp || "", entry.timestamp || header.timestamp || new Date().toISOString(), header.parentSession || null, header.version || null, JSON.stringify(header));
+  insertEntry.run(header.id, typeof entry.id === "string" ? entry.id : String(index ?? 0), Number.isInteger(index) ? index : 0, entry.parentId ?? null, entry.type || null, entry.timestamp || null, JSON.stringify(entry));
+  db.close();
+}
+export function loadEntriesFromDb(filePath) {
+  if (!filePath) return null;
+  try {
+    const db = openDb();
+    const session = db.prepare("SELECT id, header_json FROM sessions WHERE file_path = ?").get(filePath);
+    if (!session) { db.close(); return null; }
+    const entryRows = db.prepare("SELECT data_json FROM entries WHERE session_id = ? ORDER BY idx ASC").all(session.id);
+    db.close();
+    return [JSON.parse(session.header_json), ...entryRows.map((r) => JSON.parse(r.data_json))];
+  } catch { return null; }
+}
+async function buildSessionsFromRows(db, sessionRows, onProgress) {
+  const sessions = [];
+  let loaded = 0;
+  const total = sessionRows.length;
+  for (const row of sessionRows) {
+    try {
+      const entryRows = db.prepare("SELECT data_json FROM entries WHERE session_id = ? ORDER BY idx ASC").all(row.id);
+      let messageCount = 0, firstMessage = "";
+      const allMessages = [];
+      let name;
+      for (const { data_json } of entryRows) {
+        const e = JSON.parse(data_json);
+        if (e.type === "session_info" && e.name?.trim()) name = e.name.trim();
+        if (e.type !== "message") continue;
+        messageCount++;
+        const msg = e.message;
+        if (!msg?.content || (msg.role !== "user" && msg.role !== "assistant")) continue;
+        const text = [].concat(msg.content).filter((p) => p?.type === "text").map((p) => p.text).join(" ").trim();
+        if (!text) continue;
+        allMessages.push(text);
+        if (!firstMessage && msg.role === "user") firstMessage = text;
+      }
+      sessions.push({ path: row.file_path || row.id, id: row.id, cwd: row.cwd || "", name, parentSessionPath: row.parent_session || undefined, created: new Date(row.created_at || 0), modified: new Date(row.updated_at || row.created_at || 0), messageCount, firstMessage: firstMessage || "(no messages)", allMessagesText: allMessages.join(" ") });
+    } catch {}
+    loaded++;
+    onProgress?.(loaded, total);
+  }
+  return sessions;
+}
+export async function listSessionsFromDb(dir, onProgress) {
+  try {
+    const db = openDb();
+    const sessionRows = db.prepare("SELECT id, file_path, cwd, created_at, updated_at, parent_session FROM sessions WHERE session_dir = ? ORDER BY updated_at DESC").all(dir);
+    const sessions = await buildSessionsFromRows(db, sessionRows, onProgress);
+    db.close();
+    return sessions;
+  } catch { return []; }
+}
+export async function listAllSessionsFromDb(onProgress) {
+  try {
+    const db = openDb();
+    const sessionRows = db.prepare("SELECT id, file_path, cwd, created_at, updated_at, parent_session FROM sessions ORDER BY updated_at DESC").all();
+    const sessions = await buildSessionsFromRows(db, sessionRows, onProgress);
+    db.close();
+    return sessions;
+  } catch { return []; }
+}

package/node_modules/@earendil-works/pi-coding-agent/dist/core/project-trust.js

@@ -2,7 +2,7 @@ import { APP_NAME, CONFIG_DIR_NAME } from "../config.js";
 import { emitProjectTrustEvent } from "./extensions/runner.js";
 import { getProjectTrustOptions, hasTrustRequiringProjectResources, } from "./trust-manager.js";
 function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows ${APP_NAME} to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
+    return `Trust project folder?\n${cwd}\n\nThis allows Prism to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
 }
 async function selectProjectTrustOption(cwd, ctx) {
     const options = getProjectTrustOptions(cwd, { includeSessionOnly: true });

package/node_modules/@earendil-works/pi-coding-agent/dist/core/sdk.js

@@ -67,7 +67,7 @@ export async function createAgentSession(options = {}) {
     const cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd());
     const agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir();
     let resourceLoader = options.resourceLoader;
-    const authPath = options.agentDir ? join(agentDir, "auth.json") : undefined;
+    const authPath = process.env.PRISM_AUTH_PATH || process.env.PI_AUTH_PATH || (options.agentDir ? join(agentDir, "auth.json") : undefined);
     const modelsPath = options.agentDir ? join(agentDir, "models.json") : undefined;
     const modelRuntime = options.modelRuntime ?? (await ModelRuntime.create({ authPath, modelsPath }));
     const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/session-manager.js

@@ -3,6 +3,7 @@ import { randomUUID } from "crypto";
 import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
 import { readdir, stat } from "fs/promises";
 import { join, resolve } from "path";
+import { findMostRecentSessionFromDb, getSessionBackend, listAllSessionsFromDb, listSessionsFromDb, loadEntriesFromDb, mirrorEntryToDb, mirrorSessionFileToDb } from "./prism-session-db.js";
 import { createInterface } from "readline";
 import { StringDecoder } from "string_decoder";
 import { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
@@ -634,12 +635,23 @@ export class SessionManager {
                 this._rewriteFile();
             }
             this._buildIndex();
+            if (getSessionBackend() !== "file") { try { mirrorSessionFileToDb(this.sessionFile, this.fileEntries, this.cwd, this.sessionDir); } catch { } }
             this.flushed = true;
         }
         else {
-            const explicitPath = this.sessionFile;
-            this.newSession();
-            this.sessionFile = explicitPath; // preserve explicit path from --session flag
+            const dbEntries = getSessionBackend() !== "file" ? loadEntriesFromDb(this.sessionFile) : null;
+            if (dbEntries) {
+                this.fileEntries = dbEntries;
+                const header = this.fileEntries.find((e) => e.type === "session");
+                this.sessionId = header?.id ?? createSessionId();
+                this._buildIndex();
+                if (getSessionBackend() !== "file") { try { mirrorSessionFileToDb(this.sessionFile, this.fileEntries, this.cwd, this.sessionDir); } catch {} }
+                this.flushed = true;
+            } else {
+                const explicitPath = this.sessionFile;
+                this.newSession();
+                this.sessionFile = explicitPath;
+            }
         }
     }
     newSession(options) {
@@ -693,6 +705,8 @@ export class SessionManager {
     _rewriteFile() {
         if (!this.persist || !this.sessionFile)
             return;
+        if (getSessionBackend() !== "file") { try { mirrorSessionFileToDb(this.sessionFile, this.fileEntries, this.cwd, this.sessionDir); } catch { } }
+        if (getSessionBackend() === "db") return;
         const fd = openSync(this.sessionFile, "w");
         try {
             for (const entry of this.fileEntries) {
@@ -724,30 +738,14 @@ export class SessionManager {
     _persist(entry) {
         if (!this.persist || !this.sessionFile)
             return;
-        const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
-        if (!hasAssistant) {
-            if (this.flushed) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
-            }
-            else {
-                // Mark as not flushed so when assistant arrives, all entries get written
-                this.flushed = false;
-            }
-            return;
-        }
+        // Prism: persist every entry immediately. Pi defers session writes until the
+        // first assistant message, which can lose user prompts if multiple harnesses
+        // run at once or a process exits before the assistant response is recorded.
         if (!this.flushed) {
-            const fd = openSync(this.sessionFile, "wx");
-            try {
-                for (const e of this.fileEntries) {
-                    writeFileSync(fd, `${JSON.stringify(e)}\n`);
-                }
-            }
-            finally {
-                closeSync(fd);
-            }
+            if (getSessionBackend() !== "db") { const fd = openSync(this.sessionFile, "wx"); try { for (const e of this.fileEntries) { writeFileSync(fd, `${JSON.stringify(e)}\n`); } } finally { closeSync(fd); } }
             this.flushed = true;
         }
-        else {
+        else if (getSessionBackend() !== "db") {
             appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
         }
     }
@@ -756,6 +754,7 @@ export class SessionManager {
         this.byId.set(entry.id, entry);
         this.leafId = entry.id;
         this._persist(entry);
+        if (getSessionBackend() !== "file") { try { mirrorEntryToDb(this.sessionFile, this.fileEntries.find((e) => e.type === "session"), entry, this.cwd, this.sessionDir, this.fileEntries.length - 2); } catch { } }
     }
     /** Append a message as child of current leaf, then advance leaf. Returns entry id.
      * Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
@@ -1201,6 +1200,7 @@ export class SessionManager {
                 header = firstEntry?.type === "session" ? firstEntry : null;
             }
         }
+        if (!header && getSessionBackend() !== "file") { try { preloadedFileEntries = loadEntriesFromDb(resolvedPath) ?? undefined; header = preloadedFileEntries?.find((e) => e.type === "session") ?? null; } catch {} }
         const cwd = cwdOverride ?? (header ? getSessionHeaderCwd(header) : undefined) ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
@@ -1214,7 +1214,7 @@ export class SessionManager {
     static continueRecent(cwd, sessionDir) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
-        const mostRecent = findMostRecentSession(dir, filterCwd ? cwd : undefined);
+        const mostRecent = getSessionBackend() === "file" ? findMostRecentSession(dir, filterCwd ? cwd : undefined) : findMostRecentSessionFromDb(dir);
         if (mostRecent) {
             return new SessionManager(cwd, dir, mostRecent, true);
         }
@@ -1234,7 +1234,8 @@ export class SessionManager {
     static forkFrom(sourcePath, targetCwd, sessionDir, options) {
         const resolvedSourcePath = resolvePath(sourcePath);
         const resolvedTargetCwd = resolvePath(targetCwd);
-        const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+        let sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+        if (sourceEntries.length === 0 && getSessionBackend() !== "file") { try { sourceEntries = loadEntriesFromDb(resolvedSourcePath) ?? []; } catch {} }
         if (sourceEntries.length === 0) {
             throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
         }
@@ -1263,12 +1264,10 @@ export class SessionManager {
             cwd: resolvedTargetCwd,
             parentSession: resolvedSourcePath,
         };
-        writeFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`, { flag: "wx" });
-        // Copy all non-header entries from source
-        for (const entry of sourceEntries) {
-            if (entry.type !== "session") {
-                appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
-            }
+        if (getSessionBackend() !== "file") { try { mirrorSessionFileToDb(newSessionFile, [newHeader, ...sourceEntries.filter((e) => e.type !== "session")], resolvedTargetCwd, dir); } catch {} }
+        if (getSessionBackend() !== "db") {
+            writeFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`, { flag: "wx" });
+            for (const entry of sourceEntries) { if (entry.type !== "session") appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`); }
         }
         return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
@@ -1280,11 +1279,14 @@ export class SessionManager {
      */
     static async list(cwd, sessionDir, onProgress) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
-        const resolvedCwd = resolvePath(cwd);
-        const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
-        sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-        return sessions;
+        if (getSessionBackend() === "file") {
+            const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+            const resolvedCwd = resolvePath(cwd);
+            const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
+            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+            return sessions;
+        }
+        return listSessionsFromDb(dir, onProgress);
     }
     static async listAll(sessionDirOrOnProgress, onProgress) {
         const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/system-prompt.js

@@ -1,7 +1,8 @@
 /**
  * System prompt construction and project context loading
  */
-import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { formatSkillsForPrompt } from "./skills.js";
 /** Build the system prompt with tools, guidelines, and context */
 export function buildSystemPrompt(options) {
@@ -32,10 +33,22 @@ export function buildSystemPrompt(options) {
         prompt += `\nCurrent working directory: ${promptCwd}\n`;
         return prompt;
     }
-    // Get absolute paths to documentation and examples
-    const readmePath = getReadmePath();
-    const docsPath = getDocsPath();
-    const examplesPath = getExamplesPath();
+    // Get absolute paths to project documentation and examples.
+    // Only project docs are advertised here. Harness/pi docs can be linked into the project docs
+    // tree (for example docs/pi) when a project wants them in the prompt.
+    const resolvedCwd = cwd;
+    const existingPath = (filePath) => existsSync(filePath) ? filePath : undefined;
+    const firstExistingPath = (filePaths) => filePaths.find((filePath) => existsSync(filePath));
+    const projectReadmePath = firstExistingPath(["README.md", "README.MD", "readme.md"].map((name) => join(resolvedCwd, name)));
+    const projectDocsPath = existingPath(join(resolvedCwd, "docs"));
+    const projectExamplesPath = existingPath(join(resolvedCwd, "examples"));
+    const documentationLines = [];
+    if (projectReadmePath) documentationLines.push(`- Main documentation: ${projectReadmePath}`);
+    if (projectDocsPath) documentationLines.push(`- Additional docs: ${projectDocsPath}`);
+    if (projectExamplesPath) documentationLines.push(`- Examples: ${projectExamplesPath}`);
+    if (projectDocsPath || projectExamplesPath) documentationLines.push("- When reading these docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory");
+    if (projectDocsPath) documentationLines.push("- When working on this project, read the relevant docs and follow .md cross-references before implementing");
+    const documentationSection = documentationLines.length > 0 ? `\n\nProject documentation (read only when relevant):\n${documentationLines.join("\n")}` : "";
     // Build tools list based on selected tools.
     // A tool appears in Available tools only when the caller provides a one-line snippet.
     const tools = selectedTools || ["read", "bash", "edit", "write"];
@@ -70,7 +83,7 @@ export function buildSystemPrompt(options) {
     addGuideline("Be concise in your responses");
     addGuideline("Show file paths clearly when working with files");
     const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
-    let prompt = `You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+    let prompt = `You are an expert coding assistant operating inside prism, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
 
 Available tools:
 ${toolsList}
@@ -78,16 +91,7 @@ ${toolsList}
 In addition to the tools above, you may have access to other custom tools depending on the project.
 
 Guidelines:
-${guidelines}
-
-Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
-- Main documentation: ${readmePath}
-- Additional docs: ${docsPath}
-- Examples: ${examplesPath} (extensions, custom tools, SDK)
-- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
-- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md), environment variables (docs/environment-variables.md)
-- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
-- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+${guidelines}${documentationSection}`;
     if (appendSection) {
         prompt += appendSection;
     }

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/session-selector.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { deleteSessionFromDb } from "../../../core/prism-session-db.js";
 import { existsSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import * as os from "node:os";
@@ -539,6 +540,9 @@ class SessionList {
  * Delete a session file, trying the `trash` CLI first, then falling back to unlink
  */
 async function deleteSessionFile(sessionPath) {
+    const _backend = process.env.PRISM_SESSION_BACKEND || "db";
+    if (_backend !== "file") { try { deleteSessionFromDb(sessionPath); } catch {} }
+    if (_backend === "db" && !existsSync(sessionPath)) return { ok: true, method: "trash" };
     // Try `trash` first (if installed)
     const trashArgs = sessionPath.startsWith("-") ? ["--", sessionPath] : [sessionPath];
     const trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" });

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/interactive-mode.js

@@ -484,12 +484,15 @@ export class InteractiveMode {
         }));
         // Convert extension commands to SlashCommand format
         const builtinCommandNames = new Set(slashCommands.map((c) => c.name));
+        const prismInternalCommandExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "voice-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "honcho-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter"]);
+        const prismInternalCommandNpmPackages = new Set(["pi-mcp-adapter"]);
+        const isPrismInternalCommand = (cmd) => (() => { const prismExtensionPath = String(cmd.sourceInfo?.path || "").replaceAll("\\", "/"); const prismExtensionSource = String(cmd.sourceInfo?.source || ""); return prismInternalCommandExtensions.has(path.basename(prismExtensionPath)) || Array.from(prismInternalCommandNpmPackages).some((pkg) => prismExtensionSource === "npm:" + pkg || prismExtensionPath.includes("/node_modules/" + pkg + "/")); })();
         const extensionCommands = this.session.extensionRunner
             .getRegisteredCommands()
             .filter((cmd) => !builtinCommandNames.has(cmd.name))
             .map((cmd) => ({
             name: cmd.invocationName,
-            description: this.prefixAutocompleteDescription(cmd.description, cmd.sourceInfo),
+            description: isPrismInternalCommand(cmd) ? cmd.description : this.prefixAutocompleteDescription(cmd.description, cmd.sourceInfo),
             getArgumentCompletions: cmd.getArgumentCompletions,
         }));
         // Build skill commands from session.skills (if enabled)
@@ -676,7 +679,7 @@ export class InteractiveMode {
         await this.themeController.applyFromSettings();
         // Add header with keybindings from config (unless silenced)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
-            const logo = theme.bold(theme.fg("accent", APP_NAME)) + theme.fg("dim", ` v${this.version}`);
+            const logo = "▲ \u001b[38;5;196mp\u001b[38;5;202mr\u001b[38;5;226mi\u001b[38;5;46ms\u001b[38;5;51mm\u001b[0m v0.2.92";
             // Build startup instructions using keybinding hint helpers
             const hint = (keybinding, description) => keyHint(keybinding, description);
             const expandedInstructions = [
@@ -708,7 +711,7 @@ export class InteractiveMode {
                 hint("app.tools.expand", "more"),
             ].join(theme.fg("muted", " · "));
             const compactOnboarding = theme.fg("dim", `Press ${keyText("app.tools.expand")} to show full startup help and loaded resources.`);
-            const onboarding = theme.fg("dim", `Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.`);
+            const onboarding = theme.fg("dim", `Prism can explain its own features and look up its docs. Ask it how to use or extend Prism.`);
             this.builtInHeader = new ExpandableText(() => `${logo}\n${compactInstructions}\n${compactOnboarding}\n\n${onboarding}`, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
             // Setup UI layout
             this.headerContainer.addChild(new Spacer(1));
@@ -757,10 +760,10 @@ export class InteractiveMode {
         const cwdBasename = path.basename(this.sessionManager.getCwd());
         const sessionName = this.sessionManager.getSessionName();
         if (sessionName) {
-            this.ui.terminal.setTitle(`${APP_TITLE} - ${sessionName} - ${cwdBasename}`);
+            this.ui.terminal.setTitle(`▲ - ${sessionName} - ${cwdBasename}`);
         }
         else {
-            this.ui.terminal.setTitle(`${APP_TITLE} - ${cwdBasename}`);
+            this.ui.terminal.setTitle(`▲ - ${cwdBasename}`);
         }
     }
     /**
@@ -823,6 +826,7 @@ export class InteractiveMode {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                errorMessage = this.humanizeUsageLimitError(errorMessage);
                 this.showError(errorMessage);
             }
         }
@@ -833,7 +837,8 @@ export class InteractiveMode {
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-                    this.showError(errorMessage);
+                    errorMessage = this.humanizeUsageLimitError(errorMessage);
+                this.showError(errorMessage);
                 }
             }
         }
@@ -845,6 +850,7 @@ export class InteractiveMode {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                errorMessage = this.humanizeUsageLimitError(errorMessage);
                 this.showError(errorMessage);
             }
         }
@@ -921,14 +927,19 @@ export class InteractiveMode {
         const entries = parseChangelog(changelogPath);
         if (!lastVersion) {
             // Fresh install - record the version, send telemetry, don't show changelog
-            this.settingsManager.setLastChangelogVersion(VERSION);
-            this.reportInstallTelemetry(VERSION);
+            this.settingsManager.setLastChangelogVersion("0.84.2");
+            this.reportInstallTelemetry("0.84.2");
             return undefined;
         }
         const newEntries = getNewEntries(entries, lastVersion);
+        if (entries.length > 0 && newEntries.length === entries.length) {
+            this.settingsManager.setLastChangelogVersion("0.84.2");
+            this.reportInstallTelemetry("0.84.2");
+            return normalizeChangelogLinks(entries[0].content, entries[0]);
+        }
         if (newEntries.length > 0) {
-            this.settingsManager.setLastChangelogVersion(VERSION);
-            this.reportInstallTelemetry(VERSION);
+            this.settingsManager.setLastChangelogVersion("0.84.2");
+            this.reportInstallTelemetry("0.84.2");
             return newEntries.map((e) => normalizeChangelogLinks(e.content, e)).join("\n\n");
         }
         return undefined;
@@ -1266,7 +1277,7 @@ export class InteractiveMode {
         const skillsResult = this.session.resourceLoader.getSkills();
         const promptsResult = this.session.resourceLoader.getPrompts();
         const themesResult = this.session.resourceLoader.getThemes();
-        const extensions = options?.extensions ??
+        let extensions = options?.extensions ??
             this.session.resourceLoader
                 .getExtensions()
                 .extensions.filter((extension) => !extension.hidden)
@@ -1337,6 +1348,9 @@ export class InteractiveMode {
                 const promptCompactList = formatCompactList(templates.map((template) => `/${template.name}`));
                 addLoadedSection("Prompts", promptCompactList, templateList);
             }
+            const prismInternalExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "voice-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "honcho-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter"]);
+            const prismInternalNpmPackages = new Set(["pi-mcp-adapter"]);
+            extensions = extensions.filter((extension) => !(() => { const prismExtensionPath = String(extension.path || "").replaceAll("\\", "/"); const prismExtensionSource = String(extension.sourceInfo?.source || ""); return prismInternalExtensions.has(path.basename(prismExtensionPath)) || Array.from(prismInternalNpmPackages).some((pkg) => prismExtensionSource === "npm:" + pkg || prismExtensionPath.includes("/node_modules/" + pkg + "/")); })());
             if (extensions.length > 0) {
                 const groups = this.buildScopeGroups(extensions);
                 const extList = this.formatScopeGroups(groups, {
@@ -1348,7 +1362,8 @@ export class InteractiveMode {
             }
             // Show loaded themes (excluding built-in)
             const loadedThemes = themesResult.themes;
-            const customThemes = loadedThemes.filter((t) => t.sourcePath);
+            const prismInternalThemes = new Set(["soft-green"]);
+            const customThemes = loadedThemes.filter((t) => t.sourcePath && !prismInternalThemes.has(t.name));
             if (customThemes.length > 0) {
                 const groups = this.buildScopeGroups(customThemes.map((loadedTheme) => ({
                     path: loadedTheme.sourcePath,
@@ -2428,6 +2443,27 @@ export class InteractiveMode {
                 await this.handleCompactCommand(customInstructions);
                 return;
             }
+            if (text === "/plan" || text.startsWith("/plan ")) {
+                const task = text.startsWith("/plan ") ? text.slice(6).trim() : "";
+                this.editor.setText("");
+                await this.startPrismPlanMode(task);
+                return;
+            }
+            if (text === "/plan:approve") {
+                this.editor.setText("");
+                await this.approvePrismPlan();
+                return;
+            }
+            if (text === "/plan:reject") {
+                this.editor.setText("");
+                this.rejectPrismPlan();
+                return;
+            }
+            if (text === "/plan:cancel") {
+                this.editor.setText("");
+                this.cancelPrismPlan();
+                return;
+            }
             if (text === "/reload") {
                 this.editor.setText("");
                 await this.handleReloadCommand();
@@ -2692,6 +2728,8 @@ export class InteractiveMode {
                 break;
             case "agent_settled":
                 await this.checkShutdownRequested();
+                void this.maybeShowUsageLimitRecoveryMenu(event);
+                void this.maybeShowPrismPlanApprovalMenu(event);
                 break;
             case "compaction_start": {
                 if (this.settingsManager.getShowTerminalProgress()) {
@@ -2790,6 +2828,189 @@ export class InteractiveMode {
             }
         }
     }
+    formatUsageLimitDuration(ms) {
+        const totalMinutes = Math.ceil(ms / 60000);
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        const parts = [];
+        if (hours > 0) parts.push(hours + "h");
+        if (minutes > 0 || parts.length === 0) parts.push(minutes + "min");
+        return parts.join(" ");
+    }
+    humanizeUsageLimitError(errorMessage) {
+        return String(errorMessage || "").replace(/(~|about\s*)?(\d+)\s*min\b/gi, (_match, prefix, minutes) => {
+            return (prefix || "") + this.formatUsageLimitDuration(Number(minutes) * 60 * 1000);
+        });
+    }
+    extractUsageLimitWaitMs(errorMessage) {
+        const text = String(errorMessage || "");
+        const parsedSeconds = text.match(/"(?:resets_in_seconds|X-Codex-Primary-Reset-After-Seconds|Retry-After)"\s*:?\s*"?(\d+)"?/i)?.[1];
+        if (parsedSeconds) return Number(parsedSeconds) * 1000;
+        const resetAt = text.match(/"(?:resets_at|X-Codex-Primary-Reset-At)"\s*:?\s*"?(\d+)"?/i)?.[1];
+        if (resetAt) {
+            const resetMs = Number(resetAt) * 1000 - Date.now();
+            if (Number.isFinite(resetMs) && resetMs > 0) return resetMs;
+        }
+        const hours = text.match(/(?:~|about\s*)?(\d+)\s*h(?:our)?/i)?.[1];
+        if (hours) return Number(hours) * 60 * 60 * 1000;
+        const minutes = text.match(/(?:~|about\s*)?(\d+)\s*min/i)?.[1];
+        if (minutes) return Number(minutes) * 60 * 1000;
+        const seconds = text.match(/(?:~|about\s*)?(\d+)\s*s(?:ec|econd)?/i)?.[1];
+        if (seconds) return Number(seconds) * 1000;
+        return 5 * 60 * 1000;
+    }
+    getUsageLimitError(event) {
+        const last = event?.messages?.[event.messages.length - 1];
+        let errorMessage = last?.errorMessage || last?.content?.find?.((block) => block?.type === "text")?.text || "";
+        if (last?.role !== "assistant" || last?.stopReason !== "error") return undefined;
+        errorMessage = this.humanizeUsageLimitError(errorMessage);
+        return /usage limit|try again in/i.test(errorMessage) ? String(errorMessage) : undefined;
+    }
+    removeLastAssistantErrorFromState() {
+        const messages = this.agent.state.messages;
+        const last = messages[messages.length - 1];
+        if (last?.role === "assistant" && last?.stopReason === "error") this.agent.state.messages = messages.slice(0, -1);
+    }
+    async continueAfterUsageLimitRecovery() {
+        try {
+            await this.agent.continue();
+        } catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    maybeShowUsageLimitRecoveryMenu(event) {
+        const errorMessage = this.getUsageLimitError(event);
+        if (!errorMessage) return;
+        const delayMs = this.extractUsageLimitWaitMs(errorMessage);
+        const waitLabel = "Wait " + this.formatUsageLimitDuration(delayMs) + " then retry";
+        this.showSelector((done) => {
+            const selector = new ExtensionSelectorComponent("Usage limit hit", [waitLabel, "Change model and retry", "Cancel"], async (selected) => {
+                done();
+                if (selected === "Cancel") return;
+                this.removeLastAssistantErrorFromState();
+                if (selected === waitLabel) {
+                    const endTime = Date.now() + delayMs;
+                    const updateCountdown = () => {
+                        const remaining = Math.max(0, endTime - Date.now());
+                        this.showStatus("Waiting " + this.formatUsageLimitDuration(remaining) + " for usage limit, then retrying...");
+                        this.ui.requestRender();
+                    };
+                    updateCountdown();
+                    const countdownInterval = setInterval(updateCountdown, 60000);
+                    setTimeout(() => { clearInterval(countdownInterval); void this.continueAfterUsageLimitRecovery(); }, delayMs);
+                    return;
+                }
+                this.showUsageLimitModelSelector();
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, { tui: this.ui });
+            return { component: selector, focus: selector };
+        });
+    }
+    showUsageLimitModelSelector(initialSearchInput) {
+        this.showSelector((done) => {
+            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
+                try {
+                    await this.session.setModel(model);
+                    this.footer.invalidate();
+                    this.updateEditorBorderColor();
+                    done();
+                    this.showStatus("Model: " + model.id + "; retrying...");
+                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
+                    this.checkDaxnutsEasterEgg(model);
+                    void this.continueAfterUsageLimitRecovery();
+                } catch (error) {
+                    done();
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, initialSearchInput);
+            return { component: selector, focus: selector };
+        });
+    }
+    getPrismReadOnlyToolNames() {
+        const readOnly = new Set(["read", "grep", "find", "ls", "obsidian_memory_read", "obsidian_memory_search", "obsidian_memory_list", "web_search", "web_fetch"]);
+        return this.session.getActiveToolNames().filter((name) => readOnly.has(name));
+    }
+    setPrismPlanStatus(enabled) {
+        this.prismPlanMode = enabled;
+        this.setExtensionStatus("prism-mode", enabled ? "[Plan]" : undefined);
+        this.footer.invalidate();
+    }
+    async startPrismPlanMode(task) {
+        if (!this.prismPlanPreviousTools) this.prismPlanPreviousTools = this.session.getActiveToolNames();
+        if (this.prismPlanLeafId === undefined) this.prismPlanLeafId = this.session.sessionManager.getLeafId();
+        this.session.setActiveToolsByName(this.getPrismReadOnlyToolNames());
+        this.setPrismPlanStatus(true);
+        globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = "plan";
+        const prompt = "PLAN MODE ACTIVE. You must only inspect and plan. Do not modify files or run mutating commands. Ask concise clarification questions if needed. When ready, write the full implementation plan, then end with exactly: /plan:ready\n\nTask: " + (task || "Create an implementation plan for the user's next change.");
+        await this.session.prompt(prompt);
+    }
+    getPrismLastAssistantText(event) {
+        const last = event?.messages?.[event.messages.length - 1];
+        if (last?.role !== "assistant") return "";
+        return (last.content || []).map((block) => block?.type === "text" ? block.text || "" : "").join("\n");
+    }
+    maybeShowPrismPlanApprovalMenu(event) {
+        if (!this.prismPlanMode) return;
+        const text = this.getPrismLastAssistantText(event);
+        if (!text.includes("/plan:ready")) return;
+        this.prismPlanText = text.replace("/plan:ready", "").trim();
+        this.showSelector((done) => {
+            const selector = new ExtensionSelectorComponent("Plan ready", ["Approve -> make changes", "Reject -> add more context", "Cancel plan"], async (selected) => {
+                done();
+                if (selected.startsWith("Approve")) return void this.approvePrismPlan();
+                if (selected.startsWith("Reject")) return this.rejectPrismPlan();
+                this.cancelPrismPlan();
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, { tui: this.ui });
+            return { component: selector, focus: selector };
+        });
+    }
+    restorePrismPlanTools() {
+        if (this.prismPlanPreviousTools) this.session.setActiveToolsByName(this.prismPlanPreviousTools);
+        this.prismPlanPreviousTools = undefined;
+        if (globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ === "plan") globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = undefined;
+        this.setPrismPlanStatus(false);
+    }
+    restorePrismPlanBranch() {
+        if (this.prismPlanLeafId === undefined) return;
+        if (this.prismPlanLeafId === null) {
+            this.session.sessionManager.resetLeaf();
+        } else {
+            this.session.sessionManager.branch(this.prismPlanLeafId);
+        }
+        this.agent.state.messages = this.session.sessionManager.buildSessionContext().messages;
+        this.prismPlanLeafId = undefined;
+    }
+    async approvePrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to approve.");
+        const planText = this.prismPlanText || "";
+        this.prismPlanText = undefined;
+        this.restorePrismPlanBranch();
+        this.restorePrismPlanTools();
+        await this.session.prompt("Implement this plan:\n\n" + planText);
+    }
+    rejectPrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to reject.");
+        this.prismPlanText = undefined;
+        this.editor.setText("/plan ");
+        this.showStatus("Add more context after /plan and submit.");
+        this.ui.requestRender();
+    }
+    cancelPrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to cancel.");
+        this.restorePrismPlanBranch();
+        this.prismPlanText = undefined;
+        this.restorePrismPlanTools();
+        this.showStatus("Plan cancelled");
+        this.ui.requestRender();
+    }
     /** Extract text content from a user message */
     getUserMessageText(message) {
         if (message.role !== "user")

package/node_modules/@earendil-works/pi-tui/dist/autocomplete.js

@@ -202,7 +202,7 @@ export class CombinedAutocompleteProvider {
                 prefix: atPrefix,
             };
         }
-        if (!options.force && textBeforeCursor.startsWith("/")) {
+        if (textBeforeCursor.startsWith("/")) {
             const spaceIndex = textBeforeCursor.indexOf(" ");
             if (spaceIndex === -1) {
                 const prefix = textBeforeCursor.slice(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daniel156161/prism",
-  "version": "0.2.90",
+  "version": "0.2.92",
   "description": "Prism-branded wrapper around pi that stores config in ~/.prism",
   "type": "module",
   "engines": {
@@ -27,9 +27,7 @@
   "dependencies": {
     "@earendil-works/pi-ai": "^0.84.2",
     "@earendil-works/pi-coding-agent": "^0.84.2",
-    "eventsource": "^5.1.0",
     "pi-mcp-adapter": "^2.26.0",
-    "pkce-challenge": "^6.0.0",
     "typebox": "^1.3.14"
   },
   "bundledDependencies": [