@pi-unipi/unipi 2.4.1 → 2.5.0

package/packages/unipi/bundled.js

@@ -327,7 +327,7 @@ var init_events = __esm({
     UNIPI_EVENTS = {
       /** Module loaded and ready */
       MODULE_READY: "unipi:module:ready",
-      /** Module unloading */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       MODULE_GONE: "unipi:module:gone",
       /** Workflow command started */
       WORKFLOW_START: "unipi:workflow:start",
@@ -339,9 +339,9 @@ var init_events = __esm({
       RALPH_LOOP_END: "unipi:ralph:loop:end",
       /** Ralph loop iteration completed */
       RALPH_ITERATION_DONE: "unipi:ralph:iteration:done",
-      /** Request module status (for info-screen) */
+      /** @deprecated No built-in responders; use the info registry and /unipi:info. */
       MODULE_STATUS_REQUEST: "unipi:module:status:request",
-      /** Module status response */
+      /** @deprecated No built-in aggregator; use the info registry and /unipi:info. */
       MODULE_STATUS_RESPONSE: "unipi:module:status:response",
       /** Info screen group registered */
       INFO_GROUP_REGISTERED: "unipi:info:group:registered",
@@ -351,7 +351,7 @@ var init_events = __esm({
       MEMORY_STORED: "unipi:memory:stored",
       /** Memory deleted */
       MEMORY_DELETED: "unipi:memory:deleted",
-      /** Memory search performed */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       MEMORY_SEARCHED: "unipi:memory:searched",
       /** Memory consolidation completed */
       MEMORY_CONSOLIDATED: "unipi:memory:consolidated",
@@ -369,9 +369,9 @@ var init_events = __esm({
       MCP_CATALOG_SYNCED: "unipi:mcp:catalog:synced",
       /** Compactor: compaction completed */
       COMPACTOR_COMPACTED: "unipi:compactor:compacted",
-      /** Compactor: stats updated */
+      /** @deprecated Footer reads live Pi session data; retained for compatibility. */
       COMPACTOR_STATS_UPDATED: "unipi:compactor:stats:updated",
-      /** Utility module cleanup started */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_CLEANUP_START: "unipi:utility:cleanup:start",
       /** Utility module cleanup completed */
       UTILITY_CLEANUP_DONE: "unipi:utility:cleanup:done",
@@ -379,9 +379,9 @@ var init_events = __esm({
       UTILITY_DIAGNOSTICS_START: "unipi:utility:diagnostics:start",
       /** Utility diagnostics completed */
       UTILITY_DIAGNOSTICS_DONE: "unipi:utility:diagnostics:done",
-      /** Utility cache invalidated */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_CACHE_INVALIDATED: "unipi:utility:cache:invalidated",
-      /** Utility lifecycle state changed */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_LIFECYCLE_STATE: "unipi:utility:lifecycle:state",
       /** Notification sent */
       NOTIFICATION_SENT: "unipi:notify:sent",
@@ -397,11 +397,11 @@ var init_events = __esm({
       UPDATE_APPLIED: "unipi:update:applied",
       /** Update error */
       UPDATE_ERROR: "unipi:update:error",
-      /** CocoIndex: update started */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_UPDATE_STARTED: "unipi:cocoindex:update:started",
-      /** CocoIndex: update completed */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_UPDATE_COMPLETED: "unipi:cocoindex:update:completed",
-      /** CocoIndex: search performed */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_SEARCH_PERFORMED: "unipi:cocoindex:search:performed"
     };
   }
@@ -868,12 +868,40 @@ var init_core = __esm({
 
 // packages/memory/mempalace.ts
 import { spawnSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
 import * as os from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-function dirname5(p) {
-  return path4.dirname(p);
+function isReadableFile(candidate) {
+  try {
+    return fs4.statSync(candidate).isFile() && fs4.accessSync(candidate, fs4.constants.R_OK) === void 0;
+  } catch {
+    return false;
+  }
+}
+function resolveMempalaceBridgePath(moduleUrl = import.meta.url) {
+  const moduleDir = path4.dirname(fileURLToPath3(moduleUrl));
+  const candidates = [];
+  if (process.env.UNIPI_MEMPALACE_BRIDGE) {
+    candidates.push(path4.resolve(process.env.UNIPI_MEMPALACE_BRIDGE));
+  }
+  candidates.push(
+    path4.join(moduleDir, "bridge", "mempalace_bridge.py"),
+    path4.join(moduleDir, "..", "memory", "bridge", "mempalace_bridge.py")
+  );
+  try {
+    const require2 = createRequire(moduleUrl);
+    const memoryPackage = require2.resolve("@pi-unipi/memory/package.json");
+    candidates.push(path4.join(path4.dirname(memoryPackage), "bridge", "mempalace_bridge.py"));
+  } catch {
+  }
+  return candidates.find(isReadableFile) ?? null;
+}
+function getBridgePath() {
+  if (cachedBridgePath === void 0) cachedBridgePath = resolveMempalaceBridgePath();
+  return cachedBridgePath;
 }
 function which(bin) {
   try {
@@ -973,17 +1001,71 @@ function invalidatePingVerified() {
   } catch {
   }
 }
-function isMigrated() {
-  return fs4.existsSync(MIGRATED_FLAG);
+function getMemorySourceFingerprint(sourceDir = path4.join(os.homedir(), ".unipi", "memory")) {
+  const hash = createHash("sha256");
+  if (!fs4.existsSync(sourceDir)) return hash.update("missing").digest("hex");
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch {
+      hash.update(`unreadable:${dir}`);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(full);
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== "memory.db" && !entry.name.endsWith(".md")) continue;
+      try {
+        const stat = fs4.statSync(full);
+        hash.update(`${path4.relative(sourceDir, full)}\0${stat.size}\0${stat.mtimeMs}
+`);
+      } catch {
+        hash.update(`unreadable:${path4.relative(sourceDir, full)}
+`);
+      }
+    }
+  };
+  visit(sourceDir);
+  return hash.digest("hex");
 }
-function markMigrated() {
+function readMigrationState(flagPath = MIGRATED_FLAG) {
   try {
-    fs4.mkdirSync(path4.dirname(MIGRATED_FLAG), { recursive: true });
-    fs4.writeFileSync(MIGRATED_FLAG, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+    const parsed = JSON.parse(fs4.readFileSync(flagPath, "utf-8"));
+    if (parsed?.version !== MIGRATION_STATE_VERSION || typeof parsed.completedAt !== "string" || typeof parsed.sourceFingerprint !== "string" || !parsed.result || parsed.result.failed !== 0 || parsed.result.verified !== parsed.result.discovered) return null;
+    return parsed;
   } catch {
+    return null;
   }
 }
-function runBridge(install, palace, cmd, args = {}) {
+function isMigrated(sourceFingerprint = getMemorySourceFingerprint(), flagPath = MIGRATED_FLAG) {
+  return readMigrationState(flagPath)?.sourceFingerprint === sourceFingerprint;
+}
+function markMigrated(sourceFingerprint, result, flagPath = MIGRATED_FLAG) {
+  if (result.failed !== 0 || result.verified !== result.discovered) return false;
+  try {
+    fs4.mkdirSync(path4.dirname(flagPath), { recursive: true });
+    const state = {
+      version: MIGRATION_STATE_VERSION,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceFingerprint,
+      result
+    };
+    const temp = `${flagPath}.${process.pid}.tmp`;
+    fs4.writeFileSync(temp, JSON.stringify(state, null, 2), "utf-8");
+    fs4.renameSync(temp, flagPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runBridge(install, palace, cmd, args = {}, timeoutMs = 6e4) {
+  const bridgePath = getBridgePath();
+  if (!bridgePath) return null;
   let argsJson;
   try {
     argsJson = JSON.stringify(args);
@@ -992,9 +1074,9 @@ function runBridge(install, palace, cmd, args = {}) {
   }
   let res;
   try {
-    res = spawnSync(install.python, [BRIDGE_PATH, palace, cmd, argsJson], {
+    res = spawnSync(install.python, [bridgePath, palace, cmd, argsJson], {
       encoding: "utf-8",
-      timeout: 6e4,
+      timeout: timeoutMs,
       maxBuffer: 64 * 1024 * 1024
     });
   } catch {
@@ -1013,22 +1095,27 @@ function runBridge(install, palace, cmd, args = {}) {
     return null;
   }
 }
-function runBridgeAsync(install, palace, cmd, args = {}) {
-  return new Promise((resolve13) => {
+function runBridgeAsync(install, palace, cmd, args = {}, timeoutMs = 6e4) {
+  return new Promise((resolve14) => {
+    const bridgePath = getBridgePath();
+    if (!bridgePath) {
+      resolve14(null);
+      return;
+    }
     let argsJson;
     try {
       argsJson = JSON.stringify(args);
     } catch {
-      resolve13(null);
+      resolve14(null);
       return;
     }
     let child;
     try {
-      child = spawn(install.python, [BRIDGE_PATH, palace, cmd, argsJson], {
+      child = spawn(install.python, [bridgePath, palace, cmd, argsJson], {
         stdio: ["ignore", "pipe", "ignore"]
       });
     } catch {
-      resolve13(null);
+      resolve14(null);
       return;
     }
     let out = "";
@@ -1037,7 +1124,7 @@ function runBridgeAsync(install, palace, cmd, args = {}) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve13(value);
+      resolve14(value);
     };
     const timer = setTimeout(() => {
       try {
@@ -1045,7 +1132,7 @@ function runBridgeAsync(install, palace, cmd, args = {}) {
       } catch {
       }
       finish(null);
-    }, 6e4);
+    }, timeoutMs);
     timer.unref?.();
     child.stdout?.setEncoding("utf-8");
     child.stdout?.on("data", (chunk) => {
@@ -1065,7 +1152,7 @@ function runBridgeAsync(install, palace, cmd, args = {}) {
     });
   });
 }
-var DEFAULT_PALACE, INSTALL_FLAG, MIGRATED_FLAG, PING_VERIFIED_FLAG, PING_VERIFIED_TTL_MS, BRIDGE_PATH;
+var DEFAULT_PALACE, INSTALL_FLAG, MIGRATED_FLAG, PING_VERIFIED_FLAG, PING_VERIFIED_TTL_MS, MIGRATION_STATE_VERSION, cachedBridgePath;
 var init_mempalace = __esm({
   "packages/memory/mempalace.ts"() {
     "use strict";
@@ -1074,7 +1161,7 @@ var init_mempalace = __esm({
     MIGRATED_FLAG = path4.join(os.homedir(), ".unipi", "memory", ".mempalace-migrated");
     PING_VERIFIED_FLAG = path4.join(os.homedir(), ".unipi", "memory", ".mempalace-ping-verified");
     PING_VERIFIED_TTL_MS = 24 * 60 * 60 * 1e3;
-    BRIDGE_PATH = path4.join(dirname5(fileURLToPath3(import.meta.url)), "bridge", "mempalace_bridge.py");
+    MIGRATION_STATE_VERSION = 2;
   }
 });
 
@@ -1174,7 +1261,7 @@ function parseMemoryContent(content) {
   const [, frontmatterStr, body] = match;
   const frontmatter = yaml.load(frontmatterStr);
   return {
-    id: "",
+    id: frontmatter.id || "",
     title: frontmatter.title,
     content: body.trim(),
     tags: frontmatter.tags || [],
@@ -1186,6 +1273,7 @@ function parseMemoryContent(content) {
 }
 function writeMemoryFile(filePath, record) {
   const frontmatter = {
+    id: record.id,
     title: record.title,
     tags: record.tags,
     project: record.project,
@@ -1405,12 +1493,15 @@ var init_storage = __esm({
         }
         this.mempalaceInstall = install;
         this.backend = "mempalace";
-        if (!isMigrated()) {
+        const sourceFingerprint = getMemorySourceFingerprint(getMemoryBaseDir());
+        if (!isMigrated(sourceFingerprint)) {
           try {
-            runBridge(install, this.palacePath, "migrate", {
+            const result = runBridge(install, this.palacePath, "migrate", {
               source_dir: getMemoryBaseDir()
-            });
-            markMigrated();
+            }, 15 * 6e4);
+            if (result && result.failed === 0 && result.verified === result.discovered) {
+              markMigrated(sourceFingerprint, result);
+            }
           } catch {
           }
         }
@@ -1457,21 +1548,6 @@ var init_storage = __esm({
           this.db = null;
         }
       }
-      /**
-       * Remove corrupted database files (db, wal, shm).
-       */
-      removeCorruptedDb() {
-        const dbPath = path5.join(this.scopeDir, MEMORY_DB_NAME);
-        const files = [dbPath, `${dbPath}-wal`, `${dbPath}-shm`];
-        for (const file of files) {
-          try {
-            if (fs5.existsSync(file)) {
-              fs5.unlinkSync(file);
-            }
-          } catch {
-          }
-        }
-      }
       /**
        * Check if database is healthy.
        */
@@ -1612,7 +1688,7 @@ ${record.content}
           const filePath = path5.join(this.scopeDir, file);
           const record = parseMemoryFile(filePath);
           if (!record) continue;
-          const id = record.title.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+          const id = record.id || record.title.toLowerCase().replace(/[^a-z0-9]+/g, "_");
           if (existingIds.has(id)) continue;
           try {
             record.id = id;
@@ -2254,8 +2330,8 @@ var init_embedding = __esm({
 });
 
 // packages/info-screen/usage-parser.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync4, existsSync as existsSync9, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8, renameSync as renameSync2, openSync, readSync, closeSync } from "node:fs";
-import { join as join9, dirname as dirname10 } from "node:path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, existsSync as existsSync9, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8, renameSync as renameSync3, openSync, readSync, closeSync } from "node:fs";
+import { join as join9, dirname as dirname9 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function getCachePath() {
   const base = process.env.UNIPI_DIR || join9(homedir5(), ".unipi");
@@ -2277,10 +2353,10 @@ function readCache() {
 function writeCache(cache) {
   try {
     const path28 = getCachePath();
-    mkdirSync7(dirname10(path28), { recursive: true });
+    mkdirSync7(dirname9(path28), { recursive: true });
     const tmp = `${path28}.${process.pid}.tmp`;
     writeFileSync8(tmp, JSON.stringify(cache), "utf-8");
-    renameSync2(tmp, path28);
+    renameSync3(tmp, path28);
   } catch {
   }
 }
@@ -2376,7 +2452,7 @@ function extractRecords(filePath, modelIndex, models) {
 }
 function collectSessionFiles(dir, files) {
   try {
-    const entries = readdirSync4(dir, { withFileTypes: true });
+    const entries = readdirSync5(dir, { withFileTypes: true });
     for (const entry of entries) {
       const entryPath = join9(dir, entry.name);
       if (entry.isDirectory()) {
@@ -2390,7 +2466,7 @@ function collectSessionFiles(dir, files) {
 }
 async function parseUsageStatsAsync() {
   const yielder = async () => {
-    await new Promise((resolve13) => setImmediate(resolve13));
+    await new Promise((resolve14) => setImmediate(resolve14));
   };
   const { stats, pending } = collectStats(yielder);
   if (pending) await pending;
@@ -2426,7 +2502,7 @@ function collectStats(yielder) {
     let mtimeMs = 0;
     let size = 0;
     try {
-      const st = statSync4(filePath);
+      const st = statSync5(filePath);
       mtimeMs = st.mtimeMs;
       size = st.size;
     } catch {
@@ -2607,19 +2683,19 @@ __export(env_exports, {
   formatEnvironmentInfo: () => formatEnvironmentInfo,
   getEnvironmentInfo: () => getEnvironmentInfo
 });
-import { existsSync as existsSync18, readdirSync as readdirSync10 } from "node:fs";
-import { join as join18, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync18, readdirSync as readdirSync11 } from "node:fs";
+import { join as join18, resolve as resolve6 } from "node:path";
 import { homedir as homedir14 } from "node:os";
 function getEnvironmentInfo() {
   const unipiModules = [];
   const configPaths = [];
   const extensionPaths = [];
   try {
-    const nodeModules = resolve5(process.cwd(), "node_modules");
+    const nodeModules = resolve6(process.cwd(), "node_modules");
     if (existsSync18(nodeModules)) {
       const scopePath = join18(nodeModules, "@pi-unipi");
       if (existsSync18(scopePath)) {
-        for (const entry of readdirSync10(scopePath)) {
+        for (const entry of readdirSync11(scopePath)) {
           if (entry.startsWith(".")) continue;
           const pkgPath = join18(scopePath, entry, "package.json");
           if (existsSync18(pkgPath)) {
@@ -2631,7 +2707,7 @@ function getEnvironmentInfo() {
   } catch {
   }
   const globalConfig = join18(homedir14(), ".unipi", "config");
-  const projectConfig = resolve5(process.cwd(), ".unipi", "config");
+  const projectConfig = resolve6(process.cwd(), ".unipi", "config");
   if (existsSync18(globalConfig)) {
     configPaths.push(globalConfig);
   }
@@ -3878,7 +3954,7 @@ var init_schema = __esm({
 // packages/compactor/src/config/manager.ts
 import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync29, writeFileSync as writeFileSync23 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
-import { dirname as dirname25, join as join32 } from "node:path";
+import { dirname as dirname24, join as join32 } from "node:path";
 function projectConfigPath(cwd) {
   return join32(cwd, ".unipi", "config", "compactor.json");
 }
@@ -3915,7 +3991,7 @@ function loadConfig4(cwd) {
 function saveConfig3(config, opts) {
   try {
     const targetPath = opts?.perProject && opts?.cwd ? projectConfigPath(opts.cwd) : COMPACTOR_CONFIG_PATH;
-    const dir = dirname25(targetPath);
+    const dir = dirname24(targetPath);
     if (!existsSync31(dir)) mkdirSync19(dir, { recursive: true });
     writeFileSync23(targetPath, `${JSON.stringify(config, null, 2)}
 `);
@@ -3950,7 +4026,7 @@ function migrateConfig(partial) {
 }
 function scaffoldConfig() {
   try {
-    const dir = dirname25(COMPACTOR_CONFIG_PATH);
+    const dir = dirname24(COMPACTOR_CONFIG_PATH);
     if (!existsSync31(dir)) mkdirSync19(dir, { recursive: true });
     if (!existsSync31(COMPACTOR_CONFIG_PATH)) {
       writeFileSync23(COMPACTOR_CONFIG_PATH, `${JSON.stringify(DEFAULT_COMPACTOR_CONFIG, null, 2)}
@@ -5466,57 +5542,10 @@ var init_snapshot = __esm({
   }
 });
 
-// packages/compactor/src/session/auto-inject.ts
-var auto_inject_exports = {};
-__export(auto_inject_exports, {
-  buildAutoInjection: () => buildAutoInjection
-});
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function buildAutoInjection(events) {
-  const parts = [];
-  let tokenBudget = MAX_TOKENS2;
-  const roleEvents = events.filter((e) => e.category === "rule");
-  if (roleEvents.length > 0) {
-    const directive = roleEvents[roleEvents.length - 1].data;
-    const directiveText = `[Role Directive]
-${directive}`;
-    const tokens = estimateTokens(directiveText);
-    if (tokens <= tokenBudget) {
-      parts.push(directiveText);
-      tokenBudget -= tokens;
-    }
-  }
-  if (tokenBudget > 80) {
-    const intentEvents = events.filter((e) => e.category === "intent");
-    if (intentEvents.length > 0) {
-      const mode = intentEvents[intentEvents.length - 1].data;
-      const modeText = `[Session Mode]
-${mode}`;
-      const tokens = estimateTokens(modeText);
-      if (tokens <= tokenBudget) {
-        parts.push(modeText);
-        tokenBudget -= tokens;
-      }
-    }
-  }
-  if (parts.length === 0) return null;
-  const text = parts.join("\n\n");
-  return { text, tokens: estimateTokens(text) };
-}
-var MAX_TOKENS2;
-var init_auto_inject = __esm({
-  "packages/compactor/src/session/auto-inject.ts"() {
-    "use strict";
-    MAX_TOKENS2 = 150;
-  }
-});
-
 // packages/compactor/src/config/presets.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function presetHash(config) {
-  return createHash3("sha256").update(JSON.stringify(config)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(config)).digest("hex");
 }
 function configsEqual(a, b) {
   const aHash = presetHash(a);
@@ -5546,7 +5575,7 @@ function parsePreset(raw) {
   }
   return void 0;
 }
-var pipeline, pipelineAllOn, preset, PRESET_CONFIGS, presetHashes, OLD_TO_NEW;
+var pipeline, pipelineWithAutoInjection, preset, PRESET_CONFIGS, presetHashes, OLD_TO_NEW;
 var init_presets = __esm({
   "packages/compactor/src/config/presets.ts"() {
     "use strict";
@@ -5556,13 +5585,8 @@ var init_presets = __esm({
       ...overrides,
       customNoisePatterns: [...overrides.customNoisePatterns ?? DEFAULT_COMPACTOR_CONFIG.pipeline.customNoisePatterns]
     });
-    pipelineAllOn = () => pipeline({
-      ttlCache: true,
-      autoInjection: true,
-      proximityReranking: true,
-      timelineSort: true,
-      progressiveThrottling: true,
-      mmapPragma: true
+    pipelineWithAutoInjection = () => pipeline({
+      autoInjection: true
     });
     preset = (overrides) => ({
       ...structuredClone(DEFAULT_COMPACTOR_CONFIG),
@@ -5574,23 +5598,23 @@ var init_presets = __esm({
       userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...overrides.userPreferences ?? {} },
       briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...overrides.briefTranscript ?? {} },
       sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...overrides.sessionContinuity ?? {} },
-      fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, ...overrides.fts5Index ?? {} },
+      // Legacy compatibility data only; presets never advertise or alter it.
+      fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index },
       sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...overrides.sandboxExecution ?? {} },
-      toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...overrides.toolDisplay ?? {} },
+      // Legacy compatibility data only; presets never advertise or alter it.
+      toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay },
       pipeline: pipeline(overrides.pipeline),
       autoCompaction: { ...DEFAULT_COMPACTOR_CONFIG.autoCompaction, ...overrides.autoCompaction ?? {} }
     });
     PRESET_CONFIGS = {
       // New preset names
       precise: preset({
-        pipeline: pipeline({ ttlCache: true, mmapPragma: true }),
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "safe-only" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" }
+        pipeline: pipeline(),
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" }
       }),
       thorough: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" }
       }),
       lean: preset({
         pipeline: pipeline(),
@@ -5601,26 +5625,20 @@ var init_presets = __esm({
         userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
         briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
         sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, enabled: false, mode: "off" },
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, enabled: true, mode: "opencode" }
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" }
       }),
       balanced: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "balanced" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, mode: "auto" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" }
       }),
       // Backward-compat aliases — map old names to new
       opencode: preset({
-        pipeline: pipeline({ ttlCache: true, mmapPragma: true }),
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "safe-only" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" }
+        pipeline: pipeline(),
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" }
       }),
       verbose: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" }
       }),
       minimal: preset({
         pipeline: pipeline(),
@@ -5631,9 +5649,7 @@ var init_presets = __esm({
         userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
         briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
         sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, enabled: false, mode: "off" },
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, enabled: true, mode: "opencode" }
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" }
       }),
       custom: structuredClone(DEFAULT_COMPACTOR_CONFIG)
     };
@@ -5791,7 +5807,7 @@ var init_settings_overlay = __esm({
         key: "sessionContinuity",
         label: "Session Continuity",
         description: "XML resume snapshot for compaction survival",
-        modes: ["full", "essential-only", "off"],
+        modes: ["full", "off"],
         getEnabled: (c) => c.sessionContinuity.enabled,
         setEnabled: (c, v) => c.sessionContinuity.enabled = v,
         getMode: (c) => c.sessionContinuity.mode,
@@ -5801,30 +5817,17 @@ var init_settings_overlay = __esm({
         key: "sandboxExecution",
         label: "Sandbox Execution",
         description: "Polyglot code execution",
-        modes: ["all", "safe-only", "off"],
+        modes: ["all", "off"],
         getEnabled: (c) => c.sandboxExecution.enabled,
         setEnabled: (c, v) => c.sandboxExecution.enabled = v,
         getMode: (c) => c.sandboxExecution.mode,
         setMode: (c, v) => c.sandboxExecution.mode = v
-      },
-      {
-        key: "toolDisplay",
-        label: "Tool Display",
-        description: "Override tool output rendering",
-        modes: ["opencode", "balanced", "verbose", "custom"],
-        getEnabled: (c) => c.toolDisplay.enabled,
-        setEnabled: (c, v) => c.toolDisplay.enabled = v,
-        getMode: (c) => c.toolDisplay.mode,
-        setMode: (c, v) => c.toolDisplay.mode = v
       }
     ];
     PIPELINE_ITEMS = [
-      { key: "ttlCache", label: "TTL Cache", description: "Cache with time-based expiry", group: "On Compaction", getValue: (c) => c.pipeline.ttlCache, setValue: (c, v) => c.pipeline.ttlCache = v },
-      { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => c.pipeline.autoInjection = v },
-      { key: "mmapPragma", label: "MMap Pragma", description: "Use mmap for SQLite I/O", group: "On Compaction", getValue: (c) => c.pipeline.mmapPragma, setValue: (c, v) => c.pipeline.mmapPragma = v },
-      { key: "proximityReranking", label: "Proximity Reranking", description: "Rerank search results by proximity", group: "On Search", getValue: (c) => c.pipeline.proximityReranking, setValue: (c, v) => c.pipeline.proximityReranking = v },
-      { key: "timelineSort", label: "Timeline Sort", description: "Sort session events chronologically", group: "On Search", getValue: (c) => c.pipeline.timelineSort, setValue: (c, v) => c.pipeline.timelineSort = v },
-      { key: "progressiveThrottling", label: "Progressive Throttling", description: "Slow down processing for large projects", group: "On Compaction", getValue: (c) => c.pipeline.progressiveThrottling, setValue: (c, v) => c.pipeline.progressiveThrottling = v }
+      // Only expose implemented behavior. Reserved compatibility fields remain in
+      // the persisted schema so existing config files continue to load.
+      { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => c.pipeline.autoInjection = v }
     ];
     PRESETS2 = ["precise", "balanced", "thorough", "lean"];
     THRESHOLD_VALUES = ["60%", "70%", "75%", "80%", "85%", "90%", "95%"];
@@ -5832,20 +5835,20 @@ var init_settings_overlay = __esm({
     REPEAT_GROWTH_VALUES = ["0", "1k", "4k", "8k", "16k", "32k"];
     PRESET_DESCRIPTIONS = {
       precise: {
-        summary: "Code-heavy, minimal waste \u2014 compaction: full, sandbox: safe-only",
-        detail: "Max token savings. Compaction: full. Display: minimal.\nSandbox: safe-only. Pipeline: ttlCache+mmap on."
+        summary: "Code-heavy, minimal waste \u2014 compaction: full, sandbox: all",
+        detail: "Max token savings. Compaction: full.\nSandbox: all. Auto injection: off."
       },
       balanced: {
         summary: "Daily use (default) \u2014 all strategies moderate",
-        detail: "Moderate all strategies. Display: balanced.\nSandbox: all. Pipeline: all 6 on."
+        detail: "Moderate all strategies.\nSandbox: all. Auto injection: on."
       },
       thorough: {
         summary: "Debug/audit \u2014 everything on, full transcript",
-        detail: "Everything enabled. Display: verbose.\nSandbox: all. Pipeline: all 6 on."
+        detail: "Everything enabled.\nSandbox: all. Auto injection: on."
       },
       lean: {
         summary: "Quick fixes, short sessions \u2014 compaction only",
-        detail: "Compaction only. Display: opencode.\nSandbox: off. Pipeline: all 6 off."
+        detail: "Compaction only.\nSandbox: off. Auto injection: off."
       }
     };
     THEME = {
@@ -6397,7 +6400,7 @@ __export(evaluator_exports, {
   splitChainedCommands: () => splitChainedCommands
 });
 import { realpathSync as realpathSync2, existsSync as existsSync37, readFileSync as readFileSync32 } from "node:fs";
-import { resolve as resolve11, join as join36 } from "node:path";
+import { resolve as resolve12, join as join36 } from "node:path";
 import { homedir as homedir22 } from "node:os";
 function loadProjectPermissions(cwd, basePolicy) {
   const settingsPath = join36(cwd, ".pi", "settings.json");
@@ -6469,7 +6472,7 @@ function splitChainedCommands(command) {
   return commands;
 }
 function evaluateFilePath(filePath, policy, cwd = process.cwd()) {
-  const resolved = resolve11(cwd, filePath);
+  const resolved = resolve12(cwd, filePath);
   try {
     const real = realpathSync2(resolved);
     const home = homedir22();
@@ -6571,137 +6574,6 @@ var init_scanner = __esm({
   }
 });
 
-// packages/compactor/src/display/render-utils.ts
-function splitLines(text) {
-  return text.split(/\r?\n/);
-}
-function countNonEmptyLines(text) {
-  return splitLines(text).filter((l) => l.trim()).length;
-}
-function previewLines(text, lines) {
-  const all = splitLines(text);
-  if (all.length <= lines) return text;
-  return all.slice(0, lines).join("\n") + `
-...(${all.length - lines} more lines)`;
-}
-function shortenPath(path28, maxLen = 60) {
-  if (path28.length <= maxLen) return path28;
-  const parts = path28.split("/");
-  if (parts.length <= 2) return "..." + path28.slice(-(maxLen - 3));
-  return parts[0] + "/.../" + parts.slice(-2).join("/");
-}
-var init_render_utils = __esm({
-  "packages/compactor/src/display/render-utils.ts"() {
-    "use strict";
-  }
-});
-
-// packages/compactor/src/display/tool-overrides.ts
-var tool_overrides_exports = {};
-__export(tool_overrides_exports, {
-  applyToolDisplayOverride: () => applyToolDisplayOverride,
-  renderBashResult: () => renderBashResult,
-  renderReadResult: () => renderReadResult,
-  renderSearchResult: () => renderSearchResult
-});
-function renderReadResult(content, filePath, config) {
-  switch (config.readOutputMode) {
-    case "hidden":
-      return `[Read: ${shortenPath(filePath)}]`;
-    case "summary":
-      return `[Read: ${shortenPath(filePath)} \u2014 ${countNonEmptyLines(content)} lines]`;
-    case "preview":
-      return previewLines(content, config.previewLines ?? 20);
-    default:
-      return content;
-  }
-}
-function renderSearchResult(results, config) {
-  switch (config.searchOutputMode) {
-    case "hidden":
-      return `[Search results hidden]`;
-    case "count":
-      return `[Search: ${countNonEmptyLines(results)} matches]`;
-    case "preview":
-      return previewLines(results, config.previewLines ?? 20);
-    default:
-      return results;
-  }
-}
-function renderBashResult(output, command, config) {
-  switch (config.bashOutputMode) {
-    case "hidden":
-      return `[Bash: ${command.slice(0, 60)}]`;
-    case "summary":
-      return `[Bash: ${command.slice(0, 60)} \u2014 ${countNonEmptyLines(output)} lines]`;
-    case "preview":
-      return previewLines(output, config.bashCollapsedLines ?? 5);
-    default:
-      return output;
-  }
-}
-function applyToolDisplayOverride(toolName, event, config) {
-  const content = event.content;
-  if (!content || !Array.isArray(content) || content.length === 0) return void 0;
-  const textContent = content[0]?.text ?? "";
-  const previewLinesCount = config.previewLines ?? 20;
-  const collapsedLines = config.bashCollapsedLines ?? 5;
-  let overridden;
-  switch (toolName) {
-    case "read": {
-      const filePath = String(event.args?.path ?? "");
-      const mode = config.readOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Read: ${shortenPath(filePath)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Read: ${shortenPath(filePath)} \u2014 ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "grep":
-    case "find":
-    case "ls": {
-      const mode = config.searchOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[${toolName} results hidden]`;
-      } else if (mode === "count") {
-        overridden = `[${toolName}: ${countNonEmptyLines(textContent)} matches]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "bash": {
-      const command = String(event.args?.command ?? "");
-      const mode = config.bashOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Bash: ${command.slice(0, 60)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Bash: ${command.slice(0, 60)} \u2014 ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, collapsedLines);
-      }
-      break;
-    }
-    default:
-      return void 0;
-  }
-  if (overridden !== void 0) {
-    return {
-      content: [{ type: "text", text: overridden }]
-    };
-  }
-  return void 0;
-}
-var init_tool_overrides = __esm({
-  "packages/compactor/src/display/tool-overrides.ts"() {
-    "use strict";
-    init_render_utils();
-  }
-});
-
 // packages/compactor/src/display/diff-width-safety.ts
 var diff_width_safety_exports = {};
 __export(diff_width_safety_exports, {
@@ -6770,6 +6642,9 @@ var init_thinking_label = __esm({
 init_core();
 import { dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  buildSessionContext
+} from "@earendil-works/pi-coding-agent";
 
 // packages/workflow/commands.ts
 init_core();
@@ -7038,11 +6913,15 @@ function registerWorkflowCommands(pi, options) {
         return null;
       },
       handler: async (args, ctx) => {
-        const currentTools = options.getActiveTools();
-        options.saveTools(currentTools);
-        const sandboxTools = getToolsForCommand(cmd.name, currentTools);
-        const sandboxLevel = getSandboxLevel(cmd.name);
-        options.setActiveTools([...sandboxTools], sandboxLevel);
+        const workflowEvent = {
+          command: cmd.name,
+          fullCommand: `/${fullCommand}`,
+          args: args?.trim() ?? ""
+        };
+        if (!options.activateSandbox(workflowEvent)) {
+          if (ctx.hasUI) ctx.ui.notify("Another UniPi workflow is still active", "warning");
+          return;
+        }
         let skillContent = "";
         try {
           const skillPath = join3(
@@ -7071,7 +6950,12 @@ Arguments: ${args.trim()}`;
 ${skillContent}
 </skill_content>`;
         }
-        pi.sendUserMessage(message, { deliverAs: "followUp" });
+        try {
+          pi.sendUserMessage(message, { deliverAs: "followUp" });
+        } catch (error) {
+          options.abortWorkflow();
+          throw error;
+        }
         if (ctx.hasUI) {
           ctx.ui.notify(`Running /${fullCommand}`, "info");
           const ralphStatus = options.isRalphDetected() ? "\u2713 rl" : "\u25CB rl";
@@ -7106,84 +6990,180 @@ ${taskContent}`,
   });
 }
 
+// packages/workflow/lifecycle.ts
+var WorkflowLifecycle = class {
+  constructor(now2 = Date.now) {
+    this.now = now2;
+  }
+  now;
+  active = null;
+  start(event) {
+    if (this.active) return false;
+    this.active = { ...event, startedAt: this.now() };
+    return true;
+  }
+  complete(messages) {
+    if (!this.active) return void 0;
+    const workflow = this.active;
+    this.active = null;
+    const finalAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    const success = finalAssistant?.stopReason !== "error" && finalAssistant?.stopReason !== "aborted";
+    return {
+      command: workflow.command,
+      fullCommand: workflow.fullCommand,
+      args: workflow.args,
+      success,
+      durationMs: this.now() - workflow.startedAt
+    };
+  }
+  reset() {
+    this.active = null;
+  }
+};
+
 // packages/workflow/index.ts
 var VERSION = getPackageVersion(dirname2(fileURLToPath(import.meta.url)));
-var ralphDetected = false;
-var savedTools = null;
-var sandboxActive = false;
-var currentSandboxLevel = null;
-var currentSandboxTools = null;
+var WORKFLOW_SANDBOX_SNAPSHOT_TYPE = "unipi-workflow-sandbox-snapshot";
+function sandboxRestrictions(level) {
+  const common = [
+    "Do not attempt to call tools blocked by name.",
+    "If the user requests an action that requires a blocked tool, explain that the workflow sandbox does not allow it."
+  ];
+  if (level === "brainstorm") {
+    return [
+      "The write tool is restricted to .unipi/docs/specs/ only.",
+      "Use bash only for specific setup operations such as git init or mkdir; use grep, find, and ls for discovery instead of bash.",
+      ...common
+    ];
+  }
+  if (level === "write_unipi") {
+    return [
+      "The write tool is restricted to .unipi/docs/ only (specs and plans).",
+      "Use grep, find, and ls for file discovery instead of guessing filenames.",
+      "Bash is blocked; use read, write, edit, grep, find, and ls only.",
+      ...common
+    ];
+  }
+  return common;
+}
+function formatActiveSandboxSnapshot(command, level) {
+  const blocked = getBlockedToolsForLevel(level);
+  const blockedLine = blocked.length > 0 ? blocked.join(", ") : "none";
+  return [
+    "# UniPi Workflow Sandbox Snapshot",
+    "This snapshot supersedes all prior UniPi workflow sandbox snapshots; use only this snapshot for workflow sandbox status and restrictions.",
+    "Status: active",
+    `Workflow: /unipi:${command}`,
+    `Sandbox level: ${level}`,
+    `Blocked tool names: ${blockedLine}`,
+    "Pi's provider tool schemas and tool order remain unchanged. Calls to blocked tool names are rejected by the workflow sandbox.",
+    ["Restrictions:", ...sandboxRestrictions(level).map((restriction) => `- ${restriction}`)].join("\n")
+  ].join("\n\n");
+}
+function formatInactiveSandboxSnapshot() {
+  return [
+    "# UniPi Workflow Sandbox Snapshot",
+    "This snapshot supersedes all prior UniPi workflow sandbox snapshots; use only this snapshot for workflow sandbox status and restrictions.",
+    "Status: inactive",
+    "No UniPi workflow sandbox is active. Prior workflow sandbox restrictions no longer apply."
+  ].join("\n\n");
+}
+function latestEffectiveSandboxSnapshot(branch) {
+  const messages = buildSessionContext(branch).messages;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.role === "custom" && message.customType === WORKFLOW_SANDBOX_SNAPSHOT_TYPE) {
+      return {
+        content: message.content,
+        details: message.details
+      };
+    }
+  }
+  return void 0;
+}
+function latestHistoricalSandboxSnapshot(branch) {
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type === "custom_message" && entry.customType === WORKFLOW_SANDBOX_SNAPSHOT_TYPE) {
+      return {
+        content: entry.content,
+        details: entry.details
+      };
+    }
+  }
+  return void 0;
+}
+function isActiveSnapshot(snapshot) {
+  if (typeof snapshot.details?.active === "boolean") return snapshot.details.active;
+  return typeof snapshot.content === "string" && snapshot.content.includes("Status: active");
+}
 function workflow_default(pi) {
+  const workflowLifecycle = new WorkflowLifecycle();
+  let ralphDetected = false;
+  let sandboxCommand = null;
   registerWorkflowCommands(pi, {
     isRalphDetected: () => ralphDetected,
-    getActiveTools: () => pi.getActiveTools(),
-    setActiveTools: (tools, level) => {
-      pi.setActiveTools(tools);
-      sandboxActive = true;
-      currentSandboxLevel = level;
-      currentSandboxTools = tools;
+    activateSandbox: (event) => {
+      if (!workflowLifecycle.start(event)) return false;
+      sandboxCommand = event.command;
+      emitEvent(pi, UNIPI_EVENTS.WORKFLOW_START, event);
+      return true;
     },
-    saveTools: (tools) => {
-      savedTools = tools;
+    abortWorkflow: () => {
+      sandboxCommand = null;
+      workflowLifecycle.reset();
     }
   });
   pi.on("tool_call", async (event, _ctx) => {
-    if (!sandboxActive || !currentSandboxLevel) return;
-    const allowed = currentSandboxTools ?? [];
-    if (!allowed.includes(event.toolName)) {
+    if (!sandboxCommand) return;
+    const level = getSandboxLevel(sandboxCommand);
+    if (!isToolAllowed(level, event.toolName)) {
+      const blocked = getBlockedToolsForLevel(level);
       return {
         block: true,
-        reason: `Tool "${event.toolName}" is not allowed in ${currentSandboxLevel} sandbox. Allowed: ${allowed.join(", ")}`
+        reason: `Tool "${event.toolName}" is not allowed in ${level} sandbox. Blocked: ${blocked.join(", ")}`
       };
     }
   });
-  pi.on("before_agent_start", async (event, _ctx) => {
-    if (!sandboxActive || !currentSandboxLevel) return;
-    const allowed = currentSandboxTools ?? pi.getActiveTools();
-    const blocked = getBlockedToolsForLevel(currentSandboxLevel);
-    const blockedLine = blocked.length > 0 ? `
-Blocked tools: ${blocked.join(", ")} \u2014 removed from your tool list.` : "\nNo tools were blocked by this sandbox.";
-    const base = `
-
-<sandbox>
-Sandbox mode: ${currentSandboxLevel}.
-Available tools: ${allowed.join(", ")}.${blockedLine}`;
-    if (currentSandboxLevel === "brainstorm") {
-      return {
-        systemPrompt: event.systemPrompt + base + `
-The write tool is available but restricted to .unipi/docs/specs/ only.
-bash is available ONLY for specific setup use case (e.g., git init, mkdir). Do NOT use bash for reading files or listing directories \u2014 use grep, find, ls instead.
-Do NOT attempt to call blocked tools. Do NOT output tool call XML for them.
-If the user requests an action that requires a blocked tool, respond that you do not have access.
-</sandbox>`
-      };
-    }
-    if (currentSandboxLevel === "write_unipi") {
+  pi.on("before_agent_start", async (_event, ctx) => {
+    const branch = ctx.sessionManager.getBranch();
+    const latest = latestEffectiveSandboxSnapshot(branch);
+    const historical = latestHistoricalSandboxSnapshot(branch);
+    if (sandboxCommand) {
+      const level = getSandboxLevel(sandboxCommand);
+      const content = formatActiveSandboxSnapshot(sandboxCommand, level);
+      if (latest?.content === content) return void 0;
       return {
-        systemPrompt: event.systemPrompt + base + `
-Write tool is restricted to .unipi/docs/ only (specs and plans).
-Use grep, find, ls for file discovery \u2014 do NOT guess filenames.
-bash is blocked \u2014 use read, write, edit, grep, find, ls only.
-Do NOT attempt to call blocked tools. Do NOT output tool call XML for them.
-If the user requests an action that requires a blocked tool, respond that you do not have access.
-</sandbox>`
+        message: {
+          customType: WORKFLOW_SANDBOX_SNAPSHOT_TYPE,
+          content,
+          display: false,
+          details: {
+            active: true,
+            command: sandboxCommand,
+            level
+          }
+        }
       };
     }
+    const prior = latest ?? historical;
+    if (!prior || !isActiveSnapshot(prior)) return void 0;
     return {
-      systemPrompt: event.systemPrompt + base + `
-Do NOT attempt to call blocked tools. Do NOT output tool call XML for them.
-If the user requires an action that requires a blocked tool, respond that you do not have access.
-</sandbox>`
+      message: {
+        customType: WORKFLOW_SANDBOX_SNAPSHOT_TYPE,
+        content: formatInactiveSandboxSnapshot(),
+        display: false,
+        details: {
+          active: false
+        }
+      }
     };
   });
-  pi.on("agent_end", async (_event, _ctx) => {
-    if (sandboxActive && savedTools) {
-      pi.setActiveTools(savedTools);
-      savedTools = null;
-      sandboxActive = false;
-      currentSandboxLevel = null;
-      currentSandboxTools = null;
-    }
+  pi.on("agent_end", async (event, _ctx) => {
+    const completedWorkflow = workflowLifecycle.complete(event.messages);
+    if (!completedWorkflow) return;
+    sandboxCommand = null;
+    emitEvent(pi, UNIPI_EVENTS.WORKFLOW_END, completedWorkflow);
   });
   pi.on("session_start", async (_event, ctx) => {
     initUnipiDirs();
@@ -7196,7 +7176,7 @@ If the user requires an action that requires a blocked tool, respond that you do
     if (!ralphDetected) {
       try {
         const allTools = pi.getAllTools();
-        ralphDetected = allTools.some((t) => t.name === "ralph_start");
+        ralphDetected = allTools.some((tool) => tool.name === "ralph_start");
       } catch {
       }
     }
@@ -7207,14 +7187,12 @@ If the user requires an action that requires a blocked tool, respond that you do
   });
   pi.events.on(UNIPI_EVENTS.MODULE_READY, (data) => {
     const event = data;
-    if (event?.name === MODULES.RALPH) {
-      ralphDetected = true;
-    }
+    if (event?.name === MODULES.RALPH) ralphDetected = true;
   });
   pi.on("session_shutdown", async () => {
     ralphDetected = false;
-    savedTools = null;
-    sandboxActive = false;
+    sandboxCommand = null;
+    workflowLifecycle.reset();
   });
 }
 
@@ -7480,12 +7458,20 @@ Use /unipi:ralph-resume <name> to continue`, "info");
       );
       return null;
     }
+    this.emitIterationDone(state);
     const needsReflection = state.reflectEvery > 0 && (state.iteration - 1) % state.reflectEvery === 0;
     if (needsReflection) state.lastReflectionAt = state.iteration;
     this.saveState(state);
     this.updateUI();
     return { state, needsReflection };
   }
+  emitIterationDone(state) {
+    this.emitFn(UNIPI_EVENTS.RALPH_ITERATION_DONE, {
+      name: state.name,
+      iteration: state.iteration - 1,
+      nextIteration: state.iteration
+    });
+  }
   archiveLoop(name) {
     const state = this.loadState(name);
     if (!state) return false;
@@ -8084,7 +8070,7 @@ function handleNuke(rest, ctx, pi) {
 // packages/memory/index.ts
 init_core();
 init_storage();
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // packages/memory/tools.ts
@@ -8792,7 +8778,7 @@ init_settings();
 function getInfoRegistry2() {
   return globalThis.__unipi_info_registry;
 }
-var VERSION3 = getPackageVersion(dirname8(fileURLToPath4(import.meta.url)));
+var VERSION3 = getPackageVersion(dirname7(fileURLToPath4(import.meta.url)));
 var projectStorage = null;
 var orphanSyncPending = false;
 function ensureOrphanSync(storage) {
@@ -9014,12 +9000,12 @@ function memory_default(pi) {
 
 // packages/info-screen/index.ts
 init_core();
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // packages/info-screen/config.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join8, dirname as dirname9 } from "node:path";
+import { join as join8, dirname as dirname8 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 
 // packages/info-screen/types.ts
@@ -9048,7 +9034,7 @@ function readSettingsFile() {
   }
 }
 function writeSettingsFile(data) {
-  const dir = dirname9(SETTINGS_PATH);
+  const dir = dirname8(SETTINGS_PATH);
   if (!existsSync8(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
@@ -9349,7 +9335,7 @@ if (!globalThis.__unipi_info_registry) {
 
 // packages/info-screen/core-groups.ts
 init_core();
-import { readFileSync as readFileSync9, readdirSync as readdirSync5, existsSync as existsSync10 } from "node:fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync6, existsSync as existsSync10 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 init_usage_parser();
@@ -9410,7 +9396,7 @@ function discoverExtensions() {
   for (const dir of extensionDirs) {
     if (!existsSync10(dir)) continue;
     try {
-      const entries = readdirSync5(dir, { withFileTypes: true });
+      const entries = readdirSync6(dir, { withFileTypes: true });
       for (const entry of entries) {
         const name = entry.name;
         if (counted.has(name)) continue;
@@ -9484,7 +9470,7 @@ function discoverSkills() {
   for (const dir of skillDirs) {
     if (!existsSync10(dir)) continue;
     try {
-      const entries = readdirSync5(dir, { withFileTypes: true });
+      const entries = readdirSync6(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const name = entry.name;
@@ -10595,7 +10581,7 @@ var SettingsOverlay = class _SettingsOverlay {
 };
 
 // packages/info-screen/index.ts
-var VERSION4 = getPackageVersion(dirname11(fileURLToPath5(import.meta.url)));
+var VERSION4 = getPackageVersion(dirname10(fileURLToPath5(import.meta.url)));
 function info_screen_default(pi) {
   setPiApi(pi);
   registerCoreGroups();
@@ -10735,14 +10721,36 @@ function info_screen_default(pi) {
 }
 
 // packages/subagents/src/index.ts
-init_core();
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type as Type3 } from "typebox";
-import { existsSync as existsSync13, readdirSync as readdirSync7 } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync8 } from "node:fs";
 import { join as join13 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 
+// packages/subagents/src/core-compat.ts
+var MODULES2 = { SUBAGENTS: "subagents" };
+var UNIPI_EVENTS2 = {
+  MODULE_READY: "unipi:module:ready",
+  BADGE_GENERATE_REQUEST: "unipi:badge:generate:request"
+};
+function emitEvent2(pi, eventName, payload) {
+  try {
+    pi.events.emit(eventName, payload);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withHerdrBlocked2(pi, label, fn) {
+  emitEvent2(pi, "herdr:blocked", { active: true, label });
+  try {
+    return await fn();
+  } finally {
+    emitEvent2(pi, "herdr:blocked", { active: false, label });
+  }
+}
+
 // packages/subagents/src/agent-manager.ts
 import { randomUUID } from "node:crypto";
 
@@ -10955,14 +10963,14 @@ ${agentPrompt}`;
 init_model_resolver();
 
 // packages/subagents/src/custom-agents.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync10, renameSync as renameSync3 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync10, renameSync as renameSync4 } from "node:fs";
 import { join as join11 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 function backupCorrupted(filePath) {
   const backupPath = filePath + ".bak";
   try {
-    renameSync3(filePath, backupPath);
+    renameSync4(filePath, backupPath);
   } catch {
   }
 }
@@ -11011,7 +11019,7 @@ function loadCustomAgents(cwd) {
   const agents = /* @__PURE__ */ new Map();
   const globalDir = getGlobalAgentsDir();
   if (existsSync11(globalDir)) {
-    const files = readdirSync6(globalDir).filter((f) => f.endsWith(".md"));
+    const files = readdirSync7(globalDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const agent = loadAgentFromFile(join11(globalDir, file), "global");
       if (agent) {
@@ -11021,7 +11029,7 @@ function loadCustomAgents(cwd) {
   }
   const projectDir = getProjectAgentsDir(cwd);
   if (existsSync11(projectDir)) {
-    const files = readdirSync6(projectDir).filter((f) => f.endsWith(".md"));
+    const files = readdirSync7(projectDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const agent = loadAgentFromFile(join11(projectDir, file), "project");
       if (agent) {
@@ -11048,17 +11056,17 @@ var FileLock = class {
    */
   async acquire(filePath, agentId) {
     while (this.locks.has(filePath)) {
-      await new Promise((resolve13) => {
+      await new Promise((resolve14) => {
         const queue = this.queues.get(filePath) ?? [];
-        queue.push(resolve13);
+        queue.push(resolve14);
         this.queues.set(filePath, queue);
       });
     }
     let releaseFn;
-    const promise = new Promise((resolve13) => {
+    const promise = new Promise((resolve14) => {
       releaseFn = () => {
         this.locks.delete(filePath);
-        resolve13();
+        resolve14();
         const queue = this.queues.get(filePath);
         if (queue && queue.length > 0) {
           const next = queue.shift();
@@ -11124,23 +11132,43 @@ var AgentManager = class {
   onStart;
   maxConcurrent;
   customAgents;
+  typeSettings;
   /** Per-file transparent locking for write agents. */
   fileLock = new FileLock();
   /** Queue of background agents waiting to start. */
   queue = [];
   /** Number of currently running background agents. */
   runningBackground = 0;
-  constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart) {
+  constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart, typeSettings = {}, agentsCwd = process.cwd()) {
     this.onComplete = onComplete;
     this.onStart = onStart;
     this.maxConcurrent = maxConcurrent;
-    this.customAgents = loadCustomAgents(process.cwd());
+    this.typeSettings = typeSettings;
+    this.customAgents = loadCustomAgents(agentsCwd);
     this.cleanupInterval = setInterval(() => this.cleanup(), 6e4);
   }
   /** Get resolved agent config for a type. */
   getAgentConfig(type) {
     return this.customAgents.get(type) ?? BUILTIN_CONFIGS[type];
   }
+  /** Public agent types known from built-ins, custom files, or JSON config. */
+  getKnownTypes() {
+    return [.../* @__PURE__ */ new Set([
+      ...Object.keys(BUILTIN_CONFIGS).filter((type) => type !== "name-gen"),
+      ...this.customAgents.keys(),
+      ...Object.keys(this.typeSettings)
+    ])];
+  }
+  /** A type is enabled only when both JSON config and agent frontmatter allow it. */
+  isTypeEnabled(type) {
+    const agentConfig = this.getAgentConfig(type);
+    return this.typeSettings[type]?.enabled !== false && agentConfig?.enabled !== false;
+  }
+  assertTypeEnabled(type) {
+    if (!this.isTypeEnabled(type)) {
+      throw new Error(`Agent type "${type}" is disabled by configuration.`);
+    }
+  }
   setMaxConcurrent(n) {
     this.maxConcurrent = Math.max(1, n);
     this.drainQueue();
@@ -11152,6 +11180,7 @@ var AgentManager = class {
    * Spawn an agent. Returns ID immediately for background, waits for foreground.
    */
   spawn(pi, ctx, type, prompt, options) {
+    this.assertTypeEnabled(type);
     const id = randomUUID().slice(0, 17);
     const abortController = new AbortController();
     const record = {
@@ -11179,9 +11208,11 @@ var AgentManager = class {
     record.startedAt = Date.now();
     if (options.isBackground) this.runningBackground++;
     this.onStart?.(record);
+    const agentConfig = this.getAgentConfig(type);
     let model = options.model;
-    if (options.modelInput && options.modelRegistry) {
-      const resolved = resolveModel(options.modelInput, options.modelRegistry);
+    const modelInput = options.modelInput ?? agentConfig?.model;
+    if (!model && modelInput && options.modelRegistry) {
+      const resolved = resolveModel(modelInput, options.modelRegistry);
       if (typeof resolved === "string") {
         record.status = "error";
         record.error = resolved;
@@ -11194,15 +11225,14 @@ var AgentManager = class {
       }
       model = resolved;
     }
-    const agentConfig = this.getAgentConfig(type);
     const promise = runAgent(ctx, type, prompt, {
       pi,
       model,
       agentConfig,
-      maxTurns: options.maxTurns,
-      isolated: options.isolated,
-      inheritContext: options.inheritContext,
-      thinkingLevel: options.thinkingLevel,
+      maxTurns: options.maxTurns ?? agentConfig?.maxTurns,
+      isolated: options.isolated ?? agentConfig?.isolated,
+      inheritContext: options.inheritContext ?? agentConfig?.inheritContext,
+      thinkingLevel: options.thinkingLevel ?? agentConfig?.thinking,
       signal: record.abortController.signal,
       onToolActivity: (activity) => {
         if (activity.type === "end") record.toolUses++;
@@ -11354,7 +11384,7 @@ var AgentManager = class {
 };
 
 // packages/subagents/src/config.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync5, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join12 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 var DEFAULT_CONFIG2 = {
@@ -11379,7 +11409,7 @@ function ensureDirExists(dirPath) {
 function writeConfigAtomic(filePath, config) {
   const tmpPath = filePath + ".tmp";
   writeFileSync9(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-  renameSync4(tmpPath, filePath);
+  renameSync5(tmpPath, filePath);
 }
 function loadConfigFromPath(filePath) {
   if (!existsSync12(filePath)) return null;
@@ -11395,7 +11425,7 @@ function loadConfigFromPath(filePath) {
 function repairCorrupted(filePath) {
   const backupPath = filePath + ".bak";
   try {
-    renameSync4(filePath, backupPath);
+    renameSync5(filePath, backupPath);
   } catch {
   }
   writeConfigAtomic(filePath, DEFAULT_CONFIG2);
@@ -12142,7 +12172,8 @@ function src_default(pi) {
         type: record.type,
         description: record.description
       });
-    }
+    },
+    config.types
   );
   function buildNotificationDetails(record, activity) {
     return {
@@ -12213,7 +12244,7 @@ function src_default(pi) {
         for (const dir of [globalAgentsDir, workspaceAgentsDir]) {
           try {
             if (existsSync13(dir)) {
-              for (const file of readdirSync7(dir)) {
+              for (const file of readdirSync8(dir)) {
                 if (file.endsWith(".md") && !customTypes.includes(file.replace(".md", ""))) {
                   customTypes.push(file.replace(".md", ""));
                 }
@@ -12245,14 +12276,14 @@ function src_default(pi) {
   let sessionCtx2 = null;
   pi.on("session_start", async (_event, ctx) => {
     sessionCtx2 = ctx;
-    emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
-      name: MODULES.SUBAGENTS || "subagents",
+    emitEvent2(pi, UNIPI_EVENTS2.MODULE_READY, {
+      name: MODULES2.SUBAGENTS || "subagents",
       version: "0.2.0",
       commands: [],
       tools: ["spawn_helper", "get_helper_result"]
     });
   });
-  pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST, async (data) => {
+  pi.events.on(UNIPI_EVENTS2.BADGE_GENERATE_REQUEST, async (data) => {
     const event = data;
     if (!sessionCtx2) return;
     const summary = event?.conversationSummary ?? "";
@@ -12338,13 +12369,15 @@ ${summary}` : `Generate a concise session title (MAX 5 WORDS) for this session.
     return { state, callbacks };
   }
   const builtinTypes = BUILTIN_TYPES.join(", ");
+  const enabledTypes = manager2.getKnownTypes().filter((type) => manager2.isTypeEnabled(type));
+  const availableTypes = enabledTypes.join(", ") || "none";
   pi.registerTool(
     defineTool({
       name: "spawn_helper",
       label: "Spawn Helper",
       description: `Launch a sub-agent for parallel work.
 
-Available agent types: ${builtinTypes}
+Available agent types: ${availableTypes}
 Custom types can be defined in:
 - ~/.unipi/config/agents/<name>.md (global)
 - <workspace>/.unipi/config/agents/<name>.md (project)
@@ -12357,7 +12390,7 @@ Guidelines:
 - Agents inherit the parent model by default`,
       parameters: Type3.Object({
         type: Type3.String({
-          description: `Agent type: ${builtinTypes}, or custom type from ~/.unipi/config/agents/*.md`
+          description: `Enabled agent type: ${availableTypes}`
         }),
         prompt: Type3.String({
           description: "The task for the agent to perform."
@@ -12600,7 +12633,7 @@ Use get_result to retrieve full results.`,
         }
         if (params.view && record.session) {
           const activity = agentActivity.get(record.id);
-          await withHerdrBlocked(
+          await withHerdrBlocked2(
             pi,
             "helper viewer",
             () => ctx.ui.custom(
@@ -12657,7 +12690,7 @@ Description: ${record.description}
 // packages/btw/extensions/btw.ts
 init_core();
 import {
-  buildSessionContext,
+  buildSessionContext as buildSessionContext2,
   createAgentSession as createAgentSession2,
   createExtensionRuntime,
   SessionManager as SessionManager2
@@ -12743,7 +12776,7 @@ function buildBtwSeedState(ctx, thread, mode) {
   if (mode === "contextual") {
     try {
       messages.push(
-        ...buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId()).messages.filter(
+        ...buildSessionContext2(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId()).messages.filter(
           (message) => !isVisibleBtwMessage(message)
         )
       );
@@ -14146,7 +14179,7 @@ ${summary}`;
 
 // packages/web-api/src/index.ts
 init_core();
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // packages/web-api/src/tools.ts
@@ -16816,7 +16849,7 @@ var llmSummarizeProvider = {
 registry.register(llmSummarizeProvider);
 
 // packages/web-api/src/index.ts
-var VERSION5 = getPackageVersion(dirname12(fileURLToPath6(import.meta.url)));
+var VERSION5 = getPackageVersion(dirname11(fileURLToPath6(import.meta.url)));
 function getInfoRegistry4() {
   return globalThis.__unipi_info_registry;
 }
@@ -16888,14 +16921,14 @@ function src_default2(pi) {
 
 // packages/utility/src/index.ts
 init_core();
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // packages/utility/src/commands.ts
 init_core();
 
 // packages/utility/src/lifecycle/cleanup.ts
-import { existsSync as existsSync16, statSync as statSync7, readdirSync as readdirSync9, unlinkSync as unlinkSync5, rmdirSync } from "node:fs";
+import { existsSync as existsSync16, statSync as statSync8, readdirSync as readdirSync10, unlinkSync as unlinkSync5, rmdirSync } from "node:fs";
 import { join as join16 } from "node:path";
 import { homedir as homedir12, tmpdir } from "node:os";
 var DEFAULTS = {
@@ -16912,7 +16945,7 @@ function expandHome(path28) {
 }
 function isStale(path28, maxAgeDays) {
   try {
-    const stats = statSync7(path28);
+    const stats = statSync8(path28);
     const ageMs = Date.now() - stats.mtime.getTime();
     return ageMs > maxAgeDays * 24 * 60 * 60 * 1e3;
   } catch {
@@ -16924,7 +16957,7 @@ function hasWalLock(dbPath) {
   const shmPath = dbPath + "-shm";
   if (existsSync16(walPath)) {
     try {
-      const walStats = statSync7(walPath);
+      const walStats = statSync8(walPath);
       const ageMs = Date.now() - walStats.mtime.getTime();
       return ageMs > 5 * 60 * 1e3;
     } catch {
@@ -16945,14 +16978,14 @@ function cleanDbs(options) {
   const scanDir = (dir) => {
     let entries;
     try {
-      entries = readdirSync9(dir);
+      entries = readdirSync10(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       const fullPath = join16(dir, entry);
       try {
-        const stats = statSync7(fullPath);
+        const stats = statSync8(fullPath);
         if (stats.isDirectory()) {
           scanDir(fullPath);
           continue;
@@ -16968,7 +17001,7 @@ function cleanDbs(options) {
                   const companion = fullPath + suffix;
                   if (existsSync16(companion)) {
                     unlinkSync5(companion);
-                    result.bytesFreed += statSync7(companion).size;
+                    result.bytesFreed += statSync8(companion).size;
                   }
                 }
                 result.removed++;
@@ -16997,7 +17030,7 @@ function cleanTemps(options) {
   const tmpDir = tmpdir();
   let entries;
   try {
-    entries = readdirSync9(tmpDir);
+    entries = readdirSync10(tmpDir);
   } catch {
     return result;
   }
@@ -17005,7 +17038,7 @@ function cleanTemps(options) {
     if (!patterns.some((p) => p.test(entry))) continue;
     const fullPath = join16(tmpDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isFile()) continue;
       if (isStale(fullPath, options.tempMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -17037,14 +17070,14 @@ function cleanSessions(options) {
   if (!existsSync16(sessionsDir)) return result;
   let entries;
   try {
-    entries = readdirSync9(sessionsDir);
+    entries = readdirSync10(sessionsDir);
   } catch {
     return result;
   }
   for (const entry of entries) {
     const fullPath = join16(sessionsDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isDirectory()) continue;
       if (isStale(fullPath, options.sessionMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -17052,10 +17085,10 @@ function cleanSessions(options) {
         if (!options.dryRun) {
           try {
             const removeRecursive = (dir) => {
-              const items = readdirSync9(dir);
+              const items = readdirSync10(dir);
               for (const item of items) {
                 const itemPath = join16(dir, item);
-                const itemStats = statSync7(itemPath);
+                const itemStats = statSync8(itemPath);
                 if (itemStats.isDirectory()) {
                   removeRecursive(itemPath);
                 } else {
@@ -17088,14 +17121,14 @@ function cleanCache(options) {
   if (!existsSync16(cacheDir)) return result;
   let entries;
   try {
-    entries = readdirSync9(cacheDir);
+    entries = readdirSync10(cacheDir);
   } catch {
     return result;
   }
   for (const entry of entries) {
     const fullPath = join16(cacheDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isFile()) continue;
       if (isStale(fullPath, options.tempMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -17159,7 +17192,7 @@ function formatCleanupReport(report) {
 }
 
 // packages/utility/src/diagnostics/engine.ts
-import { existsSync as existsSync17, accessSync, constants } from "node:fs";
+import { existsSync as existsSync17, accessSync as accessSync2, constants as constants2 } from "node:fs";
 import { join as join17 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 function expandHome2(path28) {
@@ -17170,7 +17203,7 @@ function expandHome2(path28) {
 }
 function isReadable(path28) {
   try {
-    accessSync(path28, constants.R_OK);
+    accessSync2(path28, constants2.R_OK);
     return true;
   } catch {
     return false;
@@ -17178,7 +17211,7 @@ function isReadable(path28) {
 }
 function isWritable(path28) {
   try {
-    accessSync(path28, constants.W_OK);
+    accessSync2(path28, constants2.W_OK);
     return true;
   } catch {
     return false;
@@ -17587,7 +17620,6 @@ var PRESETS = {
     }
   }
 };
-var HARDCODED_FALLBACK = PRESETS.default.colors;
 function getPreset(name) {
   return PRESETS[name] ?? PRESETS.default;
 }
@@ -18242,17 +18274,9 @@ function registerUtilityCommands(pi) {
         }
         return;
       }
-      const requestId = `status-${Date.now()}`;
-      emitEvent(pi, UNIPI_EVENTS.MODULE_STATUS_REQUEST, { requestId });
-      await new Promise((resolve13) => setTimeout(resolve13, 500));
       sendResponse(
         pi,
-        `## \u{1F4CA} Module Status
-
-Status request broadcast to all modules.
-Modules that support status reporting will respond via events.
-
-*Request ID: \`${requestId}\`*`
+        "## \u{1F4CA} Module Status\n\nUse `/unipi:info` for the live module and tool dashboard.\nUse `/unipi:doctor` to run configuration and runtime diagnostics."
       );
     }
   });
@@ -19457,7 +19481,7 @@ function registerInfoScreen(pi) {
 }
 
 // packages/utility/src/index.ts
-var VERSION6 = getPackageVersion(dirname15(fileURLToPath7(import.meta.url)));
+var VERSION6 = getPackageVersion(dirname14(fileURLToPath7(import.meta.url)));
 var firstMessageSeen = false;
 var firstUserText = "";
 var firstInputCtx = null;
@@ -19669,7 +19693,7 @@ function registerUtilityTools(pi, nameBadgeState) {
 
 // packages/ask-user/index.ts
 init_core();
-import { dirname as dirname16 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 
 // packages/ask-user/tools.ts
@@ -21054,7 +21078,7 @@ function registerAskUserCommands(pi) {
 }
 
 // packages/ask-user/index.ts
-var VERSION7 = getPackageVersion(dirname16(fileURLToPath8(import.meta.url)));
+var VERSION7 = getPackageVersion(dirname15(fileURLToPath8(import.meta.url)));
 function ask_user_default(pi) {
   registerAskUserTools(pi);
   registerAskUserCommands(pi);
@@ -21070,7 +21094,7 @@ function ask_user_default(pi) {
 
 // packages/mcp/src/index.ts
 init_core();
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname18 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 
 // packages/mcp/src/config/manager.ts
@@ -21568,7 +21592,7 @@ var McpClient = class {
     if (this.connected) {
       throw new Error("McpClient is already connected");
     }
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       try {
         const mergedEnv = { ...process.env, ...env };
         this.process = spawn2(command, args, {
@@ -21617,7 +21641,7 @@ Stderr: ${this.stderrBuffer}`
         }).then(() => {
           this.sendNotification("notifications/initialized", {});
           this.connected = true;
-          resolve13();
+          resolve14();
         }).catch((err) => {
           this.cleanup();
           reject(
@@ -21661,16 +21685,16 @@ Stderr: ${this.stderrBuffer}`
       this.sendNotification("shutdown", {});
     } catch {
     }
-    await new Promise((resolve13) => {
-      const timer = setTimeout(() => resolve13(), 500);
+    await new Promise((resolve14) => {
+      const timer = setTimeout(() => resolve14(), 500);
       this.process.on("exit", () => {
         clearTimeout(timer);
-        resolve13();
+        resolve14();
       });
       try {
         this.process.kill("SIGTERM");
       } catch {
-        resolve13();
+        resolve14();
       }
     });
     if (this.process && !this.process.killed) {
@@ -21700,7 +21724,7 @@ Stderr: ${this.stderrBuffer}`
     }
   }
   sendRequest(method, params) {
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       if (!this.process?.stdin) {
         reject(new Error("MCP server process not available"));
         return;
@@ -21720,7 +21744,7 @@ Stderr: ${this.stderrBuffer}`
           )
         );
       }, this.timeoutMs);
-      this.pending.set(id, { resolve: resolve13, reject, timer });
+      this.pending.set(id, { resolve: resolve14, reject, timer });
       const message = JSON.stringify(request) + "\n";
       this.process.stdin.write(message);
     });
@@ -21783,15 +21807,45 @@ Stderr: ${this.stderrBuffer}`
 
 // packages/mcp/src/bridge/translator.ts
 init_core();
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var LITERAL_VALUE_KEYWORDS = /* @__PURE__ */ new Set(["const", "default", "enum", "examples"]);
+function canonicalizeValue(value, key, normalizeSchemaKeywords = true) {
+  if (Array.isArray(value)) {
+    if (normalizeSchemaKeywords && key === "required" && value.every((item) => typeof item === "string")) {
+      return [...new Set(value)].sort(compareCodeUnits);
+    }
+    return value.map((item) => canonicalizeValue(item, void 0, normalizeSchemaKeywords));
+  }
+  if (!isObject(value)) return value;
+  const canonical = {};
+  for (const objectKey of Object.keys(value).sort(compareCodeUnits)) {
+    const childNormalizesSchemaKeywords = normalizeSchemaKeywords && !LITERAL_VALUE_KEYWORDS.has(objectKey);
+    canonical[objectKey] = canonicalizeValue(
+      value[objectKey],
+      objectKey,
+      childNormalizesSchemaKeywords
+    );
+  }
+  return canonical;
+}
+function canonicalizeJsonSchema(schema) {
+  return canonicalizeValue(schema);
+}
 function translateMcpTool(mcpTool, serverName, client) {
   const separator = MCP_DEFAULTS.TOOL_NAME_SEPARATOR;
   const toolName = `${serverName}${separator}${mcpTool.name}`;
-  const inputSchema = mcpTool.inputSchema ?? {};
-  const parameters = {
+  const inputSchema = isObject(mcpTool.inputSchema) ? mcpTool.inputSchema : {};
+  const normalizedSchema = {
     type: "object",
-    properties: inputSchema.properties ?? {},
-    required: inputSchema.required
+    properties: isObject(inputSchema.properties) ? inputSchema.properties : {},
+    required: Array.isArray(inputSchema.required) ? inputSchema.required : []
   };
+  const parameters = canonicalizeJsonSchema(normalizedSchema);
   const description = [
     mcpTool.description || `MCP tool: ${mcpTool.name}`,
     `[Server: ${serverName}]`
@@ -21849,6 +21903,7 @@ Check server status via /unipi:mcp-settings`
   };
   return {
     name: toolName,
+    label: toolName,
     description,
     parameters,
     execute: execute2
@@ -21861,26 +21916,125 @@ var ServerRegistry = class {
   emitEvent;
   registerTool;
   unregisterTool;
+  canUnregisterTools;
   timeoutMs;
+  createClient;
   constructor(options) {
     this.emitEvent = options.emitEvent;
     this.registerTool = options.registerTool;
     this.unregisterTool = options.unregisterTool;
+    this.canUnregisterTools = options.canUnregisterTools ?? true;
     this.timeoutMs = options.timeoutMs ?? MCP_DEFAULTS.STARTUP_TIMEOUT_MS;
+    this.createClient = options.createClient ?? (() => new McpClient({ timeoutMs: this.timeoutMs }));
   }
   /**
-   * Start an MCP server: spawn process, initialize, discover tools, register.
+   * Start one MCP server. Discovery completes before its tools are registered,
+   * and registration always follows final Pi tool-name order.
    */
   async startServer(resolved) {
-    const { name, def } = resolved;
-    if (this.entries.size >= MCP_DEFAULTS.MAX_SERVERS) {
+    await this.startServers([resolved]);
+    const state = this.getServerState(resolved.name);
+    if (state?.status === "error") {
+      throw new Error(state.error ?? `MCP server "${resolved.name}" failed to start`);
+    }
+  }
+  /**
+   * Start MCP servers behind a discovery barrier.
+   *
+   * Connections and tool discovery run in parallel. Once every server has
+   * either prepared or failed, tools from all successful servers are checked
+   * for duplicate final names, sorted, and only then registered with Pi.
+   * Individual connection failures remain represented by error registry
+   * entries and do not prevent tools from other servers being registered.
+   */
+  async startServers(resolvedServers) {
+    if (resolvedServers.length === 0) return;
+    const names = /* @__PURE__ */ new Set();
+    for (const { name } of resolvedServers) {
+      if (names.has(name)) {
+        throw new Error(`Duplicate MCP server name in startup batch: "${name}"`);
+      }
+      names.add(name);
+    }
+    const replacementCount = [...names].filter((name) => this.entries.has(name)).length;
+    if (this.entries.size - replacementCount + resolvedServers.length > MCP_DEFAULTS.MAX_SERVERS) {
       throw new Error(
         `Maximum number of MCP servers (${MCP_DEFAULTS.MAX_SERVERS}) reached. Stop a server before starting a new one.`
       );
     }
-    if (this.entries.has(name)) {
-      await this.stopServer(name);
+    await Promise.all(
+      [...names].filter((name) => this.entries.has(name)).map((name) => this.stopServer(name))
+    );
+    const settled = await Promise.allSettled(
+      resolvedServers.map((resolved) => this.prepareServer(resolved))
+    );
+    const prepared = settled.filter((result) => result.status === "fulfilled").map((result) => result.value);
+    if (prepared.length === 0) return;
+    const registrations = prepared.flatMap(({ entry, tools }) => tools.map((tool) => ({ entry, tool }))).sort((left, right) => compareCodeUnits(left.tool.name, right.tool.name));
+    try {
+      this.assertUniqueFinalToolNames(registrations.map(({ tool }) => tool.name));
+    } catch (error) {
+      await this.failPreparedServers(prepared, error);
+      throw error;
+    }
+    const registeredNames = [];
+    try {
+      for (const { tool } of registrations) {
+        this.registerTool(tool);
+        registeredNames.push(tool.name);
+      }
+    } catch (error) {
+      if (this.canUnregisterTools) {
+        for (const toolName of registeredNames.reverse()) {
+          try {
+            this.unregisterTool(toolName);
+          } catch {
+          }
+        }
+        await this.failPreparedServers(prepared, error);
+      } else {
+        const message = `${error instanceof Error ? error.message : String(error)}; some MCP tools remain registered until Pi restarts`;
+        for (const { entry, client, tools } of prepared) {
+          const toolNames = tools.map((tool) => tool.name).filter((name) => registeredNames.includes(name)).sort(compareCodeUnits);
+          entry.toolNames = toolNames;
+          entry.state = {
+            ...entry.state,
+            status: "error",
+            pid: client.pid,
+            toolCount: toolNames.length,
+            error: message
+          };
+          this.emitEvent(UNIPI_EVENTS.MCP_SERVER_ERROR, {
+            name: entry.name,
+            error: message
+          });
+        }
+      }
+      throw error;
     }
+    for (const { entry, client, tools } of [...prepared].sort((left, right) => compareCodeUnits(left.entry.name, right.entry.name))) {
+      const toolNames = tools.map((tool) => tool.name).sort(compareCodeUnits);
+      entry.toolNames = toolNames;
+      entry.state = {
+        ...entry.state,
+        status: "running",
+        pid: client.pid,
+        toolCount: toolNames.length
+      };
+      this.emitEvent(UNIPI_EVENTS.MCP_SERVER_STARTED, {
+        name: entry.name,
+        toolCount: toolNames.length
+      });
+      if (toolNames.length > 0) {
+        this.emitEvent(UNIPI_EVENTS.MCP_TOOLS_REGISTERED, {
+          serverName: entry.name,
+          toolNames
+        });
+      }
+    }
+  }
+  async prepareServer(resolved) {
+    const { name, def } = resolved;
     const state = {
       name,
       status: "starting",
@@ -21895,73 +22049,74 @@ var ServerRegistry = class {
       toolNames: []
     };
     this.entries.set(name, entry);
+    let client = null;
     try {
       const safeCommand = typeof def.command === "string" ? def.command : String(def.command);
       const safeArgs = Array.isArray(def.args) ? def.args : [];
       let safeEnv;
-      if (def.env !== void 0 && def.env !== null) {
-        if (typeof def.env === "object" && !Array.isArray(def.env)) {
-          safeEnv = {};
-          for (const [k, v] of Object.entries(def.env)) {
-            safeEnv[k] = typeof v === "string" ? v : String(v);
-          }
-        } else {
-        }
-      }
-      const client = new McpClient({ timeoutMs: this.timeoutMs });
-      await client.connect(safeCommand, safeArgs, safeEnv);
-      entry.client = client;
-      const mcpTools = await client.listTools();
-      const toolNames = [];
-      for (const mcpTool of mcpTools) {
-        const piTool = translateMcpTool(mcpTool, name, client);
-        this.registerTool(piTool);
-        toolNames.push(piTool.name);
-      }
-      entry.state = {
-        ...state,
-        status: "running",
-        pid: client.pid,
-        toolCount: toolNames.length
-      };
-      entry.toolNames = toolNames;
-      this.emitEvent(UNIPI_EVENTS.MCP_SERVER_STARTED, {
-        name,
-        toolCount: toolNames.length
-      });
-      if (toolNames.length > 0) {
-        this.emitEvent(UNIPI_EVENTS.MCP_TOOLS_REGISTERED, {
-          serverName: name,
-          toolNames
-        });
-      }
-    } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      entry.state = {
-        ...state,
-        status: "error",
-        error
-      };
-      if (entry.client) {
+      if (def.env !== void 0 && def.env !== null && typeof def.env === "object" && !Array.isArray(def.env)) {
+        safeEnv = {};
+        for (const [key, value] of Object.entries(def.env)) {
+          safeEnv[key] = typeof value === "string" ? value : String(value);
+        }
+      }
+      client = this.createClient();
+      const connectedClient = client;
+      await connectedClient.connect(safeCommand, safeArgs, safeEnv);
+      entry.client = connectedClient;
+      const mcpTools = await connectedClient.listTools();
+      const tools = mcpTools.map((tool) => translateMcpTool(tool, name, connectedClient)).sort((left, right) => compareCodeUnits(left.name, right.name));
+      return { entry, client: connectedClient, tools };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      entry.state = { ...state, status: "error", error: message };
+      if (client) {
         try {
-          await entry.client.disconnect();
+          await client.disconnect();
         } catch {
         }
-        entry.client = null;
       }
-      this.emitEvent(UNIPI_EVENTS.MCP_SERVER_ERROR, {
-        name,
-        error
-      });
-      throw err;
+      entry.client = null;
+      this.emitEvent(UNIPI_EVENTS.MCP_SERVER_ERROR, { name, error: message });
+      throw error;
     }
   }
-  /**
-   * Stop an MCP server: unregister tools, disconnect client.
-   */
+  assertUniqueFinalToolNames(newNames) {
+    const existingNames = this.getActive().flatMap((state) => this.entries.get(state.name)?.toolNames ?? []);
+    const seen = /* @__PURE__ */ new Set();
+    const duplicates = /* @__PURE__ */ new Set();
+    for (const name of [...existingNames, ...newNames]) {
+      if (seen.has(name)) duplicates.add(name);
+      seen.add(name);
+    }
+    if (duplicates.size > 0) {
+      throw new Error(
+        `Duplicate final MCP tool name(s): ${[...duplicates].sort(compareCodeUnits).join(", ")}`
+      );
+    }
+  }
+  async failPreparedServers(prepared, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await Promise.all(prepared.map(async ({ entry, client }) => {
+      entry.state = { ...entry.state, status: "error", toolCount: 0, error: message };
+      entry.toolNames = [];
+      try {
+        await client.disconnect();
+      } catch {
+      }
+      entry.client = null;
+      this.emitEvent(UNIPI_EVENTS.MCP_SERVER_ERROR, { name: entry.name, error: message });
+    }));
+  }
+  /** Stop an MCP server: unregister tools, disconnect client. */
   async stopServer(name) {
     const entry = this.entries.get(name);
     if (!entry) return;
+    if (entry.toolNames.length > 0 && !this.canUnregisterTools) {
+      throw new Error(
+        "This Pi version cannot remove MCP tools at runtime; restart Pi to change the MCP tool set."
+      );
+    }
     for (const toolName of entry.toolNames) {
       this.unregisterTool(toolName);
     }
@@ -21978,78 +22133,63 @@ var ServerRegistry = class {
       }
       entry.client = null;
     }
-    entry.state = {
-      ...entry.state,
-      status: "stopped",
-      toolCount: 0
-    };
+    entry.state = { ...entry.state, status: "stopped", toolCount: 0 };
     entry.toolNames = [];
     this.emitEvent(UNIPI_EVENTS.MCP_SERVER_STOPPED, { name });
   }
-  /**
-   * Restart an MCP server: stop then start.
-   */
+  /** Restart an MCP server: stop then start. */
   async restartServer(name) {
     const entry = this.entries.get(name);
-    if (!entry) {
-      throw new Error(`Server '${name}' not found in registry`);
-    }
+    if (!entry) throw new Error(`Server '${name}' not found in registry`);
     const resolved = entry.resolved;
     await this.stopServer(name);
     await this.startServer(resolved);
   }
-  /**
-   * Stop all running servers.
-   */
+  /** Stop all running servers when runtime unregistration is supported. */
   async stopAll() {
     const names = Array.from(this.entries.keys());
     await Promise.allSettled(names.map((name) => this.stopServer(name)));
   }
-  /**
-   * Get all registered server states.
-   */
+  /** Disconnect clients during extension shutdown without claiming tools were removed. */
+  async disconnectAll() {
+    await Promise.allSettled([...this.entries.values()].map(async (entry) => {
+      if (!entry.client) return;
+      try {
+        await entry.client.disconnect();
+      } finally {
+        entry.client = null;
+      }
+    }));
+  }
+  /** Get all registered server states. */
   getAll() {
-    return Array.from(this.entries.values()).map((e) => e.state);
+    return Array.from(this.entries.values()).map((entry) => entry.state);
   }
-  /**
-   * Get states of running servers.
-   */
+  /** Get states of running servers. */
   getActive() {
-    return this.getAll().filter((s) => s.status === "running");
+    return this.getAll().filter((state) => state.status === "running");
   }
-  /**
-   * Get states of servers in error state.
-   */
+  /** Get states of servers in error state. */
   getFailed() {
-    return this.getAll().filter((s) => s.status === "error");
+    return this.getAll().filter((state) => state.status === "error");
   }
-  /**
-   * Get total number of tools across all active servers.
-   */
+  /** Get total number of tools across all active servers. */
   getTotalToolCount() {
-    return this.getActive().reduce((sum, s) => sum + s.toolCount, 0);
+    return this.getActive().reduce((sum, state) => sum + state.toolCount, 0);
   }
-  /**
-   * Get the state of a specific server.
-   */
+  /** Get the state of a specific server. */
   getServerState(name) {
     return this.entries.get(name)?.state ?? null;
   }
-  /**
-   * Get the full registry entry for a server.
-   */
+  /** Get the full registry entry for a server. */
   getEntry(name) {
     return this.entries.get(name) ?? null;
   }
-  /**
-   * Check if a server exists in the registry.
-   */
+  /** Check if a server exists in the registry. */
   hasServer(name) {
     return this.entries.has(name);
   }
-  /**
-   * Get the number of registered servers.
-   */
+  /** Get the number of registered servers. */
   get size() {
     return this.entries.size;
   }
@@ -22662,12 +22802,6 @@ function renderMcpSettingsOverlay(params) {
           addedAt: meta.servers[server.name]?.addedAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
         saveMetadata(configDir, meta);
-        if (!newEnabled && registry3) {
-          try {
-            await registry3.stopServer(server.name);
-          } catch {
-          }
-        }
         refreshServers();
         refresh();
       } catch (err) {
@@ -22814,7 +22948,7 @@ function renderMcpSettingsOverlay(params) {
 }
 
 // packages/mcp/src/index.ts
-var VERSION8 = getPackageVersion(dirname19(fileURLToPath9(import.meta.url)));
+var VERSION8 = getPackageVersion(dirname18(fileURLToPath9(import.meta.url)));
 var registry2 = null;
 function getInfoRegistry5() {
   return globalThis.__unipi_info_registry;
@@ -22824,20 +22958,18 @@ function getRegistry() {
 }
 function src_default4(pi) {
   pi.on("session_start", async (_event, ctx) => {
+    const toolApi = pi;
+    const registerTool = typeof toolApi.registerTool === "function" ? (tool) => toolApi.registerTool(tool) : typeof toolApi.registerExternalTool === "function" ? (tool) => toolApi.registerExternalTool(tool) : () => {
+      throw new Error("Pi does not expose a supported MCP tool registration API");
+    };
+    const canUnregisterTools = typeof toolApi.unregisterTool === "function" || typeof toolApi.unregisterExternalTool === "function";
+    const unregisterTool = typeof toolApi.unregisterTool === "function" ? (toolName) => toolApi.unregisterTool(toolName) : typeof toolApi.unregisterExternalTool === "function" ? (toolName) => toolApi.unregisterExternalTool(toolName) : () => {
+    };
     registry2 = new ServerRegistry({
       emitEvent: (event, payload) => emitEvent(pi, event, payload),
-      registerTool: (tool) => {
-        try {
-          pi.registerTool?.(tool) ?? pi.registerExternalTool?.(tool);
-        } catch {
-        }
-      },
-      unregisterTool: (toolName) => {
-        try {
-          pi.unregisterTool?.(toolName) ?? pi.unregisterExternalTool?.(toolName);
-        } catch {
-        }
-      }
+      registerTool,
+      unregisterTool,
+      canUnregisterTools
     });
     const cwd = ctx.cwd ?? process.cwd();
     let servers = [];
@@ -22846,13 +22978,10 @@ function src_default4(pi) {
       servers = result.servers;
     } catch (_err) {
     }
-    const startPromises = servers.filter((s) => s.enabled).map(async (server) => {
-      try {
-        await registry2.startServer(server);
-      } catch (err) {
-      }
-    });
-    await Promise.allSettled(startPromises);
+    try {
+      await registry2.startServers(servers.filter((server) => server.enabled));
+    } catch (_err) {
+    }
     const infoRegistry2 = getInfoRegistry5();
     if (infoRegistry2 && registry2) {
       const reg = registry2;
@@ -22909,14 +23038,12 @@ function src_default4(pi) {
         `unipi:${MCP_COMMANDS.STATUS}`,
         `unipi:${MCP_COMMANDS.RELOAD}`
       ],
-      tools: activeServers.flatMap(
-        (s) => registry2?.getEntry(s.name)?.toolNames ?? []
-      )
+      tools: activeServers.flatMap((server) => registry2?.getEntry(server.name)?.toolNames ?? []).sort(compareCodeUnits)
     });
   });
   pi.on("session_shutdown", async (_event, _ctx) => {
     if (registry2) {
-      await registry2.stopAll();
+      await registry2.disconnectAll();
       registry2 = null;
     }
   });
@@ -23030,38 +23157,16 @@ Updated: ${catalog.lastUpdated}`,
     }
   });
   pi.registerCommand(`unipi:${MCP_COMMANDS.RELOAD}`, {
-    description: "Reload all MCP servers (restart with current config)",
+    description: "Explain how to reload MCP servers safely",
     handler: async (_args, ctx) => {
-      const reg = getRegistry();
-      if (!reg) {
-        ctx.ui.notify("MCP extension not initialized", "warning");
-        return;
-      }
-      const all = reg.getAll();
-      if (all.length === 0) {
-        ctx.ui.notify("No MCP servers configured. Use /unipi:mcp-add to add one.", "info");
-        return;
-      }
-      ctx.ui.notify(`Reloading ${all.length} MCP server(s)...`, "info");
-      let restarted = 0;
-      let failed = 0;
-      for (const state of all) {
-        try {
-          await reg.restartServer(state.name);
-          restarted++;
-        } catch (_err) {
-          failed++;
-        }
-      }
-      const msg = failed > 0 ? `Reloaded: ${restarted} ok, ${failed} failed` : `Reloaded ${restarted} MCP server(s) successfully`;
-      ctx.ui.notify(msg, failed > 0 ? "warning" : "info");
+      ctx.ui.notify("Restart Pi to reload MCP servers and tool schemas safely.", "info");
     }
   });
 }
 
 // packages/notify/index.ts
 init_core();
-import { dirname as dirname22 } from "node:path";
+import { dirname as dirname21 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 
 // packages/notify/tools.ts
@@ -23071,7 +23176,7 @@ import { Type as Type6 } from "typebox";
 // packages/notify/settings.ts
 init_core();
 import { readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync15, existsSync as existsSync24 } from "fs";
-import { dirname as dirname20, join as join22 } from "path";
+import { dirname as dirname19, join as join22 } from "path";
 import { homedir as homedir17 } from "os";
 function resolveConfigPath() {
   const base = NOTIFY_DIRS.CONFIG.replace("~", homedir17());
@@ -23125,7 +23230,7 @@ function loadConfig2() {
 }
 function saveConfig2(config) {
   const configPath = resolveConfigPath();
-  const dir = dirname20(configPath);
+  const dir = dirname19(configPath);
   mkdirSync15(dir, { recursive: true });
   writeFileSync17(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
@@ -23186,7 +23291,7 @@ init_core();
 
 // packages/notify/ntfy-config.ts
 import { readFileSync as readFileSync20, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16, existsSync as existsSync25 } from "fs";
-import { dirname as dirname21, join as join23 } from "path";
+import { dirname as dirname20, join as join23 } from "path";
 import { homedir as homedir18 } from "os";
 var DEFAULT_NTFY_CONFIG = {
   enabled: false,
@@ -23226,7 +23331,7 @@ function loadNtfyConfig(cwd) {
 }
 function saveNtfyConfig(scope, cwd, config) {
   const filePath = scope === "project" ? getProjectNtfyPath(cwd) : getGlobalNtfyPath();
-  const dir = dirname21(filePath);
+  const dir = dirname20(filePath);
   mkdirSync16(dir, { recursive: true });
   writeFileSync18(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
@@ -23266,7 +23371,7 @@ function migrateFromLegacyConfig() {
       token: ntfySection.token,
       priority: ntfySection.priority ?? 3
     };
-    const dir = dirname21(globalNtfyPath);
+    const dir = dirname20(globalNtfyPath);
     mkdirSync16(dir, { recursive: true });
     writeFileSync18(
       globalNtfyPath,
@@ -23322,7 +23427,7 @@ async function isWindowFocusedOnWindows() {
     tmpDir = mkdtempSync(join24(tmpdir2(), "pi-focus-"));
     const scriptPath = join24(tmpDir, "check.ps1");
     writeFileSync19(scriptPath, POWERCHECK_SCRIPT, "utf-8");
-    const stdout = await new Promise((resolve13, reject) => {
+    const stdout = await new Promise((resolve14, reject) => {
       execFile(
         "powershell.exe",
         [
@@ -23337,7 +23442,7 @@ async function isWindowFocusedOnWindows() {
         { timeout: 5e3, encoding: "utf-8" },
         (err, out) => {
           if (err) reject(err);
-          else resolve13(out);
+          else resolve14(out);
         }
       );
     });
@@ -23379,7 +23484,7 @@ async function sendNativeNotification(title, message, options) {
   if (options?.suppressWhenFocused && await isWindowFocused()) {
     throw new SuppressedError2();
   }
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     notifier.notify(
       {
         title,
@@ -23394,7 +23499,7 @@ async function sendNativeNotification(title, message, options) {
             )
           );
         } else {
-          resolve13();
+          resolve14();
         }
       }
     );
@@ -23731,7 +23836,7 @@ function getEnabledPlatforms(config, ntfyEnabled) {
 function unregisterEventListeners() {
   unregisterAll();
 }
-async function dispatchNotification(pi, title, message, eventPlatforms, eventType, config, cwd) {
+async function dispatchNotification(pi, title, message, eventPlatforms, eventType, config, cwd, priority) {
   const ntfyConfig = loadNtfyConfig(cwd);
   const platforms = eventPlatforms.length > 0 ? eventPlatforms : getEnabledPlatforms(config, ntfyConfig.enabled).length > 0 ? getEnabledPlatforms(config, ntfyConfig.enabled) : config.defaultPlatforms;
   const enabledPlatforms = platforms.filter((p) => {
@@ -23744,8 +23849,8 @@ async function dispatchNotification(pi, title, message, eventPlatforms, eventTyp
   const results = await Promise.all(
     enabledPlatforms.map(async (platform) => {
       try {
-        await sendToPlatform(platform, title, message, config, cwd);
-        return { platform, success: true };
+        const effectivePriority = await sendToPlatform(platform, title, message, config, cwd, priority);
+        return { platform, success: true, ...effectivePriority === void 0 ? {} : { priority: effectivePriority } };
       } catch (err) {
         if (err instanceof SuppressedError2) {
           return { platform, success: true, suppressed: true };
@@ -23770,14 +23875,21 @@ async function dispatchNotification(pi, title, message, eventPlatforms, eventTyp
   });
   return { results, allSuccess };
 }
-async function sendToPlatform(platform, title, message, config, cwd) {
+function mapNotifyPriority(platform, priority) {
+  const mappings = {
+    gotify: { low: 2, normal: 5, high: 8 },
+    ntfy: { low: 2, normal: 3, high: 5 }
+  };
+  return mappings[platform][priority];
+}
+async function sendToPlatform(platform, title, message, config, cwd, priority) {
   switch (platform) {
     case "native":
       await sendNativeNotification(title, message, {
         windowsAppId: config.native.windowsAppId,
         suppressWhenFocused: config.native.suppressWhenFocused
       });
-      break;
+      return void 0;
     case "gotify":
       if (!config.gotify.serverUrl || !config.gotify.appToken) {
         throw new Error("Gotify: serverUrl and appToken are required");
@@ -23787,9 +23899,9 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         config.gotify.appToken,
         title,
         message,
-        config.gotify.priority
+        priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority
       );
-      break;
+      return priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority;
     case "telegram":
       if (!config.telegram.botToken || !config.telegram.chatId) {
         throw new Error("Telegram: botToken and chatId are required");
@@ -23800,10 +23912,10 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         title,
         message
       );
-      break;
+      return void 0;
     case "ntfy": {
       const ntfyConfig = loadNtfyConfig(cwd);
-      if (!ntfyConfig.enabled) return;
+      if (!ntfyConfig.enabled) return void 0;
       if (!ntfyConfig.serverUrl || !ntfyConfig.topic) {
         throw new Error("ntfy: serverUrl and topic are required");
       }
@@ -23812,10 +23924,10 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         ntfyConfig.topic,
         title,
         message,
-        ntfyConfig.priority,
+        priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority,
         ntfyConfig.token
       );
-      break;
+      return priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority;
     }
   }
 }
@@ -23944,7 +24056,6 @@ var NotifyUserSchema = Type6.Object({
   priority: Type6.Optional(
     Type6.String({
       enum: ["low", "normal", "high"],
-      default: "normal",
       description: "Priority level"
     })
   ),
@@ -23965,23 +24076,31 @@ function registerNotifyTools(pi) {
       const {
         message,
         title,
-        priority: _priority,
+        priority,
         platforms
       } = params;
       const config = loadConfig2();
       const notifTitle = title || "Pi Notification";
       const notifPlatforms = platforms || config.defaultPlatforms;
       const cwd = process.cwd();
-      dispatchNotification(
+      const dispatchPromise = dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
         config,
-        cwd
-      ).catch(() => {
+        cwd,
+        priority
+      );
+      void dispatchPromise.catch(() => {
       });
+      const priorityByPlatform = priority ? Object.fromEntries(
+        notifPlatforms.flatMap((platform) => {
+          if (platform === "gotify" || platform === "ntfy") return [[platform, mapNotifyPriority(platform, priority)]];
+          return [];
+        })
+      ) : void 0;
       return {
         content: [
           {
@@ -23989,7 +24108,7 @@ function registerNotifyTools(pi) {
             text: `Notification sending to ${notifPlatforms.length} platform(s): ${notifPlatforms.join(", ")}`
           }
         ],
-        details: { platforms: notifPlatforms }
+        details: { platforms: notifPlatforms, priority, priorityByPlatform }
       };
     }
   });
@@ -26116,7 +26235,7 @@ ${results.join("\n")}`, "info");
 }
 
 // packages/notify/index.ts
-var VERSION9 = getPackageVersion(dirname22(fileURLToPath10(import.meta.url)));
+var VERSION9 = getPackageVersion(dirname21(fileURLToPath10(import.meta.url)));
 function notify_default(pi) {
   registerNotifyTools(pi);
   registerNotifyCommands(pi);
@@ -26145,6 +26264,9 @@ init_core();
 init_core();
 import * as fs14 from "node:fs";
 import * as path13 from "node:path";
+import {
+  buildSessionContext as buildSessionContext3
+} from "@earendil-works/pi-coding-agent";
 
 // packages/milestone/milestone.ts
 init_core();
@@ -26290,7 +26412,7 @@ function getProgressSummary(filePath) {
 }
 
 // packages/milestone/hooks.ts
-var sessionStartMs = 0;
+var MILESTONE_SNAPSHOT_TYPE = "unipi-milestone-snapshot";
 function formatMilestoneContext(filePath) {
   const summary = getProgressSummary(filePath);
   if (summary.totalItems === 0) return null;
@@ -26303,16 +26425,67 @@ function formatMilestoneContext(filePath) {
     focus
   ].filter(Boolean).join("\n");
 }
+function formatMilestoneSnapshot(workspace, context) {
+  return [
+    "# UniPi Milestone Snapshot",
+    "This snapshot supersedes all prior UniPi milestone snapshots; use only this snapshot for milestone status.",
+    `Workspace: ${workspace}`,
+    `Status: ${context ? "active" : "inactive"}`,
+    context ?? "No milestones are active for this workspace."
+  ].join("\n\n");
+}
+function latestEffectiveSnapshot(branch) {
+  const messages = buildSessionContext3(branch).messages;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.role === "custom" && message.customType === MILESTONE_SNAPSHOT_TYPE) {
+      return {
+        content: message.content,
+        details: message.details
+      };
+    }
+  }
+  return void 0;
+}
+function latestHistoricalSnapshot(branch) {
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type === "custom_message" && entry.customType === MILESTONE_SNAPSHOT_TYPE) {
+      return {
+        content: entry.content,
+        details: entry.details
+      };
+    }
+  }
+  return void 0;
+}
+function isActiveSnapshot2(snapshot) {
+  if (typeof snapshot.details?.active === "boolean") return snapshot.details.active;
+  return typeof snapshot.content === "string" && snapshot.content.includes("Status: active");
+}
 function registerSessionStartHook(pi) {
-  pi.on("before_agent_start", (event) => {
-    sessionStartMs = Date.now();
-    const cwd = process.cwd();
-    const milestonesPath = path13.join(cwd, MILESTONE_DIRS.MILESTONES);
+  pi.on("before_agent_start", (_event, ctx) => {
+    const workspace = ctx.cwd;
+    const milestonesPath = path13.join(workspace, MILESTONE_DIRS.MILESTONES);
     const context = formatMilestoneContext(milestonesPath);
-    if (!context) return void 0;
-    const currentPrompt = event.systemPrompt ?? "";
+    const branch = ctx.sessionManager.getBranch();
+    const latest = latestEffectiveSnapshot(branch);
+    const historical = latestHistoricalSnapshot(branch);
+    if (!context && !latest && !historical) return void 0;
+    const prior = latest ?? historical;
+    if (!context && prior && !isActiveSnapshot2(prior)) return void 0;
+    const content = formatMilestoneSnapshot(workspace, context);
+    if (latest?.content === content) return void 0;
     return {
-      systemPrompt: currentPrompt + "\n\n" + context
+      message: {
+        customType: MILESTONE_SNAPSHOT_TYPE,
+        content,
+        display: false,
+        details: {
+          active: context !== null,
+          workspace
+        }
+      }
     };
   });
 }
@@ -26368,14 +26541,16 @@ function scanModifiedDocs(dirs, since) {
 }
 function registerSessionEndHook(pi) {
   const baselineSnapshots = /* @__PURE__ */ new Map();
-  pi.on("session_start", () => {
+  let sessionStartMs = 0;
+  let sessionWorkspace = null;
+  pi.on("session_start", (_event, ctx) => {
     sessionStartMs = Date.now();
+    sessionWorkspace = ctx.cwd;
     baselineSnapshots.clear();
-    const cwd = process.cwd();
     const scanDirs = [
-      path13.join(cwd, ".unipi/docs/specs"),
-      path13.join(cwd, ".unipi/docs/plans"),
-      path13.join(cwd, ".unipi/docs/quick-work")
+      path13.join(sessionWorkspace, ".unipi/docs/specs"),
+      path13.join(sessionWorkspace, ".unipi/docs/plans"),
+      path13.join(sessionWorkspace, ".unipi/docs/quick-work")
     ];
     for (const dir of scanDirs) {
       if (!fs14.existsSync(dir)) continue;
@@ -26388,17 +26563,14 @@ function registerSessionEndHook(pi) {
       }
     }
   });
-  pi.on("input", (event) => {
-    return void 0;
-  });
-  pi.on("session_shutdown", () => {
-    const cwd = process.cwd();
-    const milestonesPath = path13.join(cwd, MILESTONE_DIRS.MILESTONES);
+  const syncModifiedDocs = () => {
+    if (!sessionWorkspace) return;
+    const milestonesPath = path13.join(sessionWorkspace, MILESTONE_DIRS.MILESTONES);
     if (!fs14.existsSync(milestonesPath)) return;
     const scanDirs = [
-      path13.join(cwd, ".unipi/docs/specs"),
-      path13.join(cwd, ".unipi/docs/plans"),
-      path13.join(cwd, ".unipi/docs/quick-work")
+      path13.join(sessionWorkspace, ".unipi/docs/specs"),
+      path13.join(sessionWorkspace, ".unipi/docs/plans"),
+      path13.join(sessionWorkspace, ".unipi/docs/quick-work")
     ];
     const modifiedFiles = scanModifiedDocs(scanDirs, sessionStartMs);
     for (const filePath of modifiedFiles) {
@@ -26409,15 +26581,17 @@ function registerSessionEndHook(pi) {
         updateItemStatus(milestonesPath, phase, text, true);
       }
     }
-  });
+  };
+  pi.events.on(UNIPI_EVENTS.WORKFLOW_END, syncModifiedDocs);
+  pi.on("session_shutdown", syncModifiedDocs);
 }
 
 // packages/milestone/commands.ts
 init_core();
-import { dirname as dirname23, join as join26 } from "node:path";
+import { dirname as dirname22, join as join26 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 import { readFileSync as readFileSync21 } from "node:fs";
-var SKILLS_DIR = join26(dirname23(fileURLToPath11(import.meta.url)), "skills");
+var SKILLS_DIR = join26(dirname22(fileURLToPath11(import.meta.url)), "skills");
 function loadSkill(skillName) {
   try {
     return readFileSync21(join26(SKILLS_DIR, skillName, "SKILL.md"), "utf-8");
@@ -26644,9 +26818,9 @@ var KanboardServer = class {
   }
   /** Bind server to a port */
   listen(port) {
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       this.server.once("error", reject);
-      this.server.listen(port, () => resolve13());
+      this.server.listen(port, () => resolve14());
     });
   }
   /** Handle incoming HTTP request */
@@ -27615,11 +27789,11 @@ function markAutoCompactionError(state, nowMs) {
 }
 
 // packages/compactor/src/session/db.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync32, mkdirSync as mkdirSync20 } from "node:fs";
 import { homedir as homedir21 } from "node:os";
-import { dirname as dirname26, join as join33 } from "node:path";
+import { dirname as dirname25, join as join33 } from "node:path";
 function getWorktreeSuffix() {
   const envSuffix = process.env.COMPACTOR_SESSION_SUFFIX;
   if (envSuffix !== void 0) {
@@ -27633,7 +27807,7 @@ function getWorktreeSuffix() {
       { encoding: "utf-8", timeout: 2e3, stdio: ["ignore", "pipe", "ignore"] }
     ).split(/\r?\n/).find((l) => l.startsWith("worktree "))?.replace("worktree ", "")?.trim();
     if (mainWorktree && cwd !== mainWorktree) {
-      const suffix = createHash2("sha256").update(cwd).digest("hex").slice(0, 8);
+      const suffix = createHash3("sha256").update(cwd).digest("hex").slice(0, 8);
       return `__${suffix}`;
     }
   } catch {
@@ -27664,7 +27838,7 @@ var SessionDB = class {
     this.dbPath = opts?.dbPath ?? defaultDBPath("session");
   }
   async init() {
-    const dir = dirname26(this.dbPath);
+    const dir = dirname25(this.dbPath);
     if (!existsSync32(dir)) mkdirSync20(dir, { recursive: true });
     const sqlite = await getSQLite();
     const Database2 = sqlite.Database ?? sqlite.default?.Database ?? sqlite.default ?? sqlite;
@@ -27775,7 +27949,7 @@ var SessionDB = class {
   }
   insertEvent(sessionId, event, sourceHook = "PostToolUse") {
     if (!this.stmts) return;
-    const dataHash = createHash2("sha256").update(event.data).digest("hex").slice(0, 16).toUpperCase();
+    const dataHash = createHash3("sha256").update(event.data).digest("hex").slice(0, 16).toUpperCase();
     const projectDir = String(event.project_dir ?? "").trim();
     const attributionSource = String(event.attribution_source ?? "unknown");
     const rawConfidence = Number(event.attribution_confidence ?? 0);
@@ -27979,8 +28153,49 @@ function extractEventsFromToolResult(result) {
 
 // packages/compactor/src/session/resume-inject.ts
 init_snapshot();
-init_auto_inject();
+
+// packages/compactor/src/session/auto-inject.ts
+var MAX_TOKENS2 = 150;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function buildAutoInjection(events) {
+  const parts = [];
+  let tokenBudget = MAX_TOKENS2;
+  const roleEvents = events.filter((e) => e.category === "rule");
+  if (roleEvents.length > 0) {
+    const directive = roleEvents[roleEvents.length - 1].data;
+    const directiveText = `[Role Directive]
+${directive}`;
+    const tokens = estimateTokens(directiveText);
+    if (tokens <= tokenBudget) {
+      parts.push(directiveText);
+      tokenBudget -= tokens;
+    }
+  }
+  if (tokenBudget > 80) {
+    const intentEvents = events.filter((e) => e.category === "intent");
+    if (intentEvents.length > 0) {
+      const mode = intentEvents[intentEvents.length - 1].data;
+      const modeText = `[Session Mode]
+${mode}`;
+      const tokens = estimateTokens(modeText);
+      if (tokens <= tokenBudget) {
+        parts.push(modeText);
+        tokenBudget -= tokens;
+      }
+    }
+  }
+  if (parts.length === 0) return null;
+  const text = parts.join("\n\n");
+  return { text, tokens: estimateTokens(text) };
+}
+
+// packages/compactor/src/session/resume-inject.ts
 init_manager();
+function isSessionContinuityEnabled(config) {
+  return config.sessionContinuity.enabled && config.sessionContinuity.mode !== "off";
+}
 async function injectResumeSnapshot(db, sessionId, opts) {
   const resume = db.getResume(sessionId);
   if (!resume || resume.consumed) return null;
@@ -28003,11 +28218,22 @@ ${autoInjection}`;
   db.markResumeConsumed(sessionId);
   return fullSnapshot;
 }
+async function buildResumeContextMessage(db, sessionId) {
+  const snapshot = await injectResumeSnapshot(db, sessionId);
+  if (!snapshot) return void 0;
+  return {
+    message: {
+      customType: "unipi-compactor-resume",
+      content: snapshot,
+      display: false
+    }
+  };
+}
 
 // packages/compactor/src/executor/executor.ts
 import { spawn as spawn3, execSync, execFileSync as execFileSync2 } from "node:child_process";
 import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync24, rmSync as rmSync3 } from "node:fs";
-import { join as join34, resolve as resolve10 } from "node:path";
+import { join as join34, resolve as resolve11 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 
 // packages/compactor/src/executor/runtime.ts
@@ -28099,7 +28325,7 @@ var OS_TMPDIR = (() => {
       process.platform === "darwin" ? ["DARWIN_USER_TEMP_DIR"] : ["-u", "-d"],
       { env: { ...process.env, TMPDIR: void 0 }, encoding: "utf-8" }
     ).trim();
-    const dir = process.platform === "darwin" ? result : resolve10(result, "..");
+    const dir = process.platform === "darwin" ? result : resolve11(result, "..");
     if (dir && dir !== process.cwd()) return dir;
   } catch {
   }
@@ -28220,7 +28446,7 @@ var PolyglotExecutor = class {
   async executeFile(opts) {
     const { language, path: path28, timeout = 3e4, background = false } = opts;
     const cmd = buildCommand(this.#runtimes, language, path28);
-    const cwd = language === "shell" ? this.#projectRoot : resolve10(path28, "..");
+    const cwd = language === "shell" ? this.#projectRoot : resolve11(path28, "..");
     return this.#spawn(cmd, cwd, "", timeout, background);
   }
   #writeScript(tmpDir, code, language) {
@@ -28243,7 +28469,7 @@ var PolyglotExecutor = class {
     return filePath;
   }
   async #spawn(cmd, cwd, tmpDir, timeout, background) {
-    return new Promise((resolve13) => {
+    return new Promise((resolve14) => {
       const proc = spawn3(cmd[0], cmd.slice(1), {
         cwd,
         env: sanitizeEnv(),
@@ -28279,14 +28505,14 @@ var PolyglotExecutor = class {
       }, timeout);
       proc.on("error", (err) => {
         if (timer) clearTimeout(timer);
-        resolve13({ stdout, stderr: err.message, exitCode: 1, timedOut: false });
+        resolve14({ stdout, stderr: err.message, exitCode: 1, timedOut: false });
       });
       proc.on("close", (code) => {
         if (timer) clearTimeout(timer);
         if (background && proc.pid) {
           this.#backgroundedPids.add(proc.pid);
         }
-        resolve13({
+        resolve14({
           stdout: stdout.slice(0, this.#hardCapBytes),
           stderr: stderr.slice(0, this.#hardCapBytes),
           exitCode: code ?? 0,
@@ -28324,7 +28550,7 @@ init_core();
 init_hooks();
 
 // packages/compactor/src/compaction/search-entries.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function tokenize(text) {
   return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1);
 }
@@ -28368,7 +28594,7 @@ function searchEntries(blocks, query, opts) {
     kind: b.kind
   }));
   const hashSource = docs.length > 0 ? `${docs.length}:${docs[0].text.slice(0, 80)}:${docs[docs.length - 1].text.slice(-80)}` : "empty";
-  const currentHash = createHash4("sha256").update(hashSource).digest("hex");
+  const currentHash = createHash5("sha256").update(hashSource).digest("hex");
   let index;
   let docCount;
   let avgDocLen;
@@ -28811,8 +29037,7 @@ function compactTool() {
 }
 
 // packages/compactor/src/tools/ctx-execute.ts
-async function ctxExecute(input) {
-  const executor = new PolyglotExecutor();
+async function ctxExecute(input, executor = new PolyglotExecutor()) {
   return executor.execute({
     language: input.language,
     code: input.code,
@@ -28822,12 +29047,11 @@ async function ctxExecute(input) {
 
 // packages/compactor/src/tools/ctx-execute-file.ts
 import { readFileSync as readFileSync30 } from "node:fs";
-async function ctxExecuteFile(input) {
+async function ctxExecuteFile(input, executor = new PolyglotExecutor()) {
   const content = readFileSync30(input.path, "utf-8");
   const code = `const FILE_CONTENT = ${JSON.stringify(content)};
 // User script follows:
 `;
-  const executor = new PolyglotExecutor();
   return executor.executeFile({
     language: input.language,
     path: input.path,
@@ -28837,9 +29061,8 @@ async function ctxExecuteFile(input) {
 }
 
 // packages/compactor/src/tools/ctx-batch-execute.ts
-async function ctxBatchExecute(items) {
+async function ctxBatchExecute(items, executor = new PolyglotExecutor()) {
   const results = [];
-  const executor = new PolyglotExecutor();
   for (const item of items) {
     if (item.type === "execute") {
       const result = await executor.execute({
@@ -29024,74 +29247,85 @@ ${lines.join("\n\n")}`,
     deprecationLog2("vcc_recall", "session_recall");
     return recallExec(tcId, p);
   } });
-  const sandboxExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+  if (deps.sandbox) {
+    const { executor, allowedLanguages } = deps.sandbox;
+    const assertAllowedLanguage = (language) => {
+      if (!allowedLanguages.includes(language)) {
+        throw new Error(`Language "${language}" is disabled by Compactor sandbox settings. Allowed: ${allowedLanguages.join(", ") || "none"}`);
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxExecute(params);
-      const parts = [];
-      if (result.stdout) parts.push(result.stdout);
-      if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
-      if (result.timedOut) parts.push("[timed out]");
-      if (result.exitCode !== 0) parts.push(`[exit code: ${result.exitCode}]`);
-      return textResult2(parts.join("\n") || "(no output)", result);
-    } catch (err) {
-      return textResult2(`Execution error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox", label: "Sandbox", description: "Run code in a sandboxed environment. Supports 11 languages. Only stdout enters context.", parameters: SandboxParams, execute: sandboxExec });
-  pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId, p) {
-    deprecationLog2("ctx_execute", "sandbox");
-    return sandboxExec(tcId, p);
-  } });
-  const sandboxFileExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+    };
+    const sandboxExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        assertAllowedLanguage(params.language);
+        const result = await ctxExecute(params, executor);
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
+        if (result.timedOut) parts.push("[timed out]");
+        if (result.exitCode !== 0) parts.push(`[exit code: ${result.exitCode}]`);
+        return textResult2(parts.join("\n") || "(no output)", result);
+      } catch (err) {
+        return textResult2(`Execution error: ${err}`, { error: true });
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxExecuteFile(params);
-      const parts = [];
-      if (result.stdout) parts.push(result.stdout);
-      if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
-      if (result.timedOut) parts.push("[timed out]");
-      return textResult2(parts.join("\n") || "(no output)", result);
-    } catch (err) {
-      return textResult2(`Execution error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec });
-  pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId, p) {
-    deprecationLog2("ctx_execute_file", "sandbox_file");
-    return sandboxFileExec(tcId, p);
-  } });
-  const sandboxBatchExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+    };
+    pi.registerTool({ name: "sandbox", label: "Sandbox", description: "Run code in a sandboxed environment. Supports 11 languages. Only stdout enters context.", parameters: SandboxParams, execute: sandboxExec });
+    pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId, p) {
+      deprecationLog2("ctx_execute", "sandbox");
+      return sandboxExec(tcId, p);
+    } });
+    const sandboxFileExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        assertAllowedLanguage(params.language);
+        const result = await ctxExecuteFile(params, executor);
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
+        if (result.timedOut) parts.push("[timed out]");
+        return textResult2(parts.join("\n") || "(no output)", result);
+      } catch (err) {
+        return textResult2(`Execution error: ${err}`, { error: true });
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxBatchExecute(params.items);
-      const summaries = result.results.map((r, i) => {
-        const s = r.result.stdout?.slice(0, 200) || "(no output)";
-        return `[${i}] execute \u2192 ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
-      });
-      return textResult2(`Batch results (${result.results.length} items):
+    };
+    pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec });
+    pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId, p) {
+      deprecationLog2("ctx_execute_file", "sandbox_file");
+      return sandboxFileExec(tcId, p);
+    } });
+    const sandboxBatchExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        for (const item of params.items) assertAllowedLanguage(item.language);
+        const result = await ctxBatchExecute(params.items, executor);
+        const summaries = result.results.map((r, i) => {
+          const s = r.result.stdout?.slice(0, 200) || "(no output)";
+          return `[${i}] execute \u2192 ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
+        });
+        return textResult2(`Batch results (${result.results.length} items):
 ${summaries.join("\n")}`, result);
-    } catch (err) {
-      return textResult2(`Batch error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec });
-  pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId, p) {
-    deprecationLog2("ctx_batch_execute", "sandbox_batch");
-    return sandboxBatchExec(tcId, p);
-  } });
+      } catch (err) {
+        return textResult2(`Batch error: ${err}`, { error: true });
+      }
+    };
+    pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec });
+    pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId, p) {
+      deprecationLog2("ctx_batch_execute", "sandbox_batch");
+      return sandboxBatchExec(tcId, p);
+    } });
+  }
   const statsExec = async () => {
     try {
       const result = await ctxStats(deps.sessionDB, deps.getSessionId(), deps.getCounters?.());
@@ -29187,9 +29421,6 @@ function measureResponseBytes(event) {
 function isSandboxTool(name) {
   return name === "bash" || name === "Bash";
 }
-function isIndexTool(_name) {
-  return false;
-}
 function compactorExtension(pi) {
   let sessionDB = null;
   let executor = null;
@@ -29207,7 +29438,6 @@ function compactorExtension(pi) {
   const getCounters = () => counters;
   const runtimeStats = {
     bytesReturned: {},
-    bytesIndexed: 0,
     bytesSandboxed: 0,
     calls: {},
     sessionStart: Date.now(),
@@ -29225,7 +29455,7 @@ function compactorExtension(pi) {
     } catch {
       sessionDB = null;
     }
-    executor = new PolyglotExecutor();
+    executor = null;
   };
   registerCompactionHooks(pi, {
     getSessionDB: () => sessionDB,
@@ -29254,7 +29484,6 @@ function compactorExtension(pi) {
       }
     }
     runtimeStats.bytesReturned = {};
-    runtimeStats.bytesIndexed = 0;
     runtimeStats.bytesSandboxed = 0;
     runtimeStats.calls = {};
     runtimeStats.sessionStart = Date.now();
@@ -29263,11 +29492,17 @@ function compactorExtension(pi) {
     autoCompactionState = createAutoCompactionState();
     sessionDB?.ensureSession(fullSessionId, projectDir);
     if (sessionDB) {
+      const sandboxEnabled = config.sandboxExecution.enabled && config.sandboxExecution.mode !== "off";
+      executor = sandboxEnabled ? new PolyglotExecutor({ hardCapBytes: config.sandboxExecution.outputLimit, projectRoot: projectDir }) : null;
       registerCompactorTools(pi, {
         sessionDB,
         getSessionId: () => currentSessionId,
         getBlocks: () => cachedBlocks,
-        getCounters
+        getCounters,
+        sandbox: executor ? {
+          executor,
+          allowedLanguages: config.sandboxExecution.allowedLanguages
+        } : void 0
       });
     }
     registerCommands4(pi, getCommandDeps());
@@ -29353,21 +29588,11 @@ function compactorExtension(pi) {
       }
     } catch {
     }
-    if (sessionDB) {
-      const snapshot = await injectResumeSnapshot(sessionDB, currentSessionId);
-      debug("resume_snapshot", { injected: !!snapshot });
-      if (snapshot && sessionDB) {
-        try {
-          const { buildAutoInjection: buildAutoInjection2 } = await Promise.resolve().then(() => (init_auto_inject(), auto_inject_exports));
-          const events = sessionDB.getEvents(currentSessionId, { limit: 100 });
-          const autoInjection = buildAutoInjection2(events);
-          if (autoInjection) {
-            debug("auto_injection", { tokens: autoInjection.tokens, length: autoInjection.text.length });
-          }
-        } catch (err) {
-          debug("auto_injection_error", { error: String(err) });
-        }
-      }
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
+      const resumeContext = await buildResumeContextMessage(sessionDB, currentSessionId);
+      debug("resume_snapshot", { injected: !!resumeContext });
+      return resumeContext;
     }
   });
   pi.on("turn_end", async (_event, ctx) => {
@@ -29423,7 +29648,8 @@ function compactorExtension(pi) {
     }
   });
   pi.on("session_before_compact", async (event, _ctx) => {
-    if (sessionDB) {
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
       const sessionId = currentSessionId;
       const events = sessionDB.getEvents(sessionId, { limit: 1e3 });
       const stats = sessionDB.getSessionStats(sessionId);
@@ -29442,12 +29668,18 @@ function compactorExtension(pi) {
       counters.compactions++;
       const compactionEntry = event.compactionEntry;
       const tokensBefore = compactionEntry?.tokensBefore ?? 0;
+      let summarized = 0;
+      let kept = 0;
+      let tokensSaved = 0;
       if (tokensBefore > 0) {
         const charsBefore = tokensBefore * 4;
-        const tokensAfter = event.tokensAfter ?? Math.round(tokensBefore * 0.12);
+        const tokensAfter = Math.round(tokensBefore * 0.12);
+        kept = tokensAfter;
+        tokensSaved = tokensBefore - tokensAfter;
         const charsKept = tokensAfter * 4;
         const messagesSummarized = Math.max(1, Math.round(tokensBefore / 500));
-        counters.totalTokensCompacted += tokensBefore - tokensAfter;
+        summarized = messagesSummarized;
+        counters.totalTokensCompacted += tokensSaved;
         sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
       } else {
         try {
@@ -29457,12 +29689,23 @@ function compactorExtension(pi) {
             const estTokensAfter = Math.round(estTokensBefore * 0.12);
             const charsBefore = estTokensBefore * 4;
             const charsKept = estTokensAfter * 4;
-            counters.totalTokensCompacted += estTokensBefore - estTokensAfter;
+            summarized = eventCount;
+            kept = estTokensAfter;
+            tokensSaved = estTokensBefore - estTokensAfter;
+            counters.totalTokensCompacted += tokensSaved;
             sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, eventCount);
           }
         } catch {
         }
       }
+      const totalEstimated = tokensSaved + kept;
+      emitEvent(pi, UNIPI_EVENTS.COMPACTOR_COMPACTED, {
+        sessionId,
+        summarized,
+        kept,
+        tokensSaved,
+        compressionRatio: kept > 0 ? `${Math.round(totalEstimated / kept)}:1` : "0:1"
+      });
       debug("session_compact", { sessionId, tokensBefore, hasCompactionEntry: !!compactionEntry });
     }
   });
@@ -29554,30 +29797,10 @@ function compactorExtension(pi) {
         if (isSandboxTool(tName)) {
           runtimeStats.bytesSandboxed += responseBytes;
         }
-        if (isIndexTool(tName)) {
-          runtimeStats.bytesIndexed += responseBytes;
-        }
       }
     } catch {
     }
     const toolName = event.toolName ?? "";
-    const td = config.toolDisplay;
-    const toolConfig = {
-      readOutputMode: td?.mode,
-      searchOutputMode: td?.mode,
-      bashOutputMode: td?.mode,
-      previewLines: 20,
-      bashCollapsedLines: 5,
-      showTruncationHints: true
-    };
-    try {
-      const { applyToolDisplayOverride: applyToolDisplayOverride2 } = await Promise.resolve().then(() => (init_tool_overrides(), tool_overrides_exports));
-      const override = applyToolDisplayOverride2(toolName, event, toolConfig);
-      if (override !== void 0) {
-        return override;
-      }
-    } catch {
-    }
     const diffToolNames = ["edit", "Edit", "write", "Write"];
     if (diffToolNames.includes(toolName)) {
       try {
@@ -30886,14 +31109,6 @@ var FooterRenderer = class _FooterRenderer {
 init_core();
 function subscribeToEvents(pi, registry3) {
   const unsubscribers = [];
-  unsubscribers.push(
-    pi.events.on(UNIPI_EVENTS.COMPACTOR_STATS_UPDATED, (event) => {
-      try {
-        registry3.updateData("compactor", event);
-      } catch {
-      }
-    })
-  );
   unsubscribers.push(
     pi.events.on(UNIPI_EVENTS.COMPACTOR_COMPACTED, (event) => {
       try {
@@ -32865,7 +33080,7 @@ import { Key as Key6, matchesKey as matchesKey14, truncateToWidth as truncateToW
 // packages/updater/src/readme.ts
 init_core();
 init_core();
-import { dirname as dirname28 } from "node:path";
+import { dirname as dirname27 } from "node:path";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { existsSync as existsSync39, readFileSync as readFileSync34 } from "fs";
 import { join as join38 } from "path";
@@ -32892,7 +33107,7 @@ var PACKAGE_MAP = {
   updater: MODULES.UPDATER
 };
 function resolveUnipiRoot() {
-  const dir = dirname28(fileURLToPath12(import.meta.url));
+  const dir = dirname27(fileURLToPath12(import.meta.url));
   const root = findPackageRoot(dir, "@pi-unipi/unipi");
   return root ?? join38(dir, "..");
 }
@@ -33229,7 +33444,7 @@ import { Key as Key7, matchesKey as matchesKey15, truncateToWidth as truncateToW
 // packages/updater/src/changelog.ts
 init_core();
 import { existsSync as existsSync40, readFileSync as readFileSync36 } from "fs";
-import { dirname as dirname29, join as join39 } from "node:path";
+import { dirname as dirname28, join as join39 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 
 // packages/updater/src/version.ts
@@ -33254,7 +33469,7 @@ function isNewerVersion(latest, current) {
 // packages/updater/src/changelog.ts
 function resolveChangelogPath() {
   try {
-    const dir = dirname29(fileURLToPath13(import.meta.url));
+    const dir = dirname28(fileURLToPath13(import.meta.url));
     const root = findPackageRoot(dir, "@pi-unipi/unipi");
     if (root) {
       const packaged = join39(root, "CHANGELOG.md");
@@ -33515,7 +33730,7 @@ function renderChangelogOverlay() {
 // packages/updater/src/settings.ts
 init_core();
 import { readFileSync as readFileSync37, writeFileSync as writeFileSync26, mkdirSync as mkdirSync22, existsSync as existsSync42 } from "fs";
-import { dirname as dirname30, join as join40 } from "path";
+import { dirname as dirname29, join as join40 } from "path";
 import { homedir as homedir24 } from "os";
 var DEFAULT_CONFIG6 = {
   checkIntervalMs: 36e5,
@@ -33547,7 +33762,7 @@ function loadConfig5() {
 }
 function saveConfig4(config) {
   const configPath = resolveConfigPath2();
-  const dir = dirname30(configPath);
+  const dir = dirname29(configPath);
   mkdirSync22(dir, { recursive: true });
   writeFileSync26(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
@@ -33783,7 +33998,7 @@ init_core();
 // packages/updater/src/cache.ts
 init_core();
 import { readFileSync as readFileSync38, writeFileSync as writeFileSync27, mkdirSync as mkdirSync23, existsSync as existsSync43 } from "fs";
-import { dirname as dirname31, join as join41 } from "path";
+import { dirname as dirname30, join as join41 } from "path";
 import { homedir as homedir25 } from "os";
 function resolveCachePath() {
   const base = UPDATER_DIRS.CACHE.replace("~", homedir25());
@@ -33805,7 +34020,7 @@ function readLastCheck() {
 }
 function writeLastCheck(cache) {
   const cachePath = resolveCachePath();
-  const dir = dirname31(cachePath);
+  const dir = dirname30(cachePath);
   mkdirSync23(dir, { recursive: true });
   writeFileSync27(cachePath, JSON.stringify(cache, null, 2) + "\n", "utf-8");
 }
@@ -34215,8 +34430,8 @@ init_core();
 import { Key as Key10 } from "@earendil-works/pi-tui";
 
 // packages/input-shortcuts/src/registers.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync24, readFileSync as readFileSync39, renameSync as renameSync7, writeFileSync as writeFileSync28 } from "node:fs";
-import { dirname as dirname32, join as join42 } from "node:path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync24, readFileSync as readFileSync39, renameSync as renameSync8, writeFileSync as writeFileSync28 } from "node:fs";
+import { dirname as dirname31, join as join42 } from "node:path";
 
 // packages/input-shortcuts/src/types.ts
 var DEFAULT_CONFIG7 = {
@@ -34286,13 +34501,13 @@ var RegisterStore = class {
   /** Atomic write: write to .tmp then rename. */
   save() {
     try {
-      const dir = dirname32(this.filePath);
+      const dir = dirname31(this.filePath);
       if (!existsSync44(dir)) {
         mkdirSync24(dir, { recursive: true });
       }
       const tmpPath = this.filePath + ".tmp";
       writeFileSync28(tmpPath, JSON.stringify(this.data, null, 2), "utf-8");
-      renameSync7(tmpPath, this.filePath);
+      renameSync8(tmpPath, this.filePath);
     } catch {
     }
   }
@@ -34513,8 +34728,8 @@ var ChordOverlay = class extends Container2 {
 
 // packages/input-shortcuts/src/settings-overlay.ts
 import { SettingsList as SettingsList3 } from "@earendil-works/pi-tui";
-import { existsSync as existsSync45, mkdirSync as mkdirSync25, readFileSync as readFileSync40, renameSync as renameSync8, writeFileSync as writeFileSync29 } from "node:fs";
-import { dirname as dirname33, join as join43 } from "node:path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync25, readFileSync as readFileSync40, renameSync as renameSync9, writeFileSync as writeFileSync29 } from "node:fs";
+import { dirname as dirname32, join as join43 } from "node:path";
 var ALT_KEY_OPTIONS = [
   "alt+a",
   "alt+b",
@@ -34563,13 +34778,13 @@ function loadConfig6(baseDir) {
 function saveConfig5(config, baseDir) {
   const filePath = baseDir ? join43(baseDir, CONFIG_FILE) : CONFIG_FILE;
   try {
-    const dir = dirname33(filePath);
+    const dir = dirname32(filePath);
     if (!existsSync45(dir)) {
       mkdirSync25(dir, { recursive: true });
     }
     const tmpPath = filePath + ".tmp";
     writeFileSync29(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-    renameSync8(tmpPath, filePath);
+    renameSync9(tmpPath, filePath);
   } catch {
   }
 }
@@ -34997,7 +35212,7 @@ import { Type as Type8 } from "typebox";
 // packages/cocoindex/bridge.ts
 init_core();
 import { execFileSync as execFileSync3, spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync46, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync30, readdirSync as readdirSync13, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync46, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync30, readdirSync as readdirSync14, statSync as statSync9 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
 import { join as join44 } from "node:path";
 var DEFAULT_PIPELINE_DIR = ".unipi/cocoindex";
@@ -35073,7 +35288,7 @@ function resolveCocoindexBin() {
   if (existsSync46(uvToolBin)) return uvToolBin;
   const miseRoot = join44(homedir26(), ".local", "share", "mise", "installs", "python");
   try {
-    const versions = readdirSync13(miseRoot).sort().reverse();
+    const versions = readdirSync14(miseRoot).sort().reverse();
     for (const ver of versions) {
       const binPath = join44(miseRoot, ver, "bin", "cocoindex");
       if (existsSync46(binPath)) return binPath;
@@ -35136,7 +35351,7 @@ async function indexProject(projectDir) {
   }
   const start = Date.now();
   const cocoindexBin = resolveCocoindexBin();
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const proc = spawn4(cocoindexBin, ["update", "main.py"], {
       cwd: pipelineDir,
       stdio: ["pipe", "pipe", "pipe"]
@@ -35166,9 +35381,9 @@ async function indexProject(projectDir) {
       const durationMs = Date.now() - start;
       const chunksProcessed = parseChunksProcessed(stdout);
       if (code === 0) {
-        resolve13({ success: true, chunksProcessed, durationMs });
+        resolve14({ success: true, chunksProcessed, durationMs });
       } else {
-        resolve13({
+        resolve14({
           success: false,
           chunksProcessed,
           durationMs,
@@ -35179,7 +35394,7 @@ async function indexProject(projectDir) {
     proc.on("error", (err) => {
       settled = true;
       clearTimeout(timer);
-      resolve13({
+      resolve14({
         success: false,
         chunksProcessed: 0,
         durationMs: Date.now() - start,
@@ -35244,9 +35459,9 @@ async function status(projectDir) {
   const lancedbPath = join44(pipelineDir, ".lancedb");
   if (existsSync46(lancedbPath)) {
     try {
-      const stat = statSync8(lancedbPath);
+      const stat = statSync9(lancedbPath);
       lastRun = stat.mtime.toISOString();
-      const files = readdirSync13(lancedbPath, { recursive: true });
+      const files = readdirSync14(lancedbPath, { recursive: true });
       docCount = files.filter((f) => f.endsWith(".lance")).length;
     } catch {
     }
@@ -35906,7 +36121,7 @@ function buildUvInstallerFallback(shell) {
   ];
 }
 function runStep(step) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const proc = spawn5(step.command, step.args ?? [], {
       stdio: ["ignore", "pipe", "pipe"],
       env: installerEnv()
@@ -35929,12 +36144,12 @@ Timed out after ${step.timeoutMs ?? DEFAULT_STEP_TIMEOUT_MS}ms.`;
     proc.on("close", (code, signal) => {
       settled = true;
       clearTimeout(timeout);
-      resolve13({ ok: code === 0, stdout, stderr, exitCode: code, signal });
+      resolve14({ ok: code === 0, stdout, stderr, exitCode: code, signal });
     });
     proc.on("error", (err) => {
       settled = true;
       clearTimeout(timeout);
-      resolve13({ ok: false, stdout, stderr: stderr || err.message });
+      resolve14({ ok: false, stdout, stderr: stderr || err.message });
     });
   });
 }
@@ -36136,7 +36351,7 @@ function cocoindexExtension(pi) {
 
 // packages/image/src/index.ts
 init_core();
-import { dirname as dirname35 } from "node:path";
+import { dirname as dirname34 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 
 // packages/image/src/commands.ts
@@ -37890,7 +38105,7 @@ function currentSessionModel(ctx) {
 }
 
 // packages/image/src/index.ts
-var VERSION11 = getPackageVersion(dirname35(fileURLToPath14(import.meta.url)));
+var VERSION11 = getPackageVersion(dirname34(fileURLToPath14(import.meta.url)));
 function getInfoRegistry6() {
   return globalThis.__unipi_info_registry;
 }