@pi-unipi/unipi 2.4.0 → 2.4.2

package/packages/unipi/bundled.js

@@ -327,7 +327,7 @@ var init_events = __esm({
     UNIPI_EVENTS = {
       /** Module loaded and ready */
       MODULE_READY: "unipi:module:ready",
-      /** Module unloading */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       MODULE_GONE: "unipi:module:gone",
       /** Workflow command started */
       WORKFLOW_START: "unipi:workflow:start",
@@ -339,9 +339,9 @@ var init_events = __esm({
       RALPH_LOOP_END: "unipi:ralph:loop:end",
       /** Ralph loop iteration completed */
       RALPH_ITERATION_DONE: "unipi:ralph:iteration:done",
-      /** Request module status (for info-screen) */
+      /** @deprecated No built-in responders; use the info registry and /unipi:info. */
       MODULE_STATUS_REQUEST: "unipi:module:status:request",
-      /** Module status response */
+      /** @deprecated No built-in aggregator; use the info registry and /unipi:info. */
       MODULE_STATUS_RESPONSE: "unipi:module:status:response",
       /** Info screen group registered */
       INFO_GROUP_REGISTERED: "unipi:info:group:registered",
@@ -351,7 +351,7 @@ var init_events = __esm({
       MEMORY_STORED: "unipi:memory:stored",
       /** Memory deleted */
       MEMORY_DELETED: "unipi:memory:deleted",
-      /** Memory search performed */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       MEMORY_SEARCHED: "unipi:memory:searched",
       /** Memory consolidation completed */
       MEMORY_CONSOLIDATED: "unipi:memory:consolidated",
@@ -369,9 +369,9 @@ var init_events = __esm({
       MCP_CATALOG_SYNCED: "unipi:mcp:catalog:synced",
       /** Compactor: compaction completed */
       COMPACTOR_COMPACTED: "unipi:compactor:compacted",
-      /** Compactor: stats updated */
+      /** @deprecated Footer reads live Pi session data; retained for compatibility. */
       COMPACTOR_STATS_UPDATED: "unipi:compactor:stats:updated",
-      /** Utility module cleanup started */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_CLEANUP_START: "unipi:utility:cleanup:start",
       /** Utility module cleanup completed */
       UTILITY_CLEANUP_DONE: "unipi:utility:cleanup:done",
@@ -379,9 +379,9 @@ var init_events = __esm({
       UTILITY_DIAGNOSTICS_START: "unipi:utility:diagnostics:start",
       /** Utility diagnostics completed */
       UTILITY_DIAGNOSTICS_DONE: "unipi:utility:diagnostics:done",
-      /** Utility cache invalidated */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_CACHE_INVALIDATED: "unipi:utility:cache:invalidated",
-      /** Utility lifecycle state changed */
+      /** @deprecated No built-in emitter; retained for external compatibility. */
       UTILITY_LIFECYCLE_STATE: "unipi:utility:lifecycle:state",
       /** Notification sent */
       NOTIFICATION_SENT: "unipi:notify:sent",
@@ -397,11 +397,11 @@ var init_events = __esm({
       UPDATE_APPLIED: "unipi:update:applied",
       /** Update error */
       UPDATE_ERROR: "unipi:update:error",
-      /** CocoIndex: update started */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_UPDATE_STARTED: "unipi:cocoindex:update:started",
-      /** CocoIndex: update completed */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_UPDATE_COMPLETED: "unipi:cocoindex:update:completed",
-      /** CocoIndex: search performed */
+      /** @deprecated Reserved external contract; no built-in emitter. */
       COCOINDEX_SEARCH_PERFORMED: "unipi:cocoindex:search:performed"
     };
   }
@@ -1457,21 +1457,6 @@ var init_storage = __esm({
           this.db = null;
         }
       }
-      /**
-       * Remove corrupted database files (db, wal, shm).
-       */
-      removeCorruptedDb() {
-        const dbPath = path5.join(this.scopeDir, MEMORY_DB_NAME);
-        const files = [dbPath, `${dbPath}-wal`, `${dbPath}-shm`];
-        for (const file of files) {
-          try {
-            if (fs5.existsSync(file)) {
-              fs5.unlinkSync(file);
-            }
-          } catch {
-          }
-        }
-      }
       /**
        * Check if database is healthy.
        */
@@ -5466,53 +5451,6 @@ var init_snapshot = __esm({
   }
 });
 
-// packages/compactor/src/session/auto-inject.ts
-var auto_inject_exports = {};
-__export(auto_inject_exports, {
-  buildAutoInjection: () => buildAutoInjection
-});
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function buildAutoInjection(events) {
-  const parts = [];
-  let tokenBudget = MAX_TOKENS2;
-  const roleEvents = events.filter((e) => e.category === "rule");
-  if (roleEvents.length > 0) {
-    const directive = roleEvents[roleEvents.length - 1].data;
-    const directiveText = `[Role Directive]
-${directive}`;
-    const tokens = estimateTokens(directiveText);
-    if (tokens <= tokenBudget) {
-      parts.push(directiveText);
-      tokenBudget -= tokens;
-    }
-  }
-  if (tokenBudget > 80) {
-    const intentEvents = events.filter((e) => e.category === "intent");
-    if (intentEvents.length > 0) {
-      const mode = intentEvents[intentEvents.length - 1].data;
-      const modeText = `[Session Mode]
-${mode}`;
-      const tokens = estimateTokens(modeText);
-      if (tokens <= tokenBudget) {
-        parts.push(modeText);
-        tokenBudget -= tokens;
-      }
-    }
-  }
-  if (parts.length === 0) return null;
-  const text = parts.join("\n\n");
-  return { text, tokens: estimateTokens(text) };
-}
-var MAX_TOKENS2;
-var init_auto_inject = __esm({
-  "packages/compactor/src/session/auto-inject.ts"() {
-    "use strict";
-    MAX_TOKENS2 = 150;
-  }
-});
-
 // packages/compactor/src/config/presets.ts
 import { createHash as createHash3 } from "node:crypto";
 function presetHash(config) {
@@ -5546,7 +5484,7 @@ function parsePreset(raw) {
   }
   return void 0;
 }
-var pipeline, pipelineAllOn, preset, PRESET_CONFIGS, presetHashes, OLD_TO_NEW;
+var pipeline, pipelineWithAutoInjection, preset, PRESET_CONFIGS, presetHashes, OLD_TO_NEW;
 var init_presets = __esm({
   "packages/compactor/src/config/presets.ts"() {
     "use strict";
@@ -5556,13 +5494,8 @@ var init_presets = __esm({
       ...overrides,
       customNoisePatterns: [...overrides.customNoisePatterns ?? DEFAULT_COMPACTOR_CONFIG.pipeline.customNoisePatterns]
     });
-    pipelineAllOn = () => pipeline({
-      ttlCache: true,
-      autoInjection: true,
-      proximityReranking: true,
-      timelineSort: true,
-      progressiveThrottling: true,
-      mmapPragma: true
+    pipelineWithAutoInjection = () => pipeline({
+      autoInjection: true
     });
     preset = (overrides) => ({
       ...structuredClone(DEFAULT_COMPACTOR_CONFIG),
@@ -5574,23 +5507,23 @@ var init_presets = __esm({
       userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...overrides.userPreferences ?? {} },
       briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...overrides.briefTranscript ?? {} },
       sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...overrides.sessionContinuity ?? {} },
-      fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, ...overrides.fts5Index ?? {} },
+      // Legacy compatibility data only; presets never advertise or alter it.
+      fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index },
       sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...overrides.sandboxExecution ?? {} },
-      toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...overrides.toolDisplay ?? {} },
+      // Legacy compatibility data only; presets never advertise or alter it.
+      toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay },
       pipeline: pipeline(overrides.pipeline),
       autoCompaction: { ...DEFAULT_COMPACTOR_CONFIG.autoCompaction, ...overrides.autoCompaction ?? {} }
     });
     PRESET_CONFIGS = {
       // New preset names
       precise: preset({
-        pipeline: pipeline({ ttlCache: true, mmapPragma: true }),
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "safe-only" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" }
+        pipeline: pipeline(),
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" }
       }),
       thorough: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" }
       }),
       lean: preset({
         pipeline: pipeline(),
@@ -5601,26 +5534,20 @@ var init_presets = __esm({
         userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
         briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
         sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, enabled: false, mode: "off" },
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, enabled: true, mode: "opencode" }
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" }
       }),
       balanced: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "balanced" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, mode: "auto" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" }
       }),
       // Backward-compat aliases — map old names to new
       opencode: preset({
-        pipeline: pipeline({ ttlCache: true, mmapPragma: true }),
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "safe-only" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "opencode" }
+        pipeline: pipeline(),
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" }
       }),
       verbose: preset({
-        pipeline: pipelineAllOn(),
-        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, mode: "verbose" }
+        pipeline: pipelineWithAutoInjection(),
+        briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" }
       }),
       minimal: preset({
         pipeline: pipeline(),
@@ -5631,9 +5558,7 @@ var init_presets = __esm({
         userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
         briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
         sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-        fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, enabled: false, mode: "off" },
-        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-        toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, enabled: true, mode: "opencode" }
+        sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" }
       }),
       custom: structuredClone(DEFAULT_COMPACTOR_CONFIG)
     };
@@ -5791,7 +5716,7 @@ var init_settings_overlay = __esm({
         key: "sessionContinuity",
         label: "Session Continuity",
         description: "XML resume snapshot for compaction survival",
-        modes: ["full", "essential-only", "off"],
+        modes: ["full", "off"],
         getEnabled: (c) => c.sessionContinuity.enabled,
         setEnabled: (c, v) => c.sessionContinuity.enabled = v,
         getMode: (c) => c.sessionContinuity.mode,
@@ -5801,30 +5726,17 @@ var init_settings_overlay = __esm({
         key: "sandboxExecution",
         label: "Sandbox Execution",
         description: "Polyglot code execution",
-        modes: ["all", "safe-only", "off"],
+        modes: ["all", "off"],
         getEnabled: (c) => c.sandboxExecution.enabled,
         setEnabled: (c, v) => c.sandboxExecution.enabled = v,
         getMode: (c) => c.sandboxExecution.mode,
         setMode: (c, v) => c.sandboxExecution.mode = v
-      },
-      {
-        key: "toolDisplay",
-        label: "Tool Display",
-        description: "Override tool output rendering",
-        modes: ["opencode", "balanced", "verbose", "custom"],
-        getEnabled: (c) => c.toolDisplay.enabled,
-        setEnabled: (c, v) => c.toolDisplay.enabled = v,
-        getMode: (c) => c.toolDisplay.mode,
-        setMode: (c, v) => c.toolDisplay.mode = v
       }
     ];
     PIPELINE_ITEMS = [
-      { key: "ttlCache", label: "TTL Cache", description: "Cache with time-based expiry", group: "On Compaction", getValue: (c) => c.pipeline.ttlCache, setValue: (c, v) => c.pipeline.ttlCache = v },
-      { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => c.pipeline.autoInjection = v },
-      { key: "mmapPragma", label: "MMap Pragma", description: "Use mmap for SQLite I/O", group: "On Compaction", getValue: (c) => c.pipeline.mmapPragma, setValue: (c, v) => c.pipeline.mmapPragma = v },
-      { key: "proximityReranking", label: "Proximity Reranking", description: "Rerank search results by proximity", group: "On Search", getValue: (c) => c.pipeline.proximityReranking, setValue: (c, v) => c.pipeline.proximityReranking = v },
-      { key: "timelineSort", label: "Timeline Sort", description: "Sort session events chronologically", group: "On Search", getValue: (c) => c.pipeline.timelineSort, setValue: (c, v) => c.pipeline.timelineSort = v },
-      { key: "progressiveThrottling", label: "Progressive Throttling", description: "Slow down processing for large projects", group: "On Compaction", getValue: (c) => c.pipeline.progressiveThrottling, setValue: (c, v) => c.pipeline.progressiveThrottling = v }
+      // Only expose implemented behavior. Reserved compatibility fields remain in
+      // the persisted schema so existing config files continue to load.
+      { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => c.pipeline.autoInjection = v }
     ];
     PRESETS2 = ["precise", "balanced", "thorough", "lean"];
     THRESHOLD_VALUES = ["60%", "70%", "75%", "80%", "85%", "90%", "95%"];
@@ -5832,20 +5744,20 @@ var init_settings_overlay = __esm({
     REPEAT_GROWTH_VALUES = ["0", "1k", "4k", "8k", "16k", "32k"];
     PRESET_DESCRIPTIONS = {
       precise: {
-        summary: "Code-heavy, minimal waste \u2014 compaction: full, sandbox: safe-only",
-        detail: "Max token savings. Compaction: full. Display: minimal.\nSandbox: safe-only. Pipeline: ttlCache+mmap on."
+        summary: "Code-heavy, minimal waste \u2014 compaction: full, sandbox: all",
+        detail: "Max token savings. Compaction: full.\nSandbox: all. Auto injection: off."
       },
       balanced: {
         summary: "Daily use (default) \u2014 all strategies moderate",
-        detail: "Moderate all strategies. Display: balanced.\nSandbox: all. Pipeline: all 6 on."
+        detail: "Moderate all strategies.\nSandbox: all. Auto injection: on."
       },
       thorough: {
         summary: "Debug/audit \u2014 everything on, full transcript",
-        detail: "Everything enabled. Display: verbose.\nSandbox: all. Pipeline: all 6 on."
+        detail: "Everything enabled.\nSandbox: all. Auto injection: on."
       },
       lean: {
         summary: "Quick fixes, short sessions \u2014 compaction only",
-        detail: "Compaction only. Display: opencode.\nSandbox: off. Pipeline: all 6 off."
+        detail: "Compaction only.\nSandbox: off. Auto injection: off."
       }
     };
     THEME = {
@@ -6571,137 +6483,6 @@ var init_scanner = __esm({
   }
 });
 
-// packages/compactor/src/display/render-utils.ts
-function splitLines(text) {
-  return text.split(/\r?\n/);
-}
-function countNonEmptyLines(text) {
-  return splitLines(text).filter((l) => l.trim()).length;
-}
-function previewLines(text, lines) {
-  const all = splitLines(text);
-  if (all.length <= lines) return text;
-  return all.slice(0, lines).join("\n") + `
-...(${all.length - lines} more lines)`;
-}
-function shortenPath(path28, maxLen = 60) {
-  if (path28.length <= maxLen) return path28;
-  const parts = path28.split("/");
-  if (parts.length <= 2) return "..." + path28.slice(-(maxLen - 3));
-  return parts[0] + "/.../" + parts.slice(-2).join("/");
-}
-var init_render_utils = __esm({
-  "packages/compactor/src/display/render-utils.ts"() {
-    "use strict";
-  }
-});
-
-// packages/compactor/src/display/tool-overrides.ts
-var tool_overrides_exports = {};
-__export(tool_overrides_exports, {
-  applyToolDisplayOverride: () => applyToolDisplayOverride,
-  renderBashResult: () => renderBashResult,
-  renderReadResult: () => renderReadResult,
-  renderSearchResult: () => renderSearchResult
-});
-function renderReadResult(content, filePath, config) {
-  switch (config.readOutputMode) {
-    case "hidden":
-      return `[Read: ${shortenPath(filePath)}]`;
-    case "summary":
-      return `[Read: ${shortenPath(filePath)} \u2014 ${countNonEmptyLines(content)} lines]`;
-    case "preview":
-      return previewLines(content, config.previewLines ?? 20);
-    default:
-      return content;
-  }
-}
-function renderSearchResult(results, config) {
-  switch (config.searchOutputMode) {
-    case "hidden":
-      return `[Search results hidden]`;
-    case "count":
-      return `[Search: ${countNonEmptyLines(results)} matches]`;
-    case "preview":
-      return previewLines(results, config.previewLines ?? 20);
-    default:
-      return results;
-  }
-}
-function renderBashResult(output, command, config) {
-  switch (config.bashOutputMode) {
-    case "hidden":
-      return `[Bash: ${command.slice(0, 60)}]`;
-    case "summary":
-      return `[Bash: ${command.slice(0, 60)} \u2014 ${countNonEmptyLines(output)} lines]`;
-    case "preview":
-      return previewLines(output, config.bashCollapsedLines ?? 5);
-    default:
-      return output;
-  }
-}
-function applyToolDisplayOverride(toolName, event, config) {
-  const content = event.content;
-  if (!content || !Array.isArray(content) || content.length === 0) return void 0;
-  const textContent = content[0]?.text ?? "";
-  const previewLinesCount = config.previewLines ?? 20;
-  const collapsedLines = config.bashCollapsedLines ?? 5;
-  let overridden;
-  switch (toolName) {
-    case "read": {
-      const filePath = String(event.args?.path ?? "");
-      const mode = config.readOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Read: ${shortenPath(filePath)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Read: ${shortenPath(filePath)} \u2014 ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "grep":
-    case "find":
-    case "ls": {
-      const mode = config.searchOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[${toolName} results hidden]`;
-      } else if (mode === "count") {
-        overridden = `[${toolName}: ${countNonEmptyLines(textContent)} matches]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, previewLinesCount);
-      }
-      break;
-    }
-    case "bash": {
-      const command = String(event.args?.command ?? "");
-      const mode = config.bashOutputMode ?? "full";
-      if (mode === "hidden") {
-        overridden = `[Bash: ${command.slice(0, 60)}]`;
-      } else if (mode === "summary") {
-        overridden = `[Bash: ${command.slice(0, 60)} \u2014 ${countNonEmptyLines(textContent)} lines]`;
-      } else if (mode === "preview") {
-        overridden = previewLines(textContent, collapsedLines);
-      }
-      break;
-    }
-    default:
-      return void 0;
-  }
-  if (overridden !== void 0) {
-    return {
-      content: [{ type: "text", text: overridden }]
-    };
-  }
-  return void 0;
-}
-var init_tool_overrides = __esm({
-  "packages/compactor/src/display/tool-overrides.ts"() {
-    "use strict";
-    init_render_utils();
-  }
-});
-
 // packages/compactor/src/display/diff-width-safety.ts
 var diff_width_safety_exports = {};
 __export(diff_width_safety_exports, {
@@ -7038,6 +6819,15 @@ function registerWorkflowCommands(pi, options) {
         return null;
       },
       handler: async (args, ctx) => {
+        const workflowEvent = {
+          command: cmd.name,
+          fullCommand: `/${fullCommand}`,
+          args: args?.trim() ?? ""
+        };
+        if (!options.startWorkflow(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);
@@ -7106,6 +6896,37 @@ ${taskContent}`,
   });
 }
 
+// packages/workflow/lifecycle.ts
+var WorkflowLifecycle = class {
+  constructor(now2 = Date.now) {
+    this.now = now2;
+  }
+  now;
+  active = null;
+  start(event) {
+    if (this.active) return false;
+    this.active = { ...event, startedAt: this.now() };
+    return true;
+  }
+  complete(messages) {
+    if (!this.active) return void 0;
+    const workflow = this.active;
+    this.active = null;
+    const finalAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    const success = finalAssistant?.stopReason !== "error" && finalAssistant?.stopReason !== "aborted";
+    return {
+      command: workflow.command,
+      fullCommand: workflow.fullCommand,
+      args: workflow.args,
+      success,
+      durationMs: this.now() - workflow.startedAt
+    };
+  }
+  reset() {
+    this.active = null;
+  }
+};
+
 // packages/workflow/index.ts
 var VERSION = getPackageVersion(dirname2(fileURLToPath(import.meta.url)));
 var ralphDetected = false;
@@ -7114,6 +6935,7 @@ var sandboxActive = false;
 var currentSandboxLevel = null;
 var currentSandboxTools = null;
 function workflow_default(pi) {
+  const workflowLifecycle = new WorkflowLifecycle();
   registerWorkflowCommands(pi, {
     isRalphDetected: () => ralphDetected,
     getActiveTools: () => pi.getActiveTools(),
@@ -7125,6 +6947,11 @@ function workflow_default(pi) {
     },
     saveTools: (tools) => {
       savedTools = tools;
+    },
+    startWorkflow: (event) => {
+      if (!workflowLifecycle.start(event)) return false;
+      emitEvent(pi, UNIPI_EVENTS.WORKFLOW_START, event);
+      return true;
     }
   });
   pi.on("tool_call", async (event, _ctx) => {
@@ -7176,7 +7003,7 @@ If the user requires an action that requires a blocked tool, respond that you do
 </sandbox>`
     };
   });
-  pi.on("agent_end", async (_event, _ctx) => {
+  pi.on("agent_end", async (event, _ctx) => {
     if (sandboxActive && savedTools) {
       pi.setActiveTools(savedTools);
       savedTools = null;
@@ -7184,6 +7011,8 @@ If the user requires an action that requires a blocked tool, respond that you do
       currentSandboxLevel = null;
       currentSandboxTools = null;
     }
+    const completedWorkflow = workflowLifecycle.complete(event.messages);
+    if (completedWorkflow) emitEvent(pi, UNIPI_EVENTS.WORKFLOW_END, completedWorkflow);
   });
   pi.on("session_start", async (_event, ctx) => {
     initUnipiDirs();
@@ -7215,6 +7044,7 @@ If the user requires an action that requires a blocked tool, respond that you do
     ralphDetected = false;
     savedTools = null;
     sandboxActive = false;
+    workflowLifecycle.reset();
   });
 }
 
@@ -7480,12 +7310,20 @@ Use /unipi:ralph-resume <name> to continue`, "info");
       );
       return null;
     }
+    this.emitIterationDone(state);
     const needsReflection = state.reflectEvery > 0 && (state.iteration - 1) % state.reflectEvery === 0;
     if (needsReflection) state.lastReflectionAt = state.iteration;
     this.saveState(state);
     this.updateUI();
     return { state, needsReflection };
   }
+  emitIterationDone(state) {
+    this.emitFn(UNIPI_EVENTS.RALPH_ITERATION_DONE, {
+      name: state.name,
+      iteration: state.iteration - 1,
+      nextIteration: state.iteration
+    });
+  }
   archiveLoop(name) {
     const state = this.loadState(name);
     if (!state) return false;
@@ -7743,7 +7581,7 @@ function ralph_default(pi) {
       );
     }
   });
-  pi.on("before_agent_start", async (event, ctx) => {
+  pi.on("before_agent_start", async (_event, ctx) => {
     const mgr = getManager(ctx, pi);
     const currentLoop = mgr.getCurrentLoop();
     if (!currentLoop) return;
@@ -7762,10 +7600,13 @@ function ralph_default(pi) {
 `;
     instructions += `- Otherwise, call ralph_done tool to proceed to next iteration`;
     return {
-      systemPrompt: event.systemPrompt + `
-[RALPH LOOP - ${state.name} - Iteration ${iterStr}]
+      message: {
+        customType: "unipi-ralph-loop-reminder",
+        content: `[RALPH LOOP - ${state.name} - Iteration ${iterStr}]
 
-${instructions}`
+${instructions}`,
+        display: false
+      }
     };
   });
   pi.on("session_shutdown", async (_event, ctx) => {
@@ -10732,7 +10573,6 @@ function info_screen_default(pi) {
 }
 
 // packages/subagents/src/index.ts
-init_core();
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type as Type3 } from "typebox";
@@ -10740,6 +10580,29 @@ import { existsSync as existsSync13, readdirSync as readdirSync7 } from "node:fs
 import { join as join13 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 
+// packages/subagents/src/core-compat.ts
+var MODULES2 = { SUBAGENTS: "subagents" };
+var UNIPI_EVENTS2 = {
+  MODULE_READY: "unipi:module:ready",
+  BADGE_GENERATE_REQUEST: "unipi:badge:generate:request"
+};
+function emitEvent2(pi, eventName, payload) {
+  try {
+    pi.events.emit(eventName, payload);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withHerdrBlocked2(pi, label, fn) {
+  emitEvent2(pi, "herdr:blocked", { active: true, label });
+  try {
+    return await fn();
+  } finally {
+    emitEvent2(pi, "herdr:blocked", { active: false, label });
+  }
+}
+
 // packages/subagents/src/agent-manager.ts
 import { randomUUID } from "node:crypto";
 
@@ -11121,23 +10984,43 @@ var AgentManager = class {
   onStart;
   maxConcurrent;
   customAgents;
+  typeSettings;
   /** Per-file transparent locking for write agents. */
   fileLock = new FileLock();
   /** Queue of background agents waiting to start. */
   queue = [];
   /** Number of currently running background agents. */
   runningBackground = 0;
-  constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart) {
+  constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart, typeSettings = {}, agentsCwd = process.cwd()) {
     this.onComplete = onComplete;
     this.onStart = onStart;
     this.maxConcurrent = maxConcurrent;
-    this.customAgents = loadCustomAgents(process.cwd());
+    this.typeSettings = typeSettings;
+    this.customAgents = loadCustomAgents(agentsCwd);
     this.cleanupInterval = setInterval(() => this.cleanup(), 6e4);
   }
   /** Get resolved agent config for a type. */
   getAgentConfig(type) {
     return this.customAgents.get(type) ?? BUILTIN_CONFIGS[type];
   }
+  /** Public agent types known from built-ins, custom files, or JSON config. */
+  getKnownTypes() {
+    return [.../* @__PURE__ */ new Set([
+      ...Object.keys(BUILTIN_CONFIGS).filter((type) => type !== "name-gen"),
+      ...this.customAgents.keys(),
+      ...Object.keys(this.typeSettings)
+    ])];
+  }
+  /** A type is enabled only when both JSON config and agent frontmatter allow it. */
+  isTypeEnabled(type) {
+    const agentConfig = this.getAgentConfig(type);
+    return this.typeSettings[type]?.enabled !== false && agentConfig?.enabled !== false;
+  }
+  assertTypeEnabled(type) {
+    if (!this.isTypeEnabled(type)) {
+      throw new Error(`Agent type "${type}" is disabled by configuration.`);
+    }
+  }
   setMaxConcurrent(n) {
     this.maxConcurrent = Math.max(1, n);
     this.drainQueue();
@@ -11149,6 +11032,7 @@ var AgentManager = class {
    * Spawn an agent. Returns ID immediately for background, waits for foreground.
    */
   spawn(pi, ctx, type, prompt, options) {
+    this.assertTypeEnabled(type);
     const id = randomUUID().slice(0, 17);
     const abortController = new AbortController();
     const record = {
@@ -11176,9 +11060,11 @@ var AgentManager = class {
     record.startedAt = Date.now();
     if (options.isBackground) this.runningBackground++;
     this.onStart?.(record);
+    const agentConfig = this.getAgentConfig(type);
     let model = options.model;
-    if (options.modelInput && options.modelRegistry) {
-      const resolved = resolveModel(options.modelInput, options.modelRegistry);
+    const modelInput = options.modelInput ?? agentConfig?.model;
+    if (!model && modelInput && options.modelRegistry) {
+      const resolved = resolveModel(modelInput, options.modelRegistry);
       if (typeof resolved === "string") {
         record.status = "error";
         record.error = resolved;
@@ -11191,15 +11077,14 @@ var AgentManager = class {
       }
       model = resolved;
     }
-    const agentConfig = this.getAgentConfig(type);
     const promise = runAgent(ctx, type, prompt, {
       pi,
       model,
       agentConfig,
-      maxTurns: options.maxTurns,
-      isolated: options.isolated,
-      inheritContext: options.inheritContext,
-      thinkingLevel: options.thinkingLevel,
+      maxTurns: options.maxTurns ?? agentConfig?.maxTurns,
+      isolated: options.isolated ?? agentConfig?.isolated,
+      inheritContext: options.inheritContext ?? agentConfig?.inheritContext,
+      thinkingLevel: options.thinkingLevel ?? agentConfig?.thinking,
       signal: record.abortController.signal,
       onToolActivity: (activity) => {
         if (activity.type === "end") record.toolUses++;
@@ -12139,7 +12024,8 @@ function src_default(pi) {
         type: record.type,
         description: record.description
       });
-    }
+    },
+    config.types
   );
   function buildNotificationDetails(record, activity) {
     return {
@@ -12242,14 +12128,14 @@ function src_default(pi) {
   let sessionCtx2 = null;
   pi.on("session_start", async (_event, ctx) => {
     sessionCtx2 = ctx;
-    emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
-      name: MODULES.SUBAGENTS || "subagents",
+    emitEvent2(pi, UNIPI_EVENTS2.MODULE_READY, {
+      name: MODULES2.SUBAGENTS || "subagents",
       version: "0.2.0",
       commands: [],
       tools: ["spawn_helper", "get_helper_result"]
     });
   });
-  pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST, async (data) => {
+  pi.events.on(UNIPI_EVENTS2.BADGE_GENERATE_REQUEST, async (data) => {
     const event = data;
     if (!sessionCtx2) return;
     const summary = event?.conversationSummary ?? "";
@@ -12335,13 +12221,15 @@ ${summary}` : `Generate a concise session title (MAX 5 WORDS) for this session.
     return { state, callbacks };
   }
   const builtinTypes = BUILTIN_TYPES.join(", ");
+  const enabledTypes = manager2.getKnownTypes().filter((type) => manager2.isTypeEnabled(type));
+  const availableTypes = enabledTypes.join(", ") || "none";
   pi.registerTool(
     defineTool({
       name: "spawn_helper",
       label: "Spawn Helper",
       description: `Launch a sub-agent for parallel work.
 
-Available agent types: ${builtinTypes}
+Available agent types: ${availableTypes}
 Custom types can be defined in:
 - ~/.unipi/config/agents/<name>.md (global)
 - <workspace>/.unipi/config/agents/<name>.md (project)
@@ -12354,7 +12242,7 @@ Guidelines:
 - Agents inherit the parent model by default`,
       parameters: Type3.Object({
         type: Type3.String({
-          description: `Agent type: ${builtinTypes}, or custom type from ~/.unipi/config/agents/*.md`
+          description: `Enabled agent type: ${availableTypes}`
         }),
         prompt: Type3.String({
           description: "The task for the agent to perform."
@@ -12597,7 +12485,7 @@ Use get_result to retrieve full results.`,
         }
         if (params.view && record.session) {
           const activity = agentActivity.get(record.id);
-          await withHerdrBlocked(
+          await withHerdrBlocked2(
             pi,
             "helper viewer",
             () => ctx.ui.custom(
@@ -17584,7 +17472,6 @@ var PRESETS = {
     }
   }
 };
-var HARDCODED_FALLBACK = PRESETS.default.colors;
 function getPreset(name) {
   return PRESETS[name] ?? PRESETS.default;
 }
@@ -18239,17 +18126,9 @@ function registerUtilityCommands(pi) {
         }
         return;
       }
-      const requestId = `status-${Date.now()}`;
-      emitEvent(pi, UNIPI_EVENTS.MODULE_STATUS_REQUEST, { requestId });
-      await new Promise((resolve13) => setTimeout(resolve13, 500));
       sendResponse(
         pi,
-        `## \u{1F4CA} Module Status
-
-Status request broadcast to all modules.
-Modules that support status reporting will respond via events.
-
-*Request ID: \`${requestId}\`*`
+        "## \u{1F4CA} Module Status\n\nUse `/unipi:info` for the live module and tool dashboard.\nUse `/unipi:doctor` to run configuration and runtime diagnostics."
       );
     }
   });
@@ -23728,7 +23607,7 @@ function getEnabledPlatforms(config, ntfyEnabled) {
 function unregisterEventListeners() {
   unregisterAll();
 }
-async function dispatchNotification(pi, title, message, eventPlatforms, eventType, config, cwd) {
+async function dispatchNotification(pi, title, message, eventPlatforms, eventType, config, cwd, priority) {
   const ntfyConfig = loadNtfyConfig(cwd);
   const platforms = eventPlatforms.length > 0 ? eventPlatforms : getEnabledPlatforms(config, ntfyConfig.enabled).length > 0 ? getEnabledPlatforms(config, ntfyConfig.enabled) : config.defaultPlatforms;
   const enabledPlatforms = platforms.filter((p) => {
@@ -23741,8 +23620,8 @@ async function dispatchNotification(pi, title, message, eventPlatforms, eventTyp
   const results = await Promise.all(
     enabledPlatforms.map(async (platform) => {
       try {
-        await sendToPlatform(platform, title, message, config, cwd);
-        return { platform, success: true };
+        const effectivePriority = await sendToPlatform(platform, title, message, config, cwd, priority);
+        return { platform, success: true, ...effectivePriority === void 0 ? {} : { priority: effectivePriority } };
       } catch (err) {
         if (err instanceof SuppressedError2) {
           return { platform, success: true, suppressed: true };
@@ -23767,14 +23646,21 @@ async function dispatchNotification(pi, title, message, eventPlatforms, eventTyp
   });
   return { results, allSuccess };
 }
-async function sendToPlatform(platform, title, message, config, cwd) {
+function mapNotifyPriority(platform, priority) {
+  const mappings = {
+    gotify: { low: 2, normal: 5, high: 8 },
+    ntfy: { low: 2, normal: 3, high: 5 }
+  };
+  return mappings[platform][priority];
+}
+async function sendToPlatform(platform, title, message, config, cwd, priority) {
   switch (platform) {
     case "native":
       await sendNativeNotification(title, message, {
         windowsAppId: config.native.windowsAppId,
         suppressWhenFocused: config.native.suppressWhenFocused
       });
-      break;
+      return void 0;
     case "gotify":
       if (!config.gotify.serverUrl || !config.gotify.appToken) {
         throw new Error("Gotify: serverUrl and appToken are required");
@@ -23784,9 +23670,9 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         config.gotify.appToken,
         title,
         message,
-        config.gotify.priority
+        priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority
       );
-      break;
+      return priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority;
     case "telegram":
       if (!config.telegram.botToken || !config.telegram.chatId) {
         throw new Error("Telegram: botToken and chatId are required");
@@ -23797,10 +23683,10 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         title,
         message
       );
-      break;
+      return void 0;
     case "ntfy": {
       const ntfyConfig = loadNtfyConfig(cwd);
-      if (!ntfyConfig.enabled) return;
+      if (!ntfyConfig.enabled) return void 0;
       if (!ntfyConfig.serverUrl || !ntfyConfig.topic) {
         throw new Error("ntfy: serverUrl and topic are required");
       }
@@ -23809,10 +23695,10 @@ async function sendToPlatform(platform, title, message, config, cwd) {
         ntfyConfig.topic,
         title,
         message,
-        ntfyConfig.priority,
+        priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority,
         ntfyConfig.token
       );
-      break;
+      return priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority;
     }
   }
 }
@@ -23941,7 +23827,6 @@ var NotifyUserSchema = Type6.Object({
   priority: Type6.Optional(
     Type6.String({
       enum: ["low", "normal", "high"],
-      default: "normal",
       description: "Priority level"
     })
   ),
@@ -23962,23 +23847,31 @@ function registerNotifyTools(pi) {
       const {
         message,
         title,
-        priority: _priority,
+        priority,
         platforms
       } = params;
       const config = loadConfig2();
       const notifTitle = title || "Pi Notification";
       const notifPlatforms = platforms || config.defaultPlatforms;
       const cwd = process.cwd();
-      dispatchNotification(
+      const dispatchPromise = dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
         config,
-        cwd
-      ).catch(() => {
+        cwd,
+        priority
+      );
+      void dispatchPromise.catch(() => {
       });
+      const priorityByPlatform = priority ? Object.fromEntries(
+        notifPlatforms.flatMap((platform) => {
+          if (platform === "gotify" || platform === "ntfy") return [[platform, mapNotifyPriority(platform, priority)]];
+          return [];
+        })
+      ) : void 0;
       return {
         content: [
           {
@@ -23986,7 +23879,7 @@ function registerNotifyTools(pi) {
             text: `Notification sending to ${notifPlatforms.length} platform(s): ${notifPlatforms.join(", ")}`
           }
         ],
-        details: { platforms: notifPlatforms }
+        details: { platforms: notifPlatforms, priority, priorityByPlatform }
       };
     }
   });
@@ -26385,10 +26278,7 @@ function registerSessionEndHook(pi) {
       }
     }
   });
-  pi.on("input", (event) => {
-    return void 0;
-  });
-  pi.on("session_shutdown", () => {
+  const syncModifiedDocs = () => {
     const cwd = process.cwd();
     const milestonesPath = path13.join(cwd, MILESTONE_DIRS.MILESTONES);
     if (!fs14.existsSync(milestonesPath)) return;
@@ -26406,7 +26296,9 @@ function registerSessionEndHook(pi) {
         updateItemStatus(milestonesPath, phase, text, true);
       }
     }
-  });
+  };
+  pi.events.on(UNIPI_EVENTS.WORKFLOW_END, syncModifiedDocs);
+  pi.on("session_shutdown", syncModifiedDocs);
 }
 
 // packages/milestone/commands.ts
@@ -27976,8 +27868,49 @@ function extractEventsFromToolResult(result) {
 
 // packages/compactor/src/session/resume-inject.ts
 init_snapshot();
-init_auto_inject();
+
+// packages/compactor/src/session/auto-inject.ts
+var MAX_TOKENS2 = 150;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function buildAutoInjection(events) {
+  const parts = [];
+  let tokenBudget = MAX_TOKENS2;
+  const roleEvents = events.filter((e) => e.category === "rule");
+  if (roleEvents.length > 0) {
+    const directive = roleEvents[roleEvents.length - 1].data;
+    const directiveText = `[Role Directive]
+${directive}`;
+    const tokens = estimateTokens(directiveText);
+    if (tokens <= tokenBudget) {
+      parts.push(directiveText);
+      tokenBudget -= tokens;
+    }
+  }
+  if (tokenBudget > 80) {
+    const intentEvents = events.filter((e) => e.category === "intent");
+    if (intentEvents.length > 0) {
+      const mode = intentEvents[intentEvents.length - 1].data;
+      const modeText = `[Session Mode]
+${mode}`;
+      const tokens = estimateTokens(modeText);
+      if (tokens <= tokenBudget) {
+        parts.push(modeText);
+        tokenBudget -= tokens;
+      }
+    }
+  }
+  if (parts.length === 0) return null;
+  const text = parts.join("\n\n");
+  return { text, tokens: estimateTokens(text) };
+}
+
+// packages/compactor/src/session/resume-inject.ts
 init_manager();
+function isSessionContinuityEnabled(config) {
+  return config.sessionContinuity.enabled && config.sessionContinuity.mode !== "off";
+}
 async function injectResumeSnapshot(db, sessionId, opts) {
   const resume = db.getResume(sessionId);
   if (!resume || resume.consumed) return null;
@@ -28000,6 +27933,17 @@ ${autoInjection}`;
   db.markResumeConsumed(sessionId);
   return fullSnapshot;
 }
+async function buildResumeContextMessage(db, sessionId) {
+  const snapshot = await injectResumeSnapshot(db, sessionId);
+  if (!snapshot) return void 0;
+  return {
+    message: {
+      customType: "unipi-compactor-resume",
+      content: snapshot,
+      display: false
+    }
+  };
+}
 
 // packages/compactor/src/executor/executor.ts
 import { spawn as spawn3, execSync, execFileSync as execFileSync2 } from "node:child_process";
@@ -28808,8 +28752,7 @@ function compactTool() {
 }
 
 // packages/compactor/src/tools/ctx-execute.ts
-async function ctxExecute(input) {
-  const executor = new PolyglotExecutor();
+async function ctxExecute(input, executor = new PolyglotExecutor()) {
   return executor.execute({
     language: input.language,
     code: input.code,
@@ -28819,12 +28762,11 @@ async function ctxExecute(input) {
 
 // packages/compactor/src/tools/ctx-execute-file.ts
 import { readFileSync as readFileSync30 } from "node:fs";
-async function ctxExecuteFile(input) {
+async function ctxExecuteFile(input, executor = new PolyglotExecutor()) {
   const content = readFileSync30(input.path, "utf-8");
   const code = `const FILE_CONTENT = ${JSON.stringify(content)};
 // User script follows:
 `;
-  const executor = new PolyglotExecutor();
   return executor.executeFile({
     language: input.language,
     path: input.path,
@@ -28834,9 +28776,8 @@ async function ctxExecuteFile(input) {
 }
 
 // packages/compactor/src/tools/ctx-batch-execute.ts
-async function ctxBatchExecute(items) {
+async function ctxBatchExecute(items, executor = new PolyglotExecutor()) {
   const results = [];
-  const executor = new PolyglotExecutor();
   for (const item of items) {
     if (item.type === "execute") {
       const result = await executor.execute({
@@ -29021,74 +28962,85 @@ ${lines.join("\n\n")}`,
     deprecationLog2("vcc_recall", "session_recall");
     return recallExec(tcId, p);
   } });
-  const sandboxExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+  if (deps.sandbox) {
+    const { executor, allowedLanguages } = deps.sandbox;
+    const assertAllowedLanguage = (language) => {
+      if (!allowedLanguages.includes(language)) {
+        throw new Error(`Language "${language}" is disabled by Compactor sandbox settings. Allowed: ${allowedLanguages.join(", ") || "none"}`);
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxExecute(params);
-      const parts = [];
-      if (result.stdout) parts.push(result.stdout);
-      if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
-      if (result.timedOut) parts.push("[timed out]");
-      if (result.exitCode !== 0) parts.push(`[exit code: ${result.exitCode}]`);
-      return textResult2(parts.join("\n") || "(no output)", result);
-    } catch (err) {
-      return textResult2(`Execution error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox", label: "Sandbox", description: "Run code in a sandboxed environment. Supports 11 languages. Only stdout enters context.", parameters: SandboxParams, execute: sandboxExec });
-  pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId, p) {
-    deprecationLog2("ctx_execute", "sandbox");
-    return sandboxExec(tcId, p);
-  } });
-  const sandboxFileExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+    };
+    const sandboxExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        assertAllowedLanguage(params.language);
+        const result = await ctxExecute(params, executor);
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
+        if (result.timedOut) parts.push("[timed out]");
+        if (result.exitCode !== 0) parts.push(`[exit code: ${result.exitCode}]`);
+        return textResult2(parts.join("\n") || "(no output)", result);
+      } catch (err) {
+        return textResult2(`Execution error: ${err}`, { error: true });
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxExecuteFile(params);
-      const parts = [];
-      if (result.stdout) parts.push(result.stdout);
-      if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
-      if (result.timedOut) parts.push("[timed out]");
-      return textResult2(parts.join("\n") || "(no output)", result);
-    } catch (err) {
-      return textResult2(`Execution error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec });
-  pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId, p) {
-    deprecationLog2("ctx_execute_file", "sandbox_file");
-    return sandboxFileExec(tcId, p);
-  } });
-  const sandboxBatchExec = async (_toolCallId, params) => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) {
-        c.sandboxRuns++;
+    };
+    pi.registerTool({ name: "sandbox", label: "Sandbox", description: "Run code in a sandboxed environment. Supports 11 languages. Only stdout enters context.", parameters: SandboxParams, execute: sandboxExec });
+    pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId, p) {
+      deprecationLog2("ctx_execute", "sandbox");
+      return sandboxExec(tcId, p);
+    } });
+    const sandboxFileExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        assertAllowedLanguage(params.language);
+        const result = await ctxExecuteFile(params, executor);
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
+        if (result.timedOut) parts.push("[timed out]");
+        return textResult2(parts.join("\n") || "(no output)", result);
+      } catch (err) {
+        return textResult2(`Execution error: ${err}`, { error: true });
       }
-      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxBatchExecute(params.items);
-      const summaries = result.results.map((r, i) => {
-        const s = r.result.stdout?.slice(0, 200) || "(no output)";
-        return `[${i}] execute \u2192 ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
-      });
-      return textResult2(`Batch results (${result.results.length} items):
+    };
+    pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec });
+    pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId, p) {
+      deprecationLog2("ctx_execute_file", "sandbox_file");
+      return sandboxFileExec(tcId, p);
+    } });
+    const sandboxBatchExec = async (_toolCallId, params) => {
+      try {
+        const c = deps.getCounters?.();
+        if (c) {
+          c.sandboxRuns++;
+        }
+        deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+        for (const item of params.items) assertAllowedLanguage(item.language);
+        const result = await ctxBatchExecute(params.items, executor);
+        const summaries = result.results.map((r, i) => {
+          const s = r.result.stdout?.slice(0, 200) || "(no output)";
+          return `[${i}] execute \u2192 ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
+        });
+        return textResult2(`Batch results (${result.results.length} items):
 ${summaries.join("\n")}`, result);
-    } catch (err) {
-      return textResult2(`Batch error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec });
-  pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId, p) {
-    deprecationLog2("ctx_batch_execute", "sandbox_batch");
-    return sandboxBatchExec(tcId, p);
-  } });
+      } catch (err) {
+        return textResult2(`Batch error: ${err}`, { error: true });
+      }
+    };
+    pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec });
+    pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId, p) {
+      deprecationLog2("ctx_batch_execute", "sandbox_batch");
+      return sandboxBatchExec(tcId, p);
+    } });
+  }
   const statsExec = async () => {
     try {
       const result = await ctxStats(deps.sessionDB, deps.getSessionId(), deps.getCounters?.());
@@ -29184,9 +29136,6 @@ function measureResponseBytes(event) {
 function isSandboxTool(name) {
   return name === "bash" || name === "Bash";
 }
-function isIndexTool(_name) {
-  return false;
-}
 function compactorExtension(pi) {
   let sessionDB = null;
   let executor = null;
@@ -29204,7 +29153,6 @@ function compactorExtension(pi) {
   const getCounters = () => counters;
   const runtimeStats = {
     bytesReturned: {},
-    bytesIndexed: 0,
     bytesSandboxed: 0,
     calls: {},
     sessionStart: Date.now(),
@@ -29222,7 +29170,7 @@ function compactorExtension(pi) {
     } catch {
       sessionDB = null;
     }
-    executor = new PolyglotExecutor();
+    executor = null;
   };
   registerCompactionHooks(pi, {
     getSessionDB: () => sessionDB,
@@ -29251,7 +29199,6 @@ function compactorExtension(pi) {
       }
     }
     runtimeStats.bytesReturned = {};
-    runtimeStats.bytesIndexed = 0;
     runtimeStats.bytesSandboxed = 0;
     runtimeStats.calls = {};
     runtimeStats.sessionStart = Date.now();
@@ -29260,11 +29207,17 @@ function compactorExtension(pi) {
     autoCompactionState = createAutoCompactionState();
     sessionDB?.ensureSession(fullSessionId, projectDir);
     if (sessionDB) {
+      const sandboxEnabled = config.sandboxExecution.enabled && config.sandboxExecution.mode !== "off";
+      executor = sandboxEnabled ? new PolyglotExecutor({ hardCapBytes: config.sandboxExecution.outputLimit, projectRoot: projectDir }) : null;
       registerCompactorTools(pi, {
         sessionDB,
         getSessionId: () => currentSessionId,
         getBlocks: () => cachedBlocks,
-        getCounters
+        getCounters,
+        sandbox: executor ? {
+          executor,
+          allowedLanguages: config.sandboxExecution.allowedLanguages
+        } : void 0
       });
     }
     registerCommands4(pi, getCommandDeps());
@@ -29350,21 +29303,11 @@ function compactorExtension(pi) {
       }
     } catch {
     }
-    if (sessionDB) {
-      const snapshot = await injectResumeSnapshot(sessionDB, currentSessionId);
-      debug("resume_snapshot", { injected: !!snapshot });
-      if (snapshot && sessionDB) {
-        try {
-          const { buildAutoInjection: buildAutoInjection2 } = await Promise.resolve().then(() => (init_auto_inject(), auto_inject_exports));
-          const events = sessionDB.getEvents(currentSessionId, { limit: 100 });
-          const autoInjection = buildAutoInjection2(events);
-          if (autoInjection) {
-            debug("auto_injection", { tokens: autoInjection.tokens, length: autoInjection.text.length });
-          }
-        } catch (err) {
-          debug("auto_injection_error", { error: String(err) });
-        }
-      }
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
+      const resumeContext = await buildResumeContextMessage(sessionDB, currentSessionId);
+      debug("resume_snapshot", { injected: !!resumeContext });
+      return resumeContext;
     }
   });
   pi.on("turn_end", async (_event, ctx) => {
@@ -29420,7 +29363,8 @@ function compactorExtension(pi) {
     }
   });
   pi.on("session_before_compact", async (event, _ctx) => {
-    if (sessionDB) {
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
       const sessionId = currentSessionId;
       const events = sessionDB.getEvents(sessionId, { limit: 1e3 });
       const stats = sessionDB.getSessionStats(sessionId);
@@ -29439,12 +29383,18 @@ function compactorExtension(pi) {
       counters.compactions++;
       const compactionEntry = event.compactionEntry;
       const tokensBefore = compactionEntry?.tokensBefore ?? 0;
+      let summarized = 0;
+      let kept = 0;
+      let tokensSaved = 0;
       if (tokensBefore > 0) {
         const charsBefore = tokensBefore * 4;
-        const tokensAfter = event.tokensAfter ?? Math.round(tokensBefore * 0.12);
+        const tokensAfter = Math.round(tokensBefore * 0.12);
+        kept = tokensAfter;
+        tokensSaved = tokensBefore - tokensAfter;
         const charsKept = tokensAfter * 4;
         const messagesSummarized = Math.max(1, Math.round(tokensBefore / 500));
-        counters.totalTokensCompacted += tokensBefore - tokensAfter;
+        summarized = messagesSummarized;
+        counters.totalTokensCompacted += tokensSaved;
         sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
       } else {
         try {
@@ -29454,12 +29404,23 @@ function compactorExtension(pi) {
             const estTokensAfter = Math.round(estTokensBefore * 0.12);
             const charsBefore = estTokensBefore * 4;
             const charsKept = estTokensAfter * 4;
-            counters.totalTokensCompacted += estTokensBefore - estTokensAfter;
+            summarized = eventCount;
+            kept = estTokensAfter;
+            tokensSaved = estTokensBefore - estTokensAfter;
+            counters.totalTokensCompacted += tokensSaved;
             sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, eventCount);
           }
         } catch {
         }
       }
+      const totalEstimated = tokensSaved + kept;
+      emitEvent(pi, UNIPI_EVENTS.COMPACTOR_COMPACTED, {
+        sessionId,
+        summarized,
+        kept,
+        tokensSaved,
+        compressionRatio: kept > 0 ? `${Math.round(totalEstimated / kept)}:1` : "0:1"
+      });
       debug("session_compact", { sessionId, tokensBefore, hasCompactionEntry: !!compactionEntry });
     }
   });
@@ -29551,30 +29512,10 @@ function compactorExtension(pi) {
         if (isSandboxTool(tName)) {
           runtimeStats.bytesSandboxed += responseBytes;
         }
-        if (isIndexTool(tName)) {
-          runtimeStats.bytesIndexed += responseBytes;
-        }
       }
     } catch {
     }
     const toolName = event.toolName ?? "";
-    const td = config.toolDisplay;
-    const toolConfig = {
-      readOutputMode: td?.mode,
-      searchOutputMode: td?.mode,
-      bashOutputMode: td?.mode,
-      previewLines: 20,
-      bashCollapsedLines: 5,
-      showTruncationHints: true
-    };
-    try {
-      const { applyToolDisplayOverride: applyToolDisplayOverride2 } = await Promise.resolve().then(() => (init_tool_overrides(), tool_overrides_exports));
-      const override = applyToolDisplayOverride2(toolName, event, toolConfig);
-      if (override !== void 0) {
-        return override;
-      }
-    } catch {
-    }
     const diffToolNames = ["edit", "Edit", "write", "Write"];
     if (diffToolNames.includes(toolName)) {
       try {
@@ -30883,14 +30824,6 @@ var FooterRenderer = class _FooterRenderer {
 init_core();
 function subscribeToEvents(pi, registry3) {
   const unsubscribers = [];
-  unsubscribers.push(
-    pi.events.on(UNIPI_EVENTS.COMPACTOR_STATS_UPDATED, (event) => {
-      try {
-        registry3.updateData("compactor", event);
-      } catch {
-      }
-    })
-  );
   unsubscribers.push(
     pi.events.on(UNIPI_EVENTS.COMPACTOR_COMPACTED, (event) => {
       try {