@pi-unipi/unipi 2.4.2 → 2.6.0

package/packages/unipi/bundled.js

@@ -162,7 +162,8 @@ var init_constants = __esm({
       BADGE_GEN: "badge-gen",
       BADGE_TOGGLE: "badge-toggle",
       BADGE_SETTINGS: "badge-settings",
-      UTIL_SETTINGS: "util-settings"
+      UTIL_SETTINGS: "util-settings",
+      PREFIX_CACHE: "prefix-cache"
     };
     UTILITY_TOOLS = {
       CONTINUE: "continue_task",
@@ -206,7 +207,8 @@ var init_constants = __esm({
       SYNC_INTERVAL_MS: 864e5,
       STARTUP_TIMEOUT_MS: 1e4,
       MAX_SERVERS: 20,
-      TOOL_NAME_SEPARATOR: "__"
+      TOOL_NAME_SEPARATOR: "__",
+      MAX_MODEL_OUTPUT_BYTES: 64 * 1024
     };
     COMPACTOR_INSTRUCTION = "__compactor__";
     COMPACTOR_TOOLS = {
@@ -758,6 +760,92 @@ var init_tui_width = __esm({
   }
 });
 
+// packages/core/bounded-output.ts
+import { chmodSync, lstatSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+import { randomUUID } from "node:crypto";
+function byteSlice(text, start, end) {
+  return Buffer.from(text, "utf8").subarray(start, end).toString("utf8").replace(/\uFFFD+$/u, "");
+}
+function secureArtifactDir(customDir) {
+  const dir = customDir ?? join3(homedir(), ".unipi", "tool-results");
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  let stat = lstatSync(dir);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Refusing unsafe tool-result directory: ${dir}`);
+  }
+  if ((stat.mode & 63) !== 0) {
+    chmodSync(dir, 448);
+    stat = lstatSync(dir);
+    if ((stat.mode & 63) !== 0) {
+      throw new Error(`Refusing non-private tool-result directory: ${dir}`);
+    }
+  }
+  return dir;
+}
+function safePrefix(prefix) {
+  const safe = prefix.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").slice(0, 48);
+  return safe || "tool-result";
+}
+function boundModelOutput(text, options = {}) {
+  const maxBytes = Math.max(1024, Math.floor(options.maxBytes ?? DEFAULT_MODEL_OUTPUT_BYTES));
+  const originalBytes = Buffer.byteLength(text, "utf8");
+  if (originalBytes <= maxBytes) {
+    return { text, truncated: false, originalBytes, visibleBytes: originalBytes };
+  }
+  let artifactPath;
+  let artifactWarning;
+  if (originalBytes <= MAX_RAW_ARTIFACT_BYTES) {
+    try {
+      const dir = secureArtifactDir(options.artifactDir);
+      artifactPath = join3(dir, `${safePrefix(options.artifactPrefix ?? "tool-result")}-${randomUUID()}.txt`);
+      writeFileSync3(artifactPath, text, { encoding: "utf8", mode: 384, flag: "wx" });
+    } catch (error) {
+      artifactWarning = `Full-output artifact unavailable: ${error instanceof Error ? error.message : String(error)}`;
+      artifactPath = void 0;
+    }
+  } else {
+    artifactWarning = `Full output exceeded the ${MAX_RAW_ARTIFACT_BYTES}-byte local artifact safety cap and was not retained.`;
+  }
+  const marker = [
+    "",
+    "--- output bounded by UniPi ---",
+    artifactPath ? `Full output: ${artifactPath}` : artifactWarning,
+    `Original size: ${originalBytes} bytes; model-visible ceiling: ${maxBytes} bytes.`,
+    ...artifactPath ? ["Use the read tool with offset/limit to inspect only the needed region."] : []
+  ].join("\n");
+  const omissionReserve = 80;
+  const markerBytes = Buffer.byteLength(marker, "utf8");
+  const contentBudget = Math.max(1, maxBytes - markerBytes - omissionReserve);
+  const headBytes = Math.ceil(contentBudget * 0.75);
+  const tailBytes = Math.max(0, contentBudget - headBytes);
+  const head = byteSlice(text, 0, headBytes);
+  const tail2 = tailBytes > 0 ? byteSlice(text, originalBytes - tailBytes) : "";
+  const omission = `
+\u2026 ${Math.max(0, originalBytes - contentBudget)} bytes omitted \u2026
+`;
+  let bounded = `${head}${omission}${tail2}${marker}`;
+  if (Buffer.byteLength(bounded, "utf8") > maxBytes) {
+    bounded = byteSlice(bounded, 0, maxBytes);
+  }
+  return {
+    text: bounded,
+    truncated: true,
+    originalBytes,
+    visibleBytes: Buffer.byteLength(bounded, "utf8"),
+    artifactPath
+  };
+}
+var DEFAULT_MODEL_OUTPUT_BYTES, MAX_RAW_ARTIFACT_BYTES;
+var init_bounded_output = __esm({
+  "packages/core/bounded-output.ts"() {
+    "use strict";
+    DEFAULT_MODEL_OUTPUT_BYTES = 64 * 1024;
+    MAX_RAW_ARTIFACT_BYTES = 16 * 1024 * 1024;
+  }
+});
+
 // packages/core/index.ts
 var core_exports = {};
 __export(core_exports, {
@@ -773,6 +861,7 @@ __export(core_exports, {
   COMPACTOR_DIRS: () => COMPACTOR_DIRS,
   COMPACTOR_INSTRUCTION: () => COMPACTOR_INSTRUCTION,
   COMPACTOR_TOOLS: () => COMPACTOR_TOOLS,
+  DEFAULT_MODEL_OUTPUT_BYTES: () => DEFAULT_MODEL_OUTPUT_BYTES,
   FOOTER_COMMANDS: () => FOOTER_COMMANDS,
   IMAGE_COMMANDS: () => IMAGE_COMMANDS,
   IMAGE_DIRS: () => IMAGE_DIRS,
@@ -781,6 +870,7 @@ __export(core_exports, {
   KANBOARD_COMMANDS: () => KANBOARD_COMMANDS,
   KANBOARD_DEFAULTS: () => KANBOARD_DEFAULTS,
   KANBOARD_DIRS: () => KANBOARD_DIRS,
+  MAX_RAW_ARTIFACT_BYTES: () => MAX_RAW_ARTIFACT_BYTES,
   MCP_COMMANDS: () => MCP_COMMANDS,
   MCP_DEFAULTS: () => MCP_DEFAULTS,
   MCP_DIRS: () => MCP_DIRS,
@@ -815,6 +905,7 @@ __export(core_exports, {
   WORKFLOW_COMMANDS: () => WORKFLOW_COMMANDS,
   WidthKeyedCache: () => WidthKeyedCache,
   adaptiveInnerWidth: () => adaptiveInnerWidth,
+  boundModelOutput: () => boundModelOutput,
   boxInnerWidth: () => boxInnerWidth,
   contentWidth: () => contentWidth,
   emitEvent: () => emitEvent,
@@ -863,17 +954,46 @@ var init_core = __esm({
     init_utils();
     init_model_cache();
     init_tui_width();
+    init_bounded_output();
   }
 });
 
 // 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 +1093,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 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 = {}) {
+function runBridge(install, palace, cmd, args = {}, timeoutMs = 6e4) {
+  const bridgePath = getBridgePath();
+  if (!bridgePath) return null;
   let argsJson;
   try {
     argsJson = JSON.stringify(args);
@@ -992,9 +1166,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 +1187,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 +1216,7 @@ function runBridgeAsync(install, palace, cmd, args = {}) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve13(value);
+      resolve14(value);
     };
     const timer = setTimeout(() => {
       try {
@@ -1045,7 +1224,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 +1244,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 +1253,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 +1353,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 +1365,7 @@ function parseMemoryContent(content) {
 }
 function writeMemoryFile(filePath, record) {
   const frontmatter = {
+    id: record.id,
     title: record.title,
     tags: record.tags,
     project: record.project,
@@ -1405,12 +1585,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 {
           }
         }
@@ -1597,7 +1780,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;
@@ -2239,12 +2422,12 @@ 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 { homedir as homedir5 } from "node:os";
+import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, existsSync as existsSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, renameSync as renameSync3, openSync, readSync, closeSync } from "node:fs";
+import { join as join10, dirname as dirname9 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 function getCachePath() {
-  const base = process.env.UNIPI_DIR || join9(homedir5(), ".unipi");
-  return join9(base, "cache", "usage-stats.json");
+  const base = process.env.UNIPI_DIR || join10(homedir6(), ".unipi");
+  return join10(base, "cache", "usage-stats.json");
 }
 function readCache() {
   const empty = { version: CACHE_VERSION, models: [], files: {} };
@@ -2262,16 +2445,16 @@ function readCache() {
 function writeCache(cache) {
   try {
     const path28 = getCachePath();
-    mkdirSync7(dirname10(path28), { recursive: true });
+    mkdirSync8(dirname9(path28), { recursive: true });
     const tmp = `${path28}.${process.pid}.tmp`;
-    writeFileSync8(tmp, JSON.stringify(cache), "utf-8");
-    renameSync2(tmp, path28);
+    writeFileSync9(tmp, JSON.stringify(cache), "utf-8");
+    renameSync3(tmp, path28);
   } catch {
   }
 }
 function getSessionsDir() {
-  const agentDir = process.env.PI_CODING_AGENT_DIR || join9(homedir5(), ".pi", "agent");
-  return join9(agentDir, "sessions");
+  const agentDir = process.env.PI_CODING_AGENT_DIR || join10(homedir6(), ".pi", "agent");
+  return join10(agentDir, "sessions");
 }
 function getPeriodBounds() {
   const now2 = /* @__PURE__ */ new Date();
@@ -2361,9 +2544,9 @@ 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);
+      const entryPath = join10(dir, entry.name);
       if (entry.isDirectory()) {
         collectSessionFiles(entryPath, files);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -2375,7 +2558,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;
@@ -2411,7 +2594,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 {
@@ -2592,21 +2775,21 @@ __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 { homedir as homedir14 } from "node:os";
+import { existsSync as existsSync18, readdirSync as readdirSync11 } from "node:fs";
+import { join as join20, resolve as resolve6 } from "node:path";
+import { homedir as homedir16 } 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");
+      const scopePath = join20(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");
+          const pkgPath = join20(scopePath, entry, "package.json");
           if (existsSync18(pkgPath)) {
             unipiModules.push(`@pi-unipi/${entry}`);
           }
@@ -2615,8 +2798,8 @@ function getEnvironmentInfo() {
     }
   } catch {
   }
-  const globalConfig = join18(homedir14(), ".unipi", "config");
-  const projectConfig = resolve5(process.cwd(), ".unipi", "config");
+  const globalConfig = join20(homedir16(), ".unipi", "config");
+  const projectConfig = resolve6(process.cwd(), ".unipi", "config");
   if (existsSync18(globalConfig)) {
     configPaths.push(globalConfig);
   }
@@ -2624,7 +2807,7 @@ function getEnvironmentInfo() {
     configPaths.push(projectConfig);
   }
   try {
-    const piDir = join18(homedir14(), ".pi");
+    const piDir = join20(homedir16(), ".pi");
     if (existsSync18(piDir)) {
       extensionPaths.push(piDir);
     }
@@ -3861,11 +4044,11 @@ 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 { existsSync as existsSync31, mkdirSync as mkdirSync21, readFileSync as readFileSync29, writeFileSync as writeFileSync25 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { dirname as dirname24, join as join34 } from "node:path";
 function projectConfigPath(cwd) {
-  return join32(cwd, ".unipi", "config", "compactor.json");
+  return join34(cwd, ".unipi", "config", "compactor.json");
 }
 function deepMerge(base, override) {
   const result = { ...base };
@@ -3900,9 +4083,9 @@ function loadConfig4(cwd) {
 function saveConfig3(config, opts) {
   try {
     const targetPath = opts?.perProject && opts?.cwd ? projectConfigPath(opts.cwd) : COMPACTOR_CONFIG_PATH;
-    const dir = dirname25(targetPath);
-    if (!existsSync31(dir)) mkdirSync19(dir, { recursive: true });
-    writeFileSync23(targetPath, `${JSON.stringify(config, null, 2)}
+    const dir = dirname24(targetPath);
+    if (!existsSync31(dir)) mkdirSync21(dir, { recursive: true });
+    writeFileSync25(targetPath, `${JSON.stringify(config, null, 2)}
 `);
     return { success: true };
   } catch (err) {
@@ -3935,10 +4118,10 @@ function migrateConfig(partial) {
 }
 function scaffoldConfig() {
   try {
-    const dir = dirname25(COMPACTOR_CONFIG_PATH);
-    if (!existsSync31(dir)) mkdirSync19(dir, { recursive: true });
+    const dir = dirname24(COMPACTOR_CONFIG_PATH);
+    if (!existsSync31(dir)) mkdirSync21(dir, { recursive: true });
     if (!existsSync31(COMPACTOR_CONFIG_PATH)) {
-      writeFileSync23(COMPACTOR_CONFIG_PATH, `${JSON.stringify(DEFAULT_COMPACTOR_CONFIG, null, 2)}
+      writeFileSync25(COMPACTOR_CONFIG_PATH, `${JSON.stringify(DEFAULT_COMPACTOR_CONFIG, null, 2)}
 `);
     }
   } catch {
@@ -3949,7 +4132,7 @@ var init_manager = __esm({
   "packages/compactor/src/config/manager.ts"() {
     "use strict";
     init_schema();
-    COMPACTOR_CONFIG_PATH = join32(homedir20(), ".unipi", "config", "compactor", "config.json");
+    COMPACTOR_CONFIG_PATH = join34(homedir22(), ".unipi", "config", "compactor", "config.json");
     readJson3 = (path28) => {
       try {
         return JSON.parse(readFileSync29(path28, "utf-8"));
@@ -5354,7 +5537,6 @@ function buildIntentSection(intentEvents) {
 function buildResumeSnapshot(events, opts) {
   const compactCount = opts?.compactCount ?? 1;
   const searchTool = opts?.searchTool ?? "ctx_search";
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const fileEvents = [];
   const taskEvents = [];
   const ruleEvents = [];
@@ -5430,7 +5612,7 @@ function buildResumeSnapshot(events, opts) {
   if (skills) sections.push(skills);
   const intent = buildIntentSection(intentEvents);
   if (intent) sections.push(intent);
-  const header = `<session_resume events="${events.length}" compact_count="${compactCount}" generated_at="${now2}">`;
+  const header = `<session_resume events="${events.length}" compact_count="${compactCount}">`;
   const footer = `</session_resume>`;
   const body = sections.join("\n\n");
   if (body) {
@@ -5452,9 +5634,9 @@ var init_snapshot = __esm({
 });
 
 // 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);
@@ -6225,7 +6407,7 @@ __export(policy_exports, {
   readsOrCreatesPolicy: () => readsOrCreatesPolicy
 });
 import { existsSync as existsSync36, readFileSync as readFileSync31 } from "node:fs";
-import { join as join35 } from "node:path";
+import { join as join37 } from "node:path";
 function parseBashPattern(pattern) {
   const match = pattern.match(/^Bash\((.+)\)$/);
   return match ? match[1] : null;
@@ -6280,7 +6462,7 @@ function fileGlobToRegex(glob, caseInsensitive = false) {
   return new RegExp(`^${regexStr}$`, caseInsensitive ? "i" : "");
 }
 function readsOrCreatesPolicy(cwd) {
-  const settingsPath = join35(cwd, ".pi", "settings.json");
+  const settingsPath = join37(cwd, ".pi", "settings.json");
   if (!existsSync36(settingsPath)) return { allow: [], deny: [], ask: [] };
   try {
     const settings = JSON.parse(readFileSync31(settingsPath, "utf-8"));
@@ -6309,10 +6491,10 @@ __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 { homedir as homedir22 } from "node:os";
+import { resolve as resolve12, join as join38 } from "node:path";
+import { homedir as homedir24 } from "node:os";
 function loadProjectPermissions(cwd, basePolicy) {
-  const settingsPath = join36(cwd, ".pi", "settings.json");
+  const settingsPath = join38(cwd, ".pi", "settings.json");
   if (!existsSync37(settingsPath)) return basePolicy;
   try {
     const raw = readFileSync32(settingsPath, "utf-8");
@@ -6381,10 +6563,10 @@ 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();
+    const home = homedir24();
     if (!real.startsWith(cwd) && !real.startsWith(home)) {
       return "deny";
     }
@@ -6551,17 +6733,20 @@ 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();
 import { readFileSync as readFileSync3, readdirSync, existsSync as existsSync3, statSync as statSync2 } from "fs";
-import { join as join3, basename } from "path";
+import { join as join4, basename } from "path";
 function suggestSpecFiles(prefix) {
-  const specsDir = join3(process.cwd(), ".unipi", "docs", "specs");
+  const specsDir = join4(process.cwd(), ".unipi", "docs", "specs");
   if (!existsSync3(specsDir)) return [];
   try {
     const search2 = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(specsDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join3(specsDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const files = readdirSync(specsDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join4(specsDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
     return files.filter((f) => !search2 || f.name.includes(search2)).map((f) => ({
       value: `specs:${f.name}`,
       label: basename(f.name, ".md"),
@@ -6572,11 +6757,11 @@ function suggestSpecFiles(prefix) {
   }
 }
 function suggestPlanFiles(prefix) {
-  const plansDir = join3(process.cwd(), ".unipi", "docs", "plans");
+  const plansDir = join4(process.cwd(), ".unipi", "docs", "plans");
   if (!existsSync3(plansDir)) return [];
   try {
     const search2 = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(plansDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join3(plansDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const files = readdirSync(plansDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join4(plansDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
     return files.filter((f) => !search2 || f.name.includes(search2)).map((f) => ({
       value: `plan:${f.name}`,
       label: basename(f.name, ".md"),
@@ -6587,11 +6772,11 @@ function suggestPlanFiles(prefix) {
   }
 }
 function suggestDebugFiles(prefix) {
-  const debugDir = join3(process.cwd(), ".unipi", "docs", "debug");
+  const debugDir = join4(process.cwd(), ".unipi", "docs", "debug");
   if (!existsSync3(debugDir)) return [];
   try {
     const search2 = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(debugDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join3(debugDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const files = readdirSync(debugDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join4(debugDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
     return files.filter((f) => !search2 || f.name.includes(search2)).map((f) => ({
       value: `debug:${f.name}`,
       label: basename(f.name, ".md"),
@@ -6602,11 +6787,11 @@ function suggestDebugFiles(prefix) {
   }
 }
 function suggestChoreFiles(prefix) {
-  const choreDir = join3(process.cwd(), ".unipi", "docs", "chore");
+  const choreDir = join4(process.cwd(), ".unipi", "docs", "chore");
   if (!existsSync3(choreDir)) return [];
   try {
     const search2 = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(choreDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join3(choreDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const files = readdirSync(choreDir).filter((f) => f.endsWith(".md")).map((f) => ({ name: f, time: statSync2(join4(choreDir, f)).mtimeMs })).sort((a, b) => b.time - a.time);
     return files.filter((f) => !search2 || f.name.includes(search2)).map((f) => ({
       value: `chore:${f.name}`,
       label: basename(f.name, ".md"),
@@ -6622,7 +6807,7 @@ function suggestWorktrees() {
   if (worktreeSuggestionsCache?.cwd === cwd) {
     return worktreeSuggestionsCache.items;
   }
-  const worktreesDir = join3(cwd, ".unipi", "worktrees");
+  const worktreesDir = join4(cwd, ".unipi", "worktrees");
   if (!existsSync3(worktreesDir)) {
     worktreeSuggestionsCache = { cwd, items: [] };
     return worktreeSuggestionsCache.items;
@@ -6631,7 +6816,7 @@ function suggestWorktrees() {
     let findWorktrees2 = function(dir, relativePath) {
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join3(dir, entry.name);
+        const fullPath = join4(dir, entry.name);
         const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
         if (entry.name === ".git" && entry.isFile()) {
           try {
@@ -6824,18 +7009,13 @@ function registerWorkflowCommands(pi, options) {
           fullCommand: `/${fullCommand}`,
           args: args?.trim() ?? ""
         };
-        if (!options.startWorkflow(workflowEvent)) {
+        if (!options.activateSandbox(workflowEvent)) {
           if (ctx.hasUI) ctx.ui.notify("Another UniPi workflow is still active", "warning");
           return;
         }
-        const currentTools = options.getActiveTools();
-        options.saveTools(currentTools);
-        const sandboxTools = getToolsForCommand(cmd.name, currentTools);
-        const sandboxLevel = getSandboxLevel(cmd.name);
-        options.setActiveTools([...sandboxTools], sandboxLevel);
         let skillContent = "";
         try {
-          const skillPath = join3(
+          const skillPath = join4(
             new URL("./skills", import.meta.url).pathname,
             cmd.skillName,
             "SKILL.md"
@@ -6861,7 +7041,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";
@@ -6929,90 +7114,147 @@ var WorkflowLifecycle = class {
 
 // 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;
-    },
-    saveTools: (tools) => {
-      savedTools = tools;
-    },
-    startWorkflow: (event) => {
+    activateSandbox: (event) => {
       if (!workflowLifecycle.start(event)) return false;
+      sandboxCommand = event.command;
       emitEvent(pi, UNIPI_EVENTS.WORKFLOW_START, event);
       return true;
+    },
+    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;
-    }
     const completedWorkflow = workflowLifecycle.complete(event.messages);
-    if (completedWorkflow) emitEvent(pi, UNIPI_EVENTS.WORKFLOW_END, completedWorkflow);
+    if (!completedWorkflow) return;
+    sandboxCommand = null;
+    emitEvent(pi, UNIPI_EVENTS.WORKFLOW_END, completedWorkflow);
   });
   pi.on("session_start", async (_event, ctx) => {
     initUnipiDirs();
@@ -7025,7 +7267,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 {
       }
     }
@@ -7036,14 +7278,11 @@ 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();
   });
 }
@@ -7365,7 +7604,7 @@ Use /unipi:ralph-resume <name> to continue`, "info");
 // packages/ralph/tools.ts
 init_core();
 import { Type } from "typebox";
-function registerRalphTools(pi, manager2) {
+function registerRalphTools(pi, getManager2) {
   pi.registerTool({
     name: RALPH_TOOLS.START,
     label: "Start Ralph Loop",
@@ -7394,6 +7633,7 @@ function registerRalphTools(pi, manager2) {
       )
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const manager2 = getManager2(ctx);
       const taskFile = `.unipi/ralph/${params.name.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`;
       if (manager2.loadState(params.name)?.status === "active") {
         return {
@@ -7434,6 +7674,7 @@ function registerRalphTools(pi, manager2) {
     ],
     parameters: Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      const manager2 = getManager2(ctx);
       if (!manager2.getCurrentLoop()) {
         return {
           content: [{ type: "text", text: "No active Ralph loop." }],
@@ -7491,6 +7732,38 @@ function registerRalphTools(pi, manager2) {
   });
 }
 
+// packages/ralph/reminder.ts
+init_core();
+var RALPH_REMINDER_TYPE = "unipi-ralph-loop-reminder";
+function buildRalphLoopReminder(state) {
+  const iterStr = `${state.iteration}${state.maxIterations > 0 ? `/${state.maxIterations}` : ""}`;
+  let instructions = "This snapshot supersedes all earlier Ralph loop reminders.\n";
+  instructions += `You are in a Ralph loop working on: ${state.taskFile}
+`;
+  if (state.itemsPerIteration > 0) {
+    instructions += `- Work on ~${state.itemsPerIteration} items this iteration
+`;
+  }
+  instructions += "- Update the task file as you progress\n";
+  instructions += `- When FULLY COMPLETE: ${RALPH_COMPLETE_MARKER}
+`;
+  instructions += "- Otherwise, call ralph_done tool to proceed to next iteration";
+  return `[RALPH LOOP - ${state.name} - Iteration ${iterStr}]
+
+${instructions}`;
+}
+function latestRalphReminder(ctx) {
+  const branch = ctx.sessionManager.getBranch();
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type === "custom_message" && entry.customType === RALPH_REMINDER_TYPE) {
+      return typeof entry.content === "string" ? entry.content : null;
+    }
+    if (entry.type === "compaction") break;
+  }
+  return null;
+}
+
 // packages/ralph/index.ts
 function getInfoRegistry() {
   return globalThis.__unipi_info_registry;
@@ -7507,6 +7780,7 @@ function getManager(ctx, pi) {
   return manager;
 }
 function ralph_default(pi) {
+  registerRalphTools(pi, (ctx) => getManager(ctx, pi));
   registerCommands(pi);
   pi.on("session_start", async (_event, ctx) => {
     manager = null;
@@ -7587,24 +7861,12 @@ function ralph_default(pi) {
     if (!currentLoop) return;
     const state = mgr.loadState(currentLoop);
     if (!state || state.status !== "active") return;
-    const iterStr = `${state.iteration}${state.maxIterations > 0 ? `/${state.maxIterations}` : ""}`;
-    let instructions = `You are in a Ralph loop working on: ${state.taskFile}
-`;
-    if (state.itemsPerIteration > 0) {
-      instructions += `- Work on ~${state.itemsPerIteration} items this iteration
-`;
-    }
-    instructions += `- Update the task file as you progress
-`;
-    instructions += `- When FULLY COMPLETE: ${RALPH_COMPLETE_MARKER}
-`;
-    instructions += `- Otherwise, call ralph_done tool to proceed to next iteration`;
+    const content = buildRalphLoopReminder(state);
+    if (latestRalphReminder(ctx) === content) return;
     return {
       message: {
-        customType: "unipi-ralph-loop-reminder",
-        content: `[RALPH LOOP - ${state.name} - Iteration ${iterStr}]
-
-${instructions}`,
+        customType: RALPH_REMINDER_TYPE,
+        content,
         display: false
       }
     };
@@ -7618,10 +7880,6 @@ ${instructions}`,
     }
     manager = null;
   });
-  pi.on("session_start", async (_event, ctx) => {
-    const mgr = getManager(ctx, pi);
-    registerRalphTools(pi, mgr);
-  });
 }
 function registerCommands(pi) {
   const HELP = `Ralph Loop \u2014 Long-running development loops
@@ -7922,7 +8180,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
@@ -8630,7 +8888,37 @@ 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)));
+function buildMemoryRecallReminder(input) {
+  const lines = [
+    "## \u{1F9E0} Memory System Active",
+    "",
+    `You have ${input.memories.length} memories stored for project "${input.projectName}".`
+  ];
+  if (input.canSearch && input.memories.length > 0) {
+    const titleList = input.memories.slice(0, 20).map((memory) => `- ${memory.title}`).join("\n");
+    const extra = input.memories.length > 20 ? `
+... and ${input.memories.length - 20} more` : "";
+    lines.push(
+      "**BEFORE starting work**, call `memory_search` with relevant keywords to check for existing context.",
+      "",
+      "Available memories:",
+      titleList + extra
+    );
+  }
+  if (input.canStore) {
+    lines.push(
+      "",
+      "**AFTER completing the task**, if you learned something non-obvious,",
+      "call `memory_store` to save it for future sessions."
+    );
+  }
+  lines.push(
+    "",
+    "Guardrails: read max 10 memory results per search. Update existing memories instead of creating duplicates."
+  );
+  return lines.join("\n");
+}
 var projectStorage = null;
 var orphanSyncPending = false;
 function ensureOrphanSync(storage) {
@@ -8784,41 +9072,17 @@ function memory_default(pi) {
       recallDone = true;
       return;
     }
-    const lines = [
-      "## \u{1F9E0} Memory System Active",
-      "",
-      `You have ${projectMemories.length} memories stored for project "${projectName}".`
-    ];
-    if (canSearch && projectMemories.length > 0) {
-      const titleList = projectMemories.slice(0, 20).map((m) => `- ${m.title}`).join("\n");
-      const extra = projectMemories.length > 20 ? `
-... and ${projectMemories.length - 20} more` : "";
-      lines.push(
-        "**BEFORE starting work**, call `memory_search` with relevant keywords to check for existing context.",
-        "",
-        "Available memories:",
-        titleList + extra
-      );
-    } else {
-      recallDone = true;
-    }
-    if (canStore) {
-      lines.push(
-        "",
-        "**AFTER completing the task**, if you learned something non-obvious,",
-        "call `memory_store` to save it for future sessions."
-      );
-    } else {
-      storeDone = true;
-    }
-    lines.push(
-      "",
-      "Guardrails: read max 10 memory results per search. Update existing memories instead of creating duplicates."
-    );
+    if (!canSearch || projectMemories.length === 0) recallDone = true;
+    if (!canStore) storeDone = true;
     return {
       message: {
         customType: "unipi-memory-recall-reminder",
-        content: lines.join("\n"),
+        content: buildMemoryRecallReminder({
+          projectName,
+          memories: projectMemories,
+          canSearch,
+          canStore
+        }),
         display: false
       }
     };
@@ -8852,13 +9116,13 @@ 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 { homedir as homedir4 } from "node:os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join9, dirname as dirname8 } from "node:path";
+import { homedir as homedir5 } from "node:os";
 
 // packages/info-screen/types.ts
 var BOOT_MODES = ["on", "auto-close", "off"];
@@ -8870,7 +9134,7 @@ var DEFAULT_SETTINGS = {
 };
 
 // packages/info-screen/config.ts
-var SETTINGS_PATH = join8(homedir4(), ".pi", "agent", "settings.json");
+var SETTINGS_PATH = join9(homedir5(), ".pi", "agent", "settings.json");
 var SETTINGS_KEY = "unipi";
 var cachedSettings = null;
 function isRecord(value) {
@@ -8886,11 +9150,11 @@ function readSettingsFile() {
   }
 }
 function writeSettingsFile(data) {
-  const dir = dirname9(SETTINGS_PATH);
+  const dir = dirname8(SETTINGS_PATH);
   if (!existsSync8(dir)) {
-    mkdirSync6(dir, { recursive: true });
+    mkdirSync7(dir, { recursive: true });
   }
-  writeFileSync7(SETTINGS_PATH, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  writeFileSync8(SETTINGS_PATH, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function getInfoSettings() {
   if (cachedSettings) return cachedSettings;
@@ -9187,17 +9451,17 @@ 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 { join as join10 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { readFileSync as readFileSync9, readdirSync as readdirSync6, existsSync as existsSync10 } from "node:fs";
+import { join as join11 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 init_usage_parser();
 function discoverExtensions() {
   const extensions = [];
-  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir6();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir7();
   const cwd = process.cwd();
   const settingsPaths = [
-    join10(homeDir, ".pi", "agent", "settings.json"),
-    join10(cwd, ".pi", "settings.json")
+    join11(homeDir, ".pi", "agent", "settings.json"),
+    join11(cwd, ".pi", "settings.json")
   ];
   const counted = /* @__PURE__ */ new Set();
   for (const settingsPath of settingsPaths) {
@@ -9242,13 +9506,13 @@ function discoverExtensions() {
     }
   }
   const extensionDirs = [
-    join10(homeDir, ".pi", "agent", "extensions"),
-    join10(cwd, ".pi", "extensions")
+    join11(homeDir, ".pi", "agent", "extensions"),
+    join11(cwd, ".pi", "extensions")
   ];
   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;
@@ -9310,11 +9574,11 @@ function getTotalLoadTime() {
 var extraSkillDirs = [];
 function discoverSkills() {
   const skills = [];
-  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir6();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir7();
   const cwd = process.cwd();
   const skillDirs = [
-    join10(homeDir, ".pi", "agent", "skills"),
-    join10(cwd, ".pi", "skills"),
+    join11(homeDir, ".pi", "agent", "skills"),
+    join11(cwd, ".pi", "skills"),
     // Add extra dirs from extensions
     ...extraSkillDirs
   ];
@@ -9322,18 +9586,18 @@ 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;
         if (counted.has(name)) continue;
-        const skillPath = join10(dir, name, "SKILL.md");
+        const skillPath = join11(dir, name, "SKILL.md");
         if (existsSync10(skillPath)) {
           counted.add(name);
           let source = "extension";
-          if (dir.includes(join10(homeDir, ".pi"))) {
+          if (dir.includes(join11(homeDir, ".pi"))) {
             source = "global";
-          } else if (dir === join10(cwd, ".pi", "skills")) {
+          } else if (dir === join11(cwd, ".pi", "skills")) {
             source = "project";
           }
           skills.push({ name, source });
@@ -9384,7 +9648,7 @@ function registerCoreGroups() {
     },
     dataProvider: async () => {
       const cwd = process.cwd();
-      const homeDir = process.env.HOME || process.env.USERPROFILE || homedir6();
+      const homeDir = process.env.HOME || process.env.USERPROFILE || homedir7();
       const shortCwd = cwd.startsWith(homeDir) ? `~${cwd.slice(homeDir.length)}` : cwd;
       const announced = getAnnouncedModules();
       const registeredGroups = infoRegistry.getAllGroups();
@@ -10433,7 +10697,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();
@@ -10576,11 +10840,15 @@ function info_screen_default(pi) {
 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 { join as join13 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { existsSync as existsSync13, readdirSync as readdirSync8 } from "node:fs";
+import { join as join15 } from "node:path";
+import { homedir as homedir11 } from "node:os";
 
 // packages/subagents/src/core-compat.ts
+import { chmodSync as chmodSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join12 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var MODULES2 = { SUBAGENTS: "subagents" };
 var UNIPI_EVENTS2 = {
   MODULE_READY: "unipi:module:ready",
@@ -10594,6 +10862,61 @@ function emitEvent2(pi, eventName, payload) {
     return false;
   }
 }
+var MAX_RAW_HELPER_ARTIFACT_BYTES = 16 * 1024 * 1024;
+function boundHelperOutput(text, maxBytes = 64 * 1024, existingArtifactPath) {
+  const originalBytes = Buffer.byteLength(text, "utf8");
+  if (originalBytes <= maxBytes) return { text, truncated: false, originalBytes };
+  let artifactPath = existingArtifactPath;
+  let artifactWarning;
+  if (!artifactPath && originalBytes <= MAX_RAW_HELPER_ARTIFACT_BYTES) {
+    try {
+      const dir = join12(homedir8(), ".unipi", "tool-results");
+      mkdirSync9(dir, { recursive: true, mode: 448 });
+      let stat = lstatSync2(dir);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`Refusing unsafe tool-result directory: ${dir}`);
+      }
+      if ((stat.mode & 63) !== 0) {
+        chmodSync2(dir, 448);
+        stat = lstatSync2(dir);
+        if ((stat.mode & 63) !== 0) throw new Error(`Refusing non-private tool-result directory: ${dir}`);
+      }
+      artifactPath = join12(dir, `helper-${randomUUID2()}.txt`);
+      writeFileSync10(artifactPath, text, { encoding: "utf8", mode: 384, flag: "wx" });
+    } catch (error) {
+      artifactWarning = `Full-output artifact unavailable: ${error instanceof Error ? error.message : String(error)}`;
+      artifactPath = void 0;
+    }
+  } else if (!artifactPath) {
+    artifactWarning = `Full output exceeded the ${MAX_RAW_HELPER_ARTIFACT_BYTES}-byte local artifact safety cap and was not retained.`;
+  }
+  const marker = [
+    "",
+    "--- output bounded by UniPi ---",
+    artifactPath ? `Full output: ${artifactPath}` : artifactWarning,
+    `Original size: ${originalBytes} bytes; model-visible ceiling: ${maxBytes} bytes.`,
+    ...artifactPath ? ["Use the read tool with offset/limit to inspect only the needed region."] : []
+  ].join("\n");
+  const markerBytes = Buffer.byteLength(marker, "utf8");
+  const contentBudget = Math.max(1, maxBytes - markerBytes - 80);
+  const bytes = Buffer.from(text, "utf8");
+  const headBytes = Math.ceil(contentBudget * 0.75);
+  const tailBytes = Math.max(0, contentBudget - headBytes);
+  const head = bytes.subarray(0, headBytes).toString("utf8").replace(/\uFFFD+$/u, "");
+  const tail2 = bytes.subarray(originalBytes - tailBytes).toString("utf8").replace(/^\uFFFD+/u, "");
+  let bounded = `${head}
+\u2026 ${Math.max(0, originalBytes - contentBudget)} bytes omitted \u2026
+${tail2}${marker}`;
+  if (Buffer.byteLength(bounded, "utf8") > maxBytes) {
+    bounded = Buffer.from(bounded, "utf8").subarray(0, maxBytes).toString("utf8").replace(/\uFFFD+$/u, "");
+  }
+  return {
+    text: bounded,
+    truncated: true,
+    originalBytes,
+    artifactPath
+  };
+}
 async function withHerdrBlocked2(pi, label, fn) {
   emitEvent2(pi, "herdr:blocked", { active: true, label });
   try {
@@ -10604,7 +10927,7 @@ async function withHerdrBlocked2(pi, label, fn) {
 }
 
 // packages/subagents/src/agent-manager.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // packages/subagents/src/agent-runner.ts
 import {
@@ -10657,7 +10980,7 @@ var BUILTIN_CONFIGS = {
 };
 
 // packages/subagents/src/agent-runner.ts
-var EXCLUDED_TOOL_NAMES = ["Agent", "get_result"];
+var EXCLUDED_TOOL_NAMES = ["spawn_helper", "get_helper_result", "Agent", "get_result"];
 var BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 var defaultMaxTurns;
 var graceTurns = 5;
@@ -10815,22 +11138,25 @@ ${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 { join as join11 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync10, renameSync as renameSync4 } from "node:fs";
+import { join as join13 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+function compareCodeUnits(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 function backupCorrupted(filePath) {
   const backupPath = filePath + ".bak";
   try {
-    renameSync3(filePath, backupPath);
+    renameSync4(filePath, backupPath);
   } catch {
   }
 }
 function getProjectAgentsDir(cwd) {
-  return join11(cwd, ".unipi", "config", "agents");
+  return join13(cwd, ".unipi", "config", "agents");
 }
 function getGlobalAgentsDir() {
-  return join11(homedir7(), ".unipi", "config", "agents");
+  return join13(homedir9(), ".unipi", "config", "agents");
 }
 var BUILTIN_TOOL_NAMES2 = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 function loadAgentFromFile(filePath, source) {
@@ -10871,9 +11197,9 @@ 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")).sort(compareCodeUnits);
     for (const file of files) {
-      const agent = loadAgentFromFile(join11(globalDir, file), "global");
+      const agent = loadAgentFromFile(join13(globalDir, file), "global");
       if (agent) {
         agents.set(agent.name, agent);
       }
@@ -10881,9 +11207,9 @@ 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")).sort(compareCodeUnits);
     for (const file of files) {
-      const agent = loadAgentFromFile(join11(projectDir, file), "project");
+      const agent = loadAgentFromFile(join13(projectDir, file), "project");
       if (agent) {
         agents.set(agent.name, agent);
       }
@@ -10908,17 +11234,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();
@@ -10976,6 +11302,9 @@ var FileLock = class {
 };
 
 // packages/subagents/src/agent-manager.ts
+function compareCodeUnits2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 var DEFAULT_MAX_CONCURRENT = 4;
 var AgentManager = class {
   agents = /* @__PURE__ */ new Map();
@@ -11009,7 +11338,7 @@ var AgentManager = class {
       ...Object.keys(BUILTIN_CONFIGS).filter((type) => type !== "name-gen"),
       ...this.customAgents.keys(),
       ...Object.keys(this.typeSettings)
-    ])];
+    ])].sort(compareCodeUnits2);
   }
   /** A type is enabled only when both JSON config and agent frontmatter allow it. */
   isTypeEnabled(type) {
@@ -11033,7 +11362,7 @@ var AgentManager = class {
    */
   spawn(pi, ctx, type, prompt, options) {
     this.assertTypeEnabled(type);
-    const id = randomUUID().slice(0, 17);
+    const id = randomUUID3().slice(0, 17);
     const abortController = new AbortController();
     const record = {
       id,
@@ -11236,9 +11565,9 @@ 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 { join as join12 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync11, renameSync as renameSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 var DEFAULT_CONFIG2 = {
   maxConcurrent: 4,
   enabled: true,
@@ -11248,20 +11577,20 @@ var DEFAULT_CONFIG2 = {
   }
 };
 function getGlobalConfigPath() {
-  return join12(homedir8(), ".unipi", "config", "subagents.json");
+  return join14(homedir10(), ".unipi", "config", "subagents.json");
 }
 function getWorkspaceConfigPath(cwd) {
-  return join12(cwd, ".unipi", "config", "subagents.json");
+  return join14(cwd, ".unipi", "config", "subagents.json");
 }
 function ensureDirExists(dirPath) {
   if (!existsSync12(dirPath)) {
-    mkdirSync8(dirPath, { recursive: true });
+    mkdirSync10(dirPath, { recursive: true });
   }
 }
 function writeConfigAtomic(filePath, config) {
   const tmpPath = filePath + ".tmp";
-  writeFileSync9(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-  renameSync4(tmpPath, filePath);
+  writeFileSync11(tmpPath, JSON.stringify(config, null, 2), "utf-8");
+  renameSync5(tmpPath, filePath);
 }
 function loadConfigFromPath(filePath) {
   if (!existsSync12(filePath)) return null;
@@ -11277,7 +11606,7 @@ function loadConfigFromPath(filePath) {
 function repairCorrupted(filePath) {
   const backupPath = filePath + ".bak";
   try {
-    renameSync4(filePath, backupPath);
+    renameSync5(filePath, backupPath);
   } catch {
   }
   writeConfigAtomic(filePath, DEFAULT_CONFIG2);
@@ -11285,17 +11614,17 @@ function repairCorrupted(filePath) {
 }
 function initConfig(cwd) {
   const globalPath = getGlobalConfigPath();
-  const globalDir = join12(homedir8(), ".unipi", "config");
-  const globalAgentsDir = join12(homedir8(), ".unipi", "config", "agents");
+  const globalDir = join14(homedir10(), ".unipi", "config");
+  const globalAgentsDir = join14(homedir10(), ".unipi", "config", "agents");
   ensureDirExists(globalDir);
   ensureDirExists(globalAgentsDir);
   let globalConfig = loadConfigFromPath(globalPath);
   if (globalConfig === null) {
     globalConfig = repairCorrupted(globalPath);
   }
-  const workspaceDir = join12(cwd, ".unipi", "config");
-  const workspaceAgentsDir = join12(cwd, ".unipi", "config", "agents");
-  if (cwd && !cwd.startsWith(homedir8())) {
+  const workspaceDir = join14(cwd, ".unipi", "config");
+  const workspaceAgentsDir = join14(cwd, ".unipi", "config", "agents");
+  if (cwd && !cwd.startsWith(homedir10())) {
     ensureDirExists(workspaceDir);
     ensureDirExists(workspaceAgentsDir);
   }
@@ -11959,10 +12288,10 @@ function getStatusLabel(status2, error) {
 function src_default(pi) {
   const config = initConfig(process.cwd());
   if (!config.enabled) return;
-  const homeDir = homedir9();
+  const homeDir = homedir11();
   const cwd = process.cwd();
-  const globalAgentsDir = join13(homeDir, ".unipi", "config", "agents");
-  const workspaceAgentsDir = join13(cwd, ".unipi", "config", "agents");
+  const globalAgentsDir = join15(homeDir, ".unipi", "config", "agents");
+  const workspaceAgentsDir = join15(cwd, ".unipi", "config", "agents");
   const agentActivity = /* @__PURE__ */ new Map();
   let sessionEnded = false;
   const manager2 = new AgentManager(
@@ -12096,7 +12425,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", ""));
                 }
@@ -12442,17 +12771,22 @@ Use get_result to retrieve full results.`,
             error: record.error
           });
         }
+        const output = boundHelperOutput(record.result?.trim() || "No output.");
+        record.resultArtifactPath = output.artifactPath;
         return textResult(
           `Agent completed in ${(durationMs / 1e3).toFixed(1)}s (${record.toolUses} tool uses${tokenText ? `, ${tokenText} tokens` : ""}).
 
-` + (record.result?.trim() || "No output."),
+` + output.text,
           {
             status: "completed",
             toolUses: record.toolUses,
             tokens: tokenText,
             durationMs,
             turnCount: fgState.turnCount,
-            maxTurns: fgState.maxTurns
+            maxTurns: fgState.maxTurns,
+            truncated: output.truncated,
+            originalBytes: output.originalBytes,
+            artifactPath: output.artifactPath
           }
         );
       }
@@ -12528,7 +12862,13 @@ Description: ${record.description}
         } else if (record.status === "error") {
           output += `Error: ${record.error}`;
         } else {
-          output += record.result?.trim() || "No output.";
+          const bounded = boundHelperOutput(
+            record.result?.trim() || "No output.",
+            64 * 1024,
+            record.resultArtifactPath
+          );
+          record.resultArtifactPath = bounded.artifactPath;
+          output += bounded.text;
         }
         if (record.status !== "running" && record.status !== "queued") {
           record.resultConsumed = true;
@@ -12542,7 +12882,7 @@ Description: ${record.description}
 // packages/btw/extensions/btw.ts
 init_core();
 import {
-  buildSessionContext,
+  buildSessionContext as buildSessionContext2,
   createAgentSession as createAgentSession2,
   createExtensionRuntime,
   SessionManager as SessionManager2
@@ -12628,7 +12968,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)
         )
       );
@@ -14031,7 +14371,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
@@ -16701,7 +17041,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;
 }
@@ -16773,16 +17113,16 @@ 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 { join as join16 } from "node:path";
-import { homedir as homedir12, tmpdir } from "node:os";
+import { existsSync as existsSync16, statSync as statSync8, readdirSync as readdirSync10, unlinkSync as unlinkSync5, rmdirSync } from "node:fs";
+import { join as join18 } from "node:path";
+import { homedir as homedir14, tmpdir } from "node:os";
 var DEFAULTS = {
   dbMaxAgeDays: 14,
   tempMaxAgeDays: 7,
@@ -16791,13 +17131,13 @@ var DEFAULTS = {
 };
 function expandHome(path28) {
   if (path28.startsWith("~/")) {
-    return join16(homedir12(), path28.slice(2));
+    return join18(homedir14(), path28.slice(2));
   }
   return 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 {
@@ -16809,7 +17149,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 {
@@ -16830,14 +17170,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);
+      const fullPath = join18(dir, entry);
       try {
-        const stats = statSync7(fullPath);
+        const stats = statSync8(fullPath);
         if (stats.isDirectory()) {
           scanDir(fullPath);
           continue;
@@ -16853,7 +17193,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++;
@@ -16871,6 +17211,36 @@ function cleanDbs(options) {
   scanDir(unipiDir);
   return result;
 }
+function cleanToolResults(options) {
+  const result = {
+    category: "tool-results",
+    removed: 0,
+    bytesFreed: 0,
+    paths: []
+  };
+  const dir = expandHome("~/.unipi/tool-results");
+  if (!existsSync16(dir)) return result;
+  let entries;
+  try {
+    entries = readdirSync10(dir);
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!/^(?:tool-result|mcp-[a-zA-Z0-9_-]+|helper)-[a-f0-9-]+\.txt$/.test(entry)) continue;
+    const path28 = join18(dir, entry);
+    try {
+      const stats = statSync8(path28);
+      if (!stats.isFile() || !isStale(path28, options.tempMaxAgeDays)) continue;
+      result.paths.push(path28);
+      result.bytesFreed += stats.size;
+      if (!options.dryRun) unlinkSync5(path28);
+      result.removed++;
+    } catch {
+    }
+  }
+  return result;
+}
 function cleanTemps(options) {
   const result = {
     category: "temp",
@@ -16882,15 +17252,15 @@ function cleanTemps(options) {
   const tmpDir = tmpdir();
   let entries;
   try {
-    entries = readdirSync9(tmpDir);
+    entries = readdirSync10(tmpDir);
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (!patterns.some((p) => p.test(entry))) continue;
-    const fullPath = join16(tmpDir, entry);
+    const fullPath = join18(tmpDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isFile()) continue;
       if (isStale(fullPath, options.tempMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -16918,18 +17288,18 @@ function cleanSessions(options) {
     paths: []
   };
   const unipiDir = expandHome("~/.unipi");
-  const sessionsDir = join16(unipiDir, "sessions");
+  const sessionsDir = join18(unipiDir, "sessions");
   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);
+    const fullPath = join18(sessionsDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isDirectory()) continue;
       if (isStale(fullPath, options.sessionMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -16937,10 +17307,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 itemPath = join18(dir, item);
+                const itemStats = statSync8(itemPath);
                 if (itemStats.isDirectory()) {
                   removeRecursive(itemPath);
                 } else {
@@ -16973,14 +17343,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);
+    const fullPath = join18(cacheDir, entry);
     try {
-      const stats = statSync7(fullPath);
+      const stats = statSync8(fullPath);
       if (!stats.isFile()) continue;
       if (isStale(fullPath, options.tempMaxAgeDays)) {
         result.bytesFreed += stats.size;
@@ -17005,6 +17375,7 @@ function cleanupStale(options = {}) {
   const results = [
     cleanDbs(opts),
     cleanTemps(opts),
+    cleanToolResults(opts),
     cleanSessions(opts),
     cleanCache(opts)
   ];
@@ -17044,18 +17415,18 @@ function formatCleanupReport(report) {
 }
 
 // packages/utility/src/diagnostics/engine.ts
-import { existsSync as existsSync17, accessSync, constants } from "node:fs";
-import { join as join17 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { existsSync as existsSync17, accessSync as accessSync2, constants as constants2 } from "node:fs";
+import { join as join19 } from "node:path";
+import { homedir as homedir15 } from "node:os";
 function expandHome2(path28) {
   if (path28.startsWith("~/")) {
-    return join17(homedir13(), path28.slice(2));
+    return join19(homedir15(), path28.slice(2));
   }
   return path28;
 }
 function isReadable(path28) {
   try {
-    accessSync(path28, constants.R_OK);
+    accessSync2(path28, constants2.R_OK);
     return true;
   } catch {
     return false;
@@ -17063,7 +17434,7 @@ function isReadable(path28) {
 }
 function isWritable(path28) {
   try {
-    accessSync(path28, constants.W_OK);
+    accessSync2(path28, constants2.W_OK);
     return true;
   } catch {
     return false;
@@ -19115,7 +19486,7 @@ function getLifecycle(options) {
 }
 
 // packages/utility/src/analytics/collector.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var DEFAULTS3 = {
   dbPath: "~/.unipi/analytics/events.db",
   maxEvents: 1e4,
@@ -19124,7 +19495,7 @@ var DEFAULTS3 = {
 var eventBuffer = [];
 var bufferFlushTimer = null;
 function generateId() {
-  return randomUUID2();
+  return randomUUID4();
 }
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -19332,8 +19703,189 @@ function registerInfoScreen(pi) {
   });
 }
 
+// packages/utility/src/prefix-cache.ts
+import { createHmac, randomBytes } from "node:crypto";
+var EMPTY_SNAPSHOT = {
+  epoch: 0,
+  requests: 0,
+  prefixExtensions: 0,
+  identicalRetries: 0,
+  boundaries: 0,
+  lastTransition: "none",
+  requestFingerprint: "none",
+  envelopeFingerprint: "none",
+  sequenceField: "none",
+  sequenceItems: 0,
+  route: "unknown",
+  usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, responses: 0 }
+};
+function canonicalize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === void 0) return { $type: "undefined" };
+  if (typeof value === "bigint") return { $type: "bigint", value: value.toString() };
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return { $type: "number", value: String(value) };
+  }
+  if (typeof value !== "object" || value === null) return value;
+  if (seen.has(value)) return { $type: "cycle" };
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result2 = value.map((item) => canonicalize(item, seen));
+    seen.delete(value);
+    return result2;
+  }
+  if (value instanceof Uint8Array) {
+    seen.delete(value);
+    return { $type: "bytes", length: value.byteLength };
+  }
+  const record = value;
+  const result = {};
+  for (const key of Object.keys(record).sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+    result[key] = canonicalize(record[key], seen);
+  }
+  seen.delete(value);
+  return result;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function routeLabel(model) {
+  if (!model || typeof model !== "object") return "unknown";
+  const value = model;
+  return [value.provider, value.id, value.api].filter((part) => typeof part === "string" && part.length > 0).join("/") || "unknown";
+}
+function findSequence(payload) {
+  for (const field of ["messages", "input", "contents"]) {
+    if (Array.isArray(payload[field])) return { field, items: payload[field] };
+  }
+  return { field: "none", items: [] };
+}
+function isPrefix(previous, current) {
+  return previous.length <= current.length && previous.every((item, index) => current[index] === item);
+}
+function usageNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+var PrefixCacheTracker = class {
+  key;
+  previous = null;
+  seenResponses = /* @__PURE__ */ new WeakSet();
+  snapshot = structuredClone(EMPTY_SNAPSHOT);
+  constructor(key = randomBytes(32)) {
+    this.key = key;
+  }
+  reset() {
+    this.previous = null;
+    this.seenResponses = /* @__PURE__ */ new WeakSet();
+    this.snapshot = structuredClone(EMPTY_SNAPSHOT);
+  }
+  fingerprint(value) {
+    return createHmac("sha256", this.key).update(canonicalJson(value)).digest("hex").slice(0, 16);
+  }
+  observeRequest(payload, model) {
+    const object = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { payload };
+    const { field, items } = findSequence(object);
+    const route = routeLabel(model);
+    const envelope = { route };
+    for (const [key, value] of Object.entries(object)) {
+      if (key !== field) envelope[key] = value;
+    }
+    const current = {
+      envelopeFingerprint: this.fingerprint(envelope),
+      requestFingerprint: this.fingerprint(object),
+      sequenceField: field,
+      sequenceItemFingerprints: items.map((item) => this.fingerprint(item))
+    };
+    let transition;
+    let epoch = this.snapshot.epoch;
+    if (!this.previous) {
+      transition = "first_request";
+      epoch = Math.max(1, epoch);
+    } else if (current.envelopeFingerprint !== this.previous.envelopeFingerprint) {
+      transition = "envelope_changed";
+      epoch++;
+    } else if (current.sequenceField !== this.previous.sequenceField) {
+      transition = "payload_shape_changed";
+      epoch++;
+    } else if (current.requestFingerprint === this.previous.requestFingerprint) {
+      transition = "identical_retry";
+    } else if (isPrefix(this.previous.sequenceItemFingerprints, current.sequenceItemFingerprints)) {
+      transition = "prefix_extended";
+    } else {
+      transition = "history_rewritten";
+      epoch++;
+    }
+    this.snapshot = {
+      ...this.snapshot,
+      epoch,
+      requests: this.snapshot.requests + 1,
+      prefixExtensions: this.snapshot.prefixExtensions + (transition === "prefix_extended" ? 1 : 0),
+      identicalRetries: this.snapshot.identicalRetries + (transition === "identical_retry" ? 1 : 0),
+      boundaries: this.snapshot.boundaries + (transition === "envelope_changed" || transition === "history_rewritten" || transition === "payload_shape_changed" ? 1 : 0),
+      lastTransition: transition,
+      requestFingerprint: current.requestFingerprint,
+      envelopeFingerprint: current.envelopeFingerprint,
+      sequenceField: current.sequenceField,
+      sequenceItems: current.sequenceItemFingerprints.length,
+      route
+    };
+    this.previous = current;
+    return this.getSnapshot();
+  }
+  observeMessages(messages) {
+    for (const message of messages) {
+      if (!message || typeof message !== "object") continue;
+      const value = message;
+      if (value.role !== "assistant" || !value.usage || typeof value.usage !== "object") continue;
+      if (value.stopReason === "error" || value.stopReason === "aborted") continue;
+      if (this.seenResponses.has(message)) continue;
+      this.seenResponses.add(message);
+      const usage = value.usage;
+      this.snapshot.usage.input += usageNumber(usage.input);
+      this.snapshot.usage.output += usageNumber(usage.output);
+      this.snapshot.usage.cacheRead += usageNumber(usage.cacheRead);
+      this.snapshot.usage.cacheWrite += usageNumber(usage.cacheWrite);
+      this.snapshot.usage.responses++;
+    }
+    return this.getSnapshot();
+  }
+  markBoundary(transition) {
+    if (this.previous) {
+      this.snapshot.epoch++;
+      this.snapshot.boundaries++;
+    }
+    this.snapshot.lastTransition = transition;
+    this.previous = null;
+  }
+  getSnapshot() {
+    return structuredClone(this.snapshot);
+  }
+};
+function formatPrefixCacheStats(snapshot) {
+  const usage = snapshot.usage;
+  const totalPrompt = usage.input + usage.cacheRead + usage.cacheWrite;
+  const readRate = totalPrompt > 0 ? `${(usage.cacheRead / totalPrompt * 100).toFixed(1)}%` : "n/a";
+  return [
+    "## Provider Prefix Cache",
+    "",
+    `- Epoch: ${snapshot.epoch || "not observed"}`,
+    `- Requests observed: ${snapshot.requests}`,
+    `- Prefix extensions: ${snapshot.prefixExtensions}`,
+    `- Explicit boundaries: ${snapshot.boundaries}`,
+    `- Last transition: ${snapshot.lastTransition}`,
+    `- Route: ${snapshot.route}`,
+    `- Request fingerprint: ${snapshot.requestFingerprint}`,
+    `- Envelope fingerprint: ${snapshot.envelopeFingerprint}`,
+    `- Provider cache read: ${usage.cacheRead} tokens`,
+    `- Provider cache write: ${usage.cacheWrite} tokens`,
+    `- Observed cache-read share: ${readRate}`,
+    "",
+    "Fingerprints are session-local keyed HMACs. Raw prompts, messages, tool arguments, and payloads are not retained or logged.",
+    "A prefix extension indicates structural eligibility only; provider cache retention and routing still determine actual hits."
+  ].join("\n");
+}
+
 // 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;
@@ -19348,12 +19900,44 @@ var ALL_COMMANDS = [
   UTILITY_COMMANDS.BADGE_GEN,
   UTILITY_COMMANDS.BADGE_TOGGLE,
   UTILITY_COMMANDS.BADGE_SETTINGS,
-  UTILITY_COMMANDS.UTIL_SETTINGS
+  UTILITY_COMMANDS.UTIL_SETTINGS,
+  UTILITY_COMMANDS.PREFIX_CACHE
 ].map((cmd) => `unipi:${cmd}`);
 var ALL_TOOLS2 = [UTILITY_TOOLS.BATCH, UTILITY_TOOLS.ENV, UTILITY_TOOLS.SET_SESSION_NAME];
 function src_default3(pi) {
   const lifecycle = getLifecycle();
   const analytics = getAnalyticsCollector();
+  const prefixCache = new PrefixCacheTracker();
+  pi.registerCommand(`unipi:${UTILITY_COMMANDS.PREFIX_CACHE}`, {
+    description: "Show privacy-safe provider prefix-cache diagnostics",
+    handler: async (_args, ctx) => {
+      const report = formatPrefixCacheStats(prefixCache.getSnapshot());
+      if (ctx.hasUI) {
+        ctx.ui.notify(report, "info");
+      } else {
+        pi.sendMessage({ customType: "unipi-response", content: report, display: true }, { deliverAs: "followUp" });
+      }
+    }
+  });
+  pi.on("session_start", () => {
+    prefixCache.reset();
+  });
+  pi.on("before_provider_request", (event, ctx) => {
+    prefixCache.observeRequest(event.payload, ctx.model);
+  });
+  pi.on("agent_end", (event) => {
+    prefixCache.observeMessages(event.messages);
+  });
+  pi.on("model_select", (event) => {
+    if (event.previousModel && (event.previousModel.provider !== event.model.provider || event.previousModel.id !== event.model.id || event.previousModel.api !== event.model.api)) {
+      prefixCache.markBoundary("envelope_changed");
+    }
+  });
+  pi.on("thinking_level_select", (event) => {
+    if (event.previousLevel !== event.level) prefixCache.markBoundary("envelope_changed");
+  });
+  pi.on("session_compact", () => prefixCache.markBoundary("history_rewritten"));
+  pi.on("session_tree", () => prefixCache.markBoundary("history_rewritten"));
   lifecycle.registerCleanup(async () => {
     analytics.disable();
   });
@@ -19545,7 +20129,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
@@ -20201,9 +20785,9 @@ function renderLauncherUI(params) {
 }
 
 // packages/ask-user/config.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync14, existsSync as existsSync21 } from "node:fs";
-import { join as join19 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync16, existsSync as existsSync21 } from "node:fs";
+import { join as join21 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 var DEFAULT_SETTINGS3 = {
   enabled: true,
   allowedFormats: {
@@ -20213,7 +20797,7 @@ var DEFAULT_SETTINGS3 = {
   },
   notifyOnAsk: true
 };
-var SETTINGS_PATH2 = join19(homedir15(), ".pi", "agent", "settings.json");
+var SETTINGS_PATH2 = join21(homedir17(), ".pi", "agent", "settings.json");
 var SETTINGS_KEY2 = "unipi";
 var cachedSettings2 = null;
 function isRecord3(value) {
@@ -20233,7 +20817,7 @@ function writeSettingsFile2(data) {
   if (!existsSync21(dir)) {
     __require("node:fs").mkdirSync(dir, { recursive: true });
   }
-  writeFileSync14(SETTINGS_PATH2, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  writeFileSync16(SETTINGS_PATH2, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function getAskUserSettings() {
   if (cachedSettings2) return cachedSettings2;
@@ -20930,7 +21514,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);
@@ -20946,7 +21530,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
@@ -21444,7 +22028,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, {
@@ -21493,7 +22077,7 @@ Stderr: ${this.stderrBuffer}`
         }).then(() => {
           this.sendNotification("notifications/initialized", {});
           this.connected = true;
-          resolve13();
+          resolve14();
         }).catch((err) => {
           this.cleanup();
           reject(
@@ -21537,16 +22121,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) {
@@ -21576,7 +22160,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;
@@ -21596,7 +22180,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);
     });
@@ -21659,15 +22243,45 @@ Stderr: ${this.stderrBuffer}`
 
 // packages/mcp/src/bridge/translator.ts
 init_core();
+function compareCodeUnits3(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(compareCodeUnits3);
+    }
+    return value.map((item) => canonicalizeValue(item, void 0, normalizeSchemaKeywords));
+  }
+  if (!isObject(value)) return value;
+  const canonical = {};
+  for (const objectKey of Object.keys(value).sort(compareCodeUnits3)) {
+    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}]`
@@ -21695,19 +22309,26 @@ function translateMcpTool(mcpTool, serverName, client) {
           });
         }
       }
-      if (result.isError) {
-        const errorText = blocks.map((b) => b.text).join("\n") || "Unknown error";
-        return {
-          content: [{ type: "text", text: `MCP tool error from ${serverName}: ${errorText}` }],
-          details: { error: true, server: serverName, tool: mcpTool.name }
-        };
-      }
       if (blocks.length === 0) {
-        blocks.push({ type: "text", text: "(no output)" });
+        blocks.push({ type: "text", text: result.isError ? "Unknown error" : "(no output)" });
       }
+      const rawText = blocks.map((block2) => block2.text).join("\n");
+      const wrapper = result.isError ? `MCP tool error from ${serverName}: ` : "";
+      const output = boundModelOutput(rawText, {
+        maxBytes: Math.max(1024, MCP_DEFAULTS.MAX_MODEL_OUTPUT_BYTES - Buffer.byteLength(wrapper, "utf8")),
+        artifactPrefix: `mcp-${serverName}-${mcpTool.name}`
+      });
+      const visibleText = `${wrapper}${output.text}`;
       return {
-        content: blocks,
-        details: { server: serverName, tool: mcpTool.name }
+        content: [{ type: "text", text: visibleText }],
+        details: {
+          error: result.isError || void 0,
+          server: serverName,
+          tool: mcpTool.name,
+          truncated: output.truncated,
+          originalBytes: output.originalBytes,
+          artifactPath: output.artifactPath
+        }
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -21725,6 +22346,7 @@ Check server status via /unipi:mcp-settings`
   };
   return {
     name: toolName,
+    label: toolName,
     description,
     parameters,
     execute: execute2
@@ -21737,26 +22359,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) => compareCodeUnits3(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(compareCodeUnits3);
+          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) => compareCodeUnits3(left.entry.name, right.entry.name))) {
+      const toolNames = tools.map((tool) => tool.name).sort(compareCodeUnits3);
+      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",
@@ -21771,73 +22492,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) => compareCodeUnits3(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(compareCodeUnits3).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);
     }
@@ -21854,78 +22576,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;
   }
@@ -22538,12 +23245,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) {
@@ -22690,7 +23391,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;
@@ -22700,20 +23401,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 = [];
@@ -22722,13 +23421,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;
@@ -22785,14 +23481,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(compareCodeUnits3)
     });
   });
   pi.on("session_shutdown", async (_event, _ctx) => {
     if (registry2) {
-      await registry2.stopAll();
+      await registry2.disconnectAll();
       registry2 = null;
     }
   });
@@ -22906,38 +23600,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
@@ -22946,12 +23618,12 @@ 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 { homedir as homedir17 } from "os";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync19, mkdirSync as mkdirSync17, existsSync as existsSync24 } from "fs";
+import { dirname as dirname19, join as join24 } from "path";
+import { homedir as homedir19 } from "os";
 function resolveConfigPath() {
-  const base = NOTIFY_DIRS.CONFIG.replace("~", homedir17());
-  return join22(base, "config.json");
+  const base = NOTIFY_DIRS.CONFIG.replace("~", homedir19());
+  return join24(base, "config.json");
 }
 var DEFAULT_CONFIG4 = {
   defaultPlatforms: ["native"],
@@ -23001,9 +23673,9 @@ function loadConfig2() {
 }
 function saveConfig2(config) {
   const configPath = resolveConfigPath();
-  const dir = dirname20(configPath);
-  mkdirSync15(dir, { recursive: true });
-  writeFileSync17(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const dir = dirname19(configPath);
+  mkdirSync17(dir, { recursive: true });
+  writeFileSync19(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function updateConfig(partial) {
   const current = loadConfig2();
@@ -23061,19 +23733,19 @@ function mergeWithDefaults(loaded) {
 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 { homedir as homedir18 } from "os";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync20, mkdirSync as mkdirSync18, existsSync as existsSync25 } from "fs";
+import { dirname as dirname20, join as join25 } from "path";
+import { homedir as homedir20 } from "os";
 var DEFAULT_NTFY_CONFIG = {
   enabled: false,
   serverUrl: "https://ntfy.sh",
   priority: 3
 };
 function getGlobalNtfyPath() {
-  return join23(homedir18(), ".unipi", "config", "notify", "ntfy.json");
+  return join25(homedir20(), ".unipi", "config", "notify", "ntfy.json");
 }
 function getProjectNtfyPath(cwd) {
-  return join23(cwd, ".unipi", "config", "notify", "ntfy.json");
+  return join25(cwd, ".unipi", "config", "notify", "ntfy.json");
 }
 function readNtfyJson(filePath) {
   try {
@@ -23102,9 +23774,9 @@ function loadNtfyConfig(cwd) {
 }
 function saveNtfyConfig(scope, cwd, config) {
   const filePath = scope === "project" ? getProjectNtfyPath(cwd) : getGlobalNtfyPath();
-  const dir = dirname21(filePath);
-  mkdirSync16(dir, { recursive: true });
-  writeFileSync18(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const dir = dirname20(filePath);
+  mkdirSync18(dir, { recursive: true });
+  writeFileSync20(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function getNtfyConfigScope(cwd) {
   if (existsSync25(getProjectNtfyPath(cwd))) {
@@ -23120,8 +23792,8 @@ function migrateFromLegacyConfig() {
   if (existsSync25(globalNtfyPath)) {
     return;
   }
-  const legacyConfigPath = join23(
-    homedir18(),
+  const legacyConfigPath = join25(
+    homedir20(),
     ".unipi",
     "config",
     "notify",
@@ -23142,9 +23814,9 @@ function migrateFromLegacyConfig() {
       token: ntfySection.token,
       priority: ntfySection.priority ?? 3
     };
-    const dir = dirname21(globalNtfyPath);
-    mkdirSync16(dir, { recursive: true });
-    writeFileSync18(
+    const dir = dirname20(globalNtfyPath);
+    mkdirSync18(dir, { recursive: true });
+    writeFileSync20(
       globalNtfyPath,
       JSON.stringify(migratedConfig, null, 2) + "\n",
       "utf-8"
@@ -23158,8 +23830,8 @@ import notifier from "node-notifier";
 
 // packages/notify/platforms/focus-win.ts
 import { execFile } from "child_process";
-import { writeFileSync as writeFileSync19, rmSync as rmSync2, mkdtempSync } from "fs";
-import { join as join24 } from "path";
+import { writeFileSync as writeFileSync21, rmSync as rmSync2, mkdtempSync } from "fs";
+import { join as join26 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 var POWERCHECK_SCRIPT = `
 param($targetPid)
@@ -23195,10 +23867,10 @@ async function isWindowFocusedOnWindows() {
   }
   let tmpDir = null;
   try {
-    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) => {
+    tmpDir = mkdtempSync(join26(tmpdir2(), "pi-focus-"));
+    const scriptPath = join26(tmpDir, "check.ps1");
+    writeFileSync21(scriptPath, POWERCHECK_SCRIPT, "utf-8");
+    const stdout = await new Promise((resolve14, reject) => {
       execFile(
         "powershell.exe",
         [
@@ -23213,7 +23885,7 @@ async function isWindowFocusedOnWindows() {
         { timeout: 5e3, encoding: "utf-8" },
         (err, out) => {
           if (err) reject(err);
-          else resolve13(out);
+          else resolve14(out);
         }
       );
     });
@@ -23255,7 +23927,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,
@@ -23270,7 +23942,7 @@ async function sendNativeNotification(title, message, options) {
             )
           );
         } else {
-          resolve13();
+          resolve14();
         }
       }
     );
@@ -26006,7 +26678,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);
@@ -26035,6 +26707,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();
@@ -26180,7 +26855,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;
@@ -26193,16 +26868,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
+        }
+      }
     };
   });
 }
@@ -26258,14 +26984,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;
@@ -26279,13 +27007,13 @@ function registerSessionEndHook(pi) {
     }
   });
   const syncModifiedDocs = () => {
-    const cwd = process.cwd();
-    const milestonesPath = path13.join(cwd, MILESTONE_DIRS.MILESTONES);
+    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) {
@@ -26303,13 +27031,13 @@ function registerSessionEndHook(pi) {
 
 // packages/milestone/commands.ts
 init_core();
-import { dirname as dirname23, join as join26 } from "node:path";
+import { dirname as dirname22, join as join28 } 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 = join28(dirname22(fileURLToPath11(import.meta.url)), "skills");
 function loadSkill(skillName) {
   try {
-    return readFileSync21(join26(SKILLS_DIR, skillName, "SKILL.md"), "utf-8");
+    return readFileSync21(join28(SKILLS_DIR, skillName, "SKILL.md"), "utf-8");
   } catch {
     return "";
   }
@@ -26362,7 +27090,7 @@ ${skillContent}
     },
     getArgumentCompletions: () => {
       const cwd = process.cwd();
-      const milestonesPath = join26(cwd, MILESTONE_DIRS.MILESTONES);
+      const milestonesPath = join28(cwd, MILESTONE_DIRS.MILESTONES);
       const doc = parseMilestones(milestonesPath);
       const suggestions = doc.phases.map((phase) => ({
         value: phase.name,
@@ -26533,9 +27261,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 */
@@ -26818,6 +27546,7 @@ var COMMAND_REGISTRY = {
   "unipi:worktree-list": "workflow",
   "unipi:worktree-merge": "workflow",
   "unipi:consultant": "workflow",
+  "unipi:prefix-cache": "utility",
   "unipi:quick-work": "workflow",
   "unipi:gather-context": "workflow",
   "unipi:document": "workflow",
@@ -26925,6 +27654,7 @@ var COMMAND_DESCRIPTIONS = {
   "unipi:worktree-list": "List all unipi worktrees",
   "unipi:worktree-merge": "Merge worktree branches back to main",
   "unipi:consultant": "Expert consultation \u2014 advisory analysis",
+  "unipi:prefix-cache": "Show privacy-safe provider prefix-cache diagnostics",
   "unipi:quick-work": "Fast single-task execution \u2014 one shot",
   "unipi:gather-context": "Research codebase \u2014 surface patterns",
   "unipi:document": "Generate documentation \u2014 README, API docs",
@@ -27504,11 +28234,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 { existsSync as existsSync32, mkdirSync as mkdirSync22 } from "node:fs";
+import { homedir as homedir23 } from "node:os";
+import { dirname as dirname25, join as join35 } from "node:path";
 function getWorktreeSuffix() {
   const envSuffix = process.env.COMPACTOR_SESSION_SUFFIX;
   if (envSuffix !== void 0) {
@@ -27522,7 +28252,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 {
@@ -27530,7 +28260,7 @@ function getWorktreeSuffix() {
   return "";
 }
 function defaultDBPath(name) {
-  return join33(homedir21(), ".unipi", "db", "compactor", `${name}.db`);
+  return join35(homedir23(), ".unipi", "db", "compactor", `${name}.db`);
 }
 var sqliteLib = null;
 async function getSQLite() {
@@ -27553,8 +28283,8 @@ var SessionDB = class {
     this.dbPath = opts?.dbPath ?? defaultDBPath("session");
   }
   async init() {
-    const dir = dirname26(this.dbPath);
-    if (!existsSync32(dir)) mkdirSync20(dir, { recursive: true });
+    const dir = dirname25(this.dbPath);
+    if (!existsSync32(dir)) mkdirSync22(dir, { recursive: true });
     const sqlite = await getSQLite();
     const Database2 = sqlite.Database ?? sqlite.default?.Database ?? sqlite.default ?? sqlite;
     this.db = new Database2(this.dbPath);
@@ -27664,7 +28394,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);
@@ -27947,8 +28677,8 @@ async function buildResumeContextMessage(db, sessionId) {
 
 // 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 { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync26, rmSync as rmSync3 } from "node:fs";
+import { join as join36, resolve as resolve11 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 
 // packages/compactor/src/executor/runtime.ts
@@ -28040,7 +28770,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 {
   }
@@ -28129,7 +28859,7 @@ var PolyglotExecutor = class {
   }
   async execute(opts) {
     const { language, code, timeout = 3e4, background = false } = opts;
-    const tmpDir = mkdtempSync2(join34(OS_TMPDIR, ".compactor-"));
+    const tmpDir = mkdtempSync2(join36(OS_TMPDIR, ".compactor-"));
     try {
       const filePath = this.#writeScript(tmpDir, code, language);
       const cmd = buildCommand(this.#runtimes, language, filePath);
@@ -28161,7 +28891,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) {
@@ -28179,12 +28909,12 @@ var PolyglotExecutor = class {
       elixir: "ex"
     };
     const ext = extensions[language];
-    const filePath = join34(tmpDir, `script.${ext}`);
-    writeFileSync24(filePath, code, "utf-8");
+    const filePath = join36(tmpDir, `script.${ext}`);
+    writeFileSync26(filePath, code, "utf-8");
     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(),
@@ -28220,14 +28950,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,
@@ -28238,7 +28968,7 @@ var PolyglotExecutor = class {
     });
   }
   async #compileAndRun(filePath, tmpDir, timeout) {
-    const binPath = join34(tmpDir, "script");
+    const binPath = join36(tmpDir, "script");
     try {
       execSync(`rustc "${filePath}" -o "${binPath}"`, {
         cwd: tmpDir,
@@ -28265,7 +28995,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);
 }
@@ -28309,7 +29039,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;
@@ -28348,15 +29078,29 @@ function searchEntries(blocks, query, opts) {
 }
 
 // packages/compactor/src/tools/vcc-recall.ts
+var MAX_RECALL_RESULTS = 50;
+var MAX_EXPANDED_HIT_BYTES = 16 * 1024;
+function truncateExpandedHit(text) {
+  const bytes = Buffer.from(text, "utf8");
+  if (bytes.byteLength <= MAX_EXPANDED_HIT_BYTES) return text;
+  const omitted = bytes.byteLength - MAX_EXPANDED_HIT_BYTES;
+  const visible = bytes.subarray(0, MAX_EXPANDED_HIT_BYTES).toString("utf8").replace(/\uFFFD+$/u, "");
+  return `${visible}
+\u2026 ${omitted} bytes omitted from this hit; narrow the query to inspect more specific context \u2026`;
+}
 function vccRecall(blocks, input) {
-  const { query, mode = "bm25", limit = 10, offset = 0, expand = false } = input;
+  const { query, mode = "bm25", expand = false } = input;
+  const requestedLimit = Number.isFinite(input.limit) ? Math.floor(input.limit) : 10;
+  const requestedOffset = Number.isFinite(input.offset) ? Math.floor(input.offset) : 0;
+  const limit = Math.min(MAX_RECALL_RESULTS, Math.max(1, requestedLimit));
+  const offset = Math.max(0, requestedOffset);
   let hits = [];
   if (mode === "bm25") {
     const results = searchEntries(blocks, query, { limit: limit + offset, offset: 0 });
     hits = results.map((r, i) => ({
       index: r.docId,
       score: r.score,
-      text: expand ? r.text : r.text.slice(0, 200),
+      text: expand ? truncateExpandedHit(r.text) : r.text.slice(0, 200),
       kind: r.kind
     }));
   } else {
@@ -28368,7 +29112,7 @@ function vccRecall(blocks, input) {
         hits.push({
           index: i,
           score: 1,
-          text: expand ? text : text.slice(0, 200),
+          text: expand ? truncateExpandedHit(text) : text.slice(0, 200),
           kind: b.kind
         });
       }
@@ -28850,7 +29594,11 @@ var RecallParams = Type7.Object({
   mode: Type7.Optional(Type7.Union([Type7.Literal("bm25"), Type7.Literal("regex")], {
     description: "Search mode: bm25 (default) or regex fallback"
   })),
-  limit: Type7.Optional(Type7.Number({ description: "Max results to return (default 10)", minimum: 1 })),
+  limit: Type7.Optional(Type7.Number({
+    description: `Max results to return (default 10, hard cap ${MAX_RECALL_RESULTS})`,
+    minimum: 1,
+    maximum: MAX_RECALL_RESULTS
+  })),
   offset: Type7.Optional(Type7.Number({ description: "Pagination offset", minimum: 0 })),
   expand: Type7.Optional(Type7.Boolean({ description: "Return full message content for hits" }))
 });
@@ -29275,13 +30023,13 @@ function compactorExtension(pi) {
     debug("before_agent_start", { sessionId: currentSessionId, configDebug: config.debug });
     try {
       const { existsSync: existsSync48 } = await import("node:fs");
-      const { join: join48 } = await import("node:path");
+      const { join: join50 } = await import("node:path");
       const strategies = [
         { key: "commits", config: config.commits }
       ];
       for (const { key, config: strat } of strategies) {
         if (strat.autoDetect === "git") {
-          const gitDir = join48(cwd, ".git");
+          const gitDir = join50(cwd, ".git");
           if (!existsSync48(gitDir)) {
             debug("autoDetect_disable", { strategy: key, reason: "no .git dir" });
             strat.enabled = false;
@@ -32795,10 +33543,10 @@ 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";
+import { join as join40 } from "path";
 var PACKAGE_MAP = {
   core: MODULES.CORE,
   workflow: MODULES.WORKFLOW,
@@ -32822,13 +33570,13 @@ 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, "..");
+  return root ?? join40(dir, "..");
 }
 function getPackageVersion2(dir) {
   try {
-    const pkgPath = join38(dir, "package.json");
+    const pkgPath = join40(dir, "package.json");
     if (existsSync39(pkgPath)) {
       const raw = readFileSync34(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
@@ -32841,7 +33589,7 @@ function getPackageVersion2(dir) {
 function discoverReadmes() {
   const root = resolveUnipiRoot();
   const entries = [];
-  const rootReadme = join38(root, "README.md");
+  const rootReadme = join40(root, "README.md");
   if (existsSync39(rootReadme)) {
     entries.push({
       name: "unipi",
@@ -32851,16 +33599,16 @@ function discoverReadmes() {
     });
   }
   for (const [shortName, fullName] of Object.entries(PACKAGE_MAP)) {
-    const workspacePath = join38(root, "packages", shortName, "README.md");
-    const nodeModulesPath = join38(root, "node_modules", fullName, "README.md");
+    const workspacePath = join40(root, "packages", shortName, "README.md");
+    const nodeModulesPath = join40(root, "node_modules", fullName, "README.md");
     let readmePath = null;
     let versionDir = null;
     if (existsSync39(workspacePath)) {
       readmePath = workspacePath;
-      versionDir = join38(root, "packages", shortName);
+      versionDir = join40(root, "packages", shortName);
     } else if (existsSync39(nodeModulesPath)) {
       readmePath = nodeModulesPath;
-      versionDir = join38(root, "node_modules", fullName);
+      versionDir = join40(root, "node_modules", fullName);
     }
     if (readmePath && versionDir) {
       entries.push({
@@ -32876,14 +33624,14 @@ function discoverReadmes() {
 function resolveReadmePath(packageName) {
   const root = resolveUnipiRoot();
   if (!packageName || packageName === "unipi") {
-    const rootReadme = join38(root, "README.md");
+    const rootReadme = join40(root, "README.md");
     return existsSync39(rootReadme) ? rootReadme : null;
   }
   const fullName = PACKAGE_MAP[packageName];
   if (!fullName) return null;
-  const workspacePath = join38(root, "packages", packageName, "README.md");
+  const workspacePath = join40(root, "packages", packageName, "README.md");
   if (existsSync39(workspacePath)) return workspacePath;
-  const nodeModulesPath = join38(root, "node_modules", fullName, "README.md");
+  const nodeModulesPath = join40(root, "node_modules", fullName, "README.md");
   if (existsSync39(nodeModulesPath)) return nodeModulesPath;
   return null;
 }
@@ -33159,7 +33907,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 join41 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 
 // packages/updater/src/version.ts
@@ -33184,15 +33932,15 @@ 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");
+      const packaged = join41(root, "CHANGELOG.md");
       if (existsSync40(packaged)) return packaged;
     }
   } catch {
   }
-  return join39(process.cwd(), "CHANGELOG.md");
+  return join41(process.cwd(), "CHANGELOG.md");
 }
 var VERSION_HEADER_RE = /^## \[(.+?)\](?:\s*[-—–]\s*(.+))?$/;
 var SECTION_HEADER_RE = /^### (.+)$/;
@@ -33444,9 +34192,9 @@ 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 { homedir as homedir24 } from "os";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync28, mkdirSync as mkdirSync24, existsSync as existsSync42 } from "fs";
+import { dirname as dirname29, join as join42 } from "path";
+import { homedir as homedir26 } from "os";
 var DEFAULT_CONFIG6 = {
   checkIntervalMs: 36e5,
   // 1 hour
@@ -33460,8 +34208,8 @@ var VALID_INTERVALS = {
 };
 var VALID_MODES = ["disabled", "notify", "auto"];
 function resolveConfigPath2() {
-  const base = UPDATER_DIRS.CONFIG.replace("~", homedir24());
-  return join40(base, "config.json");
+  const base = UPDATER_DIRS.CONFIG.replace("~", homedir26());
+  return join42(base, "config.json");
 }
 function loadConfig5() {
   const configPath = resolveConfigPath2();
@@ -33477,9 +34225,9 @@ function loadConfig5() {
 }
 function saveConfig4(config) {
   const configPath = resolveConfigPath2();
-  const dir = dirname30(configPath);
-  mkdirSync22(dir, { recursive: true });
-  writeFileSync26(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const dir = dirname29(configPath);
+  mkdirSync24(dir, { recursive: true });
+  writeFileSync28(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function getIntervalLabel(ms) {
   for (const [label, value] of Object.entries(VALID_INTERVALS)) {
@@ -33712,12 +34460,12 @@ 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 { homedir as homedir25 } from "os";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync29, mkdirSync as mkdirSync25, existsSync as existsSync43 } from "fs";
+import { dirname as dirname30, join as join43 } from "path";
+import { homedir as homedir27 } from "os";
 function resolveCachePath() {
-  const base = UPDATER_DIRS.CACHE.replace("~", homedir25());
-  return join41(base, "last-check.json");
+  const base = UPDATER_DIRS.CACHE.replace("~", homedir27());
+  return join43(base, "last-check.json");
 }
 function readLastCheck() {
   const cachePath = resolveCachePath();
@@ -33735,9 +34483,9 @@ function readLastCheck() {
 }
 function writeLastCheck(cache) {
   const cachePath = resolveCachePath();
-  const dir = dirname31(cachePath);
-  mkdirSync23(dir, { recursive: true });
-  writeFileSync27(cachePath, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  const dir = dirname30(cachePath);
+  mkdirSync25(dir, { recursive: true });
+  writeFileSync29(cachePath, JSON.stringify(cache, null, 2) + "\n", "utf-8");
 }
 function isCheckDue(intervalMs) {
   const cache = readLastCheck();
@@ -34145,8 +34893,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 mkdirSync26, readFileSync as readFileSync39, renameSync as renameSync8, writeFileSync as writeFileSync30 } from "node:fs";
+import { dirname as dirname31, join as join44 } from "node:path";
 
 // packages/input-shortcuts/src/types.ts
 var DEFAULT_CONFIG7 = {
@@ -34168,7 +34916,7 @@ var RegisterStore = class {
   filePath;
   loaded = false;
   constructor(baseDir) {
-    this.filePath = baseDir ? join42(baseDir, REGISTERS_FILE) : REGISTERS_FILE;
+    this.filePath = baseDir ? join44(baseDir, REGISTERS_FILE) : REGISTERS_FILE;
   }
   /** Get the stash register contents. */
   getStash() {
@@ -34216,13 +34964,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 });
+        mkdirSync26(dir, { recursive: true });
       }
       const tmpPath = this.filePath + ".tmp";
-      writeFileSync28(tmpPath, JSON.stringify(this.data, null, 2), "utf-8");
-      renameSync7(tmpPath, this.filePath);
+      writeFileSync30(tmpPath, JSON.stringify(this.data, null, 2), "utf-8");
+      renameSync8(tmpPath, this.filePath);
     } catch {
     }
   }
@@ -34443,8 +35191,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 mkdirSync27, readFileSync as readFileSync40, renameSync as renameSync9, writeFileSync as writeFileSync31 } from "node:fs";
+import { dirname as dirname32, join as join45 } from "node:path";
 var ALT_KEY_OPTIONS = [
   "alt+a",
   "alt+b",
@@ -34476,7 +35224,7 @@ var ALT_KEY_OPTIONS = [
 var CONFLICTS = /* @__PURE__ */ new Set(["alt+e"]);
 var FREE_ALT_KEYS = ALT_KEY_OPTIONS.filter((k) => !CONFLICTS.has(k));
 function loadConfig6(baseDir) {
-  const filePath = baseDir ? join43(baseDir, CONFIG_FILE) : CONFIG_FILE;
+  const filePath = baseDir ? join45(baseDir, CONFIG_FILE) : CONFIG_FILE;
   try {
     if (existsSync45(filePath)) {
       const raw = readFileSync40(filePath, "utf-8");
@@ -34491,15 +35239,15 @@ function loadConfig6(baseDir) {
   return { ...DEFAULT_CONFIG7 };
 }
 function saveConfig5(config, baseDir) {
-  const filePath = baseDir ? join43(baseDir, CONFIG_FILE) : CONFIG_FILE;
+  const filePath = baseDir ? join45(baseDir, CONFIG_FILE) : CONFIG_FILE;
   try {
-    const dir = dirname33(filePath);
+    const dir = dirname32(filePath);
     if (!existsSync45(dir)) {
-      mkdirSync25(dir, { recursive: true });
+      mkdirSync27(dir, { recursive: true });
     }
     const tmpPath = filePath + ".tmp";
-    writeFileSync29(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-    renameSync8(tmpPath, filePath);
+    writeFileSync31(tmpPath, JSON.stringify(config, null, 2), "utf-8");
+    renameSync9(tmpPath, filePath);
   } catch {
   }
 }
@@ -34927,9 +35675,9 @@ 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 { homedir as homedir26 } from "node:os";
-import { join as join44 } from "node:path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync28, readFileSync as readFileSync41, writeFileSync as writeFileSync32, readdirSync as readdirSync14, statSync as statSync9 } from "node:fs";
+import { homedir as homedir28 } from "node:os";
+import { join as join46 } from "node:path";
 var DEFAULT_PIPELINE_DIR = ".unipi/cocoindex";
 var DEFAULT_UPDATE_TIMEOUT_MS = 15 * 60 * 1e3;
 var DEFAULT_LEXICAL_SCAN_LIMIT = 5e4;
@@ -34999,13 +35747,13 @@ function resolveCocoindexBin() {
     if (resolved) return resolved;
   } catch {
   }
-  const uvToolBin = join44(homedir26(), ".local", "bin", "cocoindex");
+  const uvToolBin = join46(homedir28(), ".local", "bin", "cocoindex");
   if (existsSync46(uvToolBin)) return uvToolBin;
-  const miseRoot = join44(homedir26(), ".local", "share", "mise", "installs", "python");
+  const miseRoot = join46(homedir28(), ".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");
+      const binPath = join46(miseRoot, ver, "bin", "cocoindex");
       if (existsSync46(binPath)) return binPath;
     }
   } catch {
@@ -35013,13 +35761,13 @@ function resolveCocoindexBin() {
   return "cocoindex";
 }
 function getPipelineDir(projectDir) {
-  return join44(projectDir, DEFAULT_PIPELINE_DIR);
+  return join46(projectDir, DEFAULT_PIPELINE_DIR);
 }
 async function isPipelineInitialized(pipelineDir) {
-  return existsSync46(join44(pipelineDir, "main.py"));
+  return existsSync46(join46(pipelineDir, "main.py"));
 }
 function detectTargetStore(pipelineDir) {
-  const mainPyPath = join44(pipelineDir, "main.py");
+  const mainPyPath = join46(pipelineDir, "main.py");
   if (!existsSync46(mainPyPath)) return "unknown";
   try {
     const content = readFileSync41(mainPyPath, "utf-8");
@@ -35035,14 +35783,14 @@ function detectTargetStore(pipelineDir) {
 async function initPipeline(projectDir) {
   const pipelineDir = getPipelineDir(projectDir);
   if (!existsSync46(pipelineDir)) {
-    mkdirSync26(pipelineDir, { recursive: true });
+    mkdirSync28(pipelineDir, { recursive: true });
   }
-  if (existsSync46(join44(pipelineDir, "main.py"))) {
+  if (existsSync46(join46(pipelineDir, "main.py"))) {
     return { success: true };
   }
   const embeddingConfig = loadEmbeddingConfig2();
   const template = generatePipelineTemplate(projectDir, embeddingConfig);
-  writeFileSync30(join44(pipelineDir, "main.py"), template, "utf-8");
+  writeFileSync32(join46(pipelineDir, "main.py"), template, "utf-8");
   return { success: true };
 }
 async function indexProject(projectDir) {
@@ -35056,7 +35804,7 @@ async function indexProject(projectDir) {
     };
   }
   const pipelineDir = getPipelineDir(projectDir);
-  if (!existsSync46(join44(pipelineDir, "main.py"))) {
+  if (!existsSync46(join46(pipelineDir, "main.py"))) {
     return {
       success: false,
       chunksProcessed: 0,
@@ -35066,7 +35814,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"]
@@ -35096,9 +35844,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,
@@ -35109,7 +35857,7 @@ async function indexProject(projectDir) {
     proc.on("error", (err) => {
       settled = true;
       clearTimeout(timer);
-      resolve13({
+      resolve14({
         success: false,
         chunksProcessed: 0,
         durationMs: Date.now() - start,
@@ -35167,16 +35915,16 @@ function parseChunksProcessed(output) {
 async function status(projectDir) {
   const pipelineDir = getPipelineDir(projectDir);
   const cliAvailable = await isAvailable();
-  const pipelineConfigured = existsSync46(join44(pipelineDir, "main.py"));
+  const pipelineConfigured = existsSync46(join46(pipelineDir, "main.py"));
   const targetStore = detectTargetStore(pipelineDir);
   let docCount = 0;
   let lastRun = null;
-  const lancedbPath = join44(pipelineDir, ".lancedb");
+  const lancedbPath = join46(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 {
     }
@@ -35194,7 +35942,7 @@ async function search(projectDir, query, options) {
   const limit = options?.limit ?? 10;
   const offset = options?.offset ?? 0;
   try {
-    const lancedbPath = join44(getPipelineDir(projectDir), ".lancedb");
+    const lancedbPath = join46(getPipelineDir(projectDir), ".lancedb");
     if (!existsSync46(lancedbPath)) {
       return [];
     }
@@ -35309,7 +36057,7 @@ function countOccurrences(value, needle) {
 }
 function loadEmbeddingConfig2() {
   const envKey = process.env.OPENROUTER_API_KEY ?? null;
-  const configPath = join44(homedir26(), ".unipi", "memory", "config.json");
+  const configPath = join46(homedir28(), ".unipi", "memory", "config.json");
   try {
     if (existsSync46(configPath)) {
       const raw = readFileSync41(configPath, "utf-8");
@@ -35516,9 +36264,22 @@ app = coco.App(
 }
 
 // packages/cocoindex/tools.ts
+var MAX_SEARCH_RESULTS = 50;
+function normalizeSearchPage(limit, offset) {
+  const requestedLimit = Number.isFinite(limit) ? Math.floor(limit) : 10;
+  const requestedOffset = Number.isFinite(offset) ? Math.floor(offset) : 0;
+  return {
+    limit: Math.min(MAX_SEARCH_RESULTS, Math.max(1, requestedLimit)),
+    offset: Math.max(0, requestedOffset)
+  };
+}
 var SearchParams = Type8.Object({
   query: Type8.String({ description: "Search query against indexed content" }),
-  limit: Type8.Optional(Type8.Number({ description: "Max results (default 10)", minimum: 1 })),
+  limit: Type8.Optional(Type8.Number({
+    description: `Max results (default 10, hard cap ${MAX_SEARCH_RESULTS})`,
+    minimum: 1,
+    maximum: MAX_SEARCH_RESULTS
+  })),
   offset: Type8.Optional(Type8.Number({ description: "Pagination offset", minimum: 0 }))
 });
 var StatusParams = Type8.Object({});
@@ -35534,7 +36295,7 @@ function registerCocoindexTools(pi, deps) {
     label: "CocoIndex Search",
     description: "Search indexed content using semantic vector search when available, with full-text/lexical fallbacks. Diagnostic/search only: this tool never installs CocoIndex. Use /unipi:cocoindex-init to set up/install, then /unipi:cocoindex-update to index.",
     parameters: SearchParams,
-    async execute(_toolCallId, params) {
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       try {
         const available = await isAvailable();
         if (!available) {
@@ -35543,9 +36304,10 @@ function registerCocoindexTools(pi, deps) {
             { cliAvailable: false }
           );
         }
-        const results = await search(deps.projectDir, params.query, {
-          limit: params.limit,
-          offset: params.offset
+        const { limit, offset } = normalizeSearchPage(params.limit, params.offset);
+        const results = await search(deps.getProjectDir(ctx), params.query, {
+          limit,
+          offset
         });
         if (results.length === 0) {
           return textResult3(
@@ -35560,7 +36322,8 @@ ${r.content.slice(0, 300)}`
           `Found ${results.length} results for "${params.query}":
 
 ${lines.join("\n\n")}`,
-          { results }
+          // Avoid duplicating full result content in model-visible details.
+          { count: results.length, query: params.query, limit, offset }
         );
       } catch (err) {
         return textResult3(`CocoIndex search error: ${err}`, { error: true });
@@ -35572,9 +36335,9 @@ ${lines.join("\n\n")}`,
     label: "CocoIndex Status",
     description: "Check CocoIndex indexing status. Diagnostic only; use commands for interactive install/update.",
     parameters: StatusParams,
-    async execute() {
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       try {
-        const info = await status(deps.projectDir);
+        const info = await status(deps.getProjectDir(ctx));
         const lines = [
           `\u{1F4E6} CocoIndex Status`,
           `CLI available: ${info.cliAvailable ? "\u2705" : "\u274C"}`,
@@ -35607,8 +36370,8 @@ init_core();
 // packages/cocoindex/installer.ts
 init_core();
 import { execFileSync as execFileSync4, spawn as spawn5 } from "node:child_process";
-import { homedir as homedir27 } from "node:os";
-import { delimiter, join as join45 } from "node:path";
+import { homedir as homedir29 } from "node:os";
+import { delimiter, join as join47 } from "node:path";
 var DEFAULT_STEP_TIMEOUT_MS = 10 * 60 * 1e3;
 function detectShell() {
   const shell = process.env.SHELL ?? "";
@@ -35836,7 +36599,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()
@@ -35859,20 +36622,20 @@ 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 });
     });
   });
 }
 function installerEnv() {
-  const home = homedir27();
+  const home = homedir29();
   const extraPaths = [
-    join45(home, ".local", "bin"),
-    join45(home, ".local", "share", "mise", "shims")
+    join47(home, ".local", "bin"),
+    join47(home, ".local", "share", "mise", "shims")
   ];
   const currentPath = process.env.PATH ?? "";
   return {
@@ -36037,15 +36800,11 @@ ${lines.join("\n\n")}`,
 // packages/cocoindex/index.ts
 function cocoindexExtension(pi) {
   registerCocoindexCommands(pi);
+  registerCocoindexTools(pi, {
+    getProjectDir: (ctx) => ctx.cwd ?? process.cwd()
+  });
   pi.on("session_start", async (_event, ctx) => {
     const projectDir = ctx.cwd ?? process.cwd();
-    const pipelineDir = getPipelineDir(projectDir);
-    const initialized = await isPipelineInitialized(pipelineDir);
-    registerCocoindexTools(pi, {
-      projectDir,
-      pipelineDir,
-      initialized
-    });
     emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.COCOINDEX,
       version: "0.1.0",
@@ -36066,7 +36825,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
@@ -37820,7 +38579,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;
 }