@cortexkit/pi-magic-context 0.21.6 → 0.21.8

package/dist/index.js

@@ -8163,10 +8163,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join10 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join9(comment, inside, gap);
+    return join10(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -8188,13 +8188,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join10(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join10(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -8215,13 +8215,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join10(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join10(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -8343,7 +8343,57 @@ var init_rpc_notifications = __esm(() => {
 
 // src/index.ts
 import { createRequire as createRequire4 } from "node:module";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
+
+// ../plugin/src/config/agent-disable.ts
+function isDreamerRunnable(config) {
+  return !!config.dreamer && config.dreamer.disable !== true;
+}
+function clonePlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return { ...value };
+}
+function migrateLegacyEnabledForAgent(args) {
+  const agent = clonePlainObject(args.patched[args.agentName]);
+  if (!agent || !("enabled" in agent))
+    return;
+  const enabled = agent.enabled;
+  const disable = agent.disable;
+  delete agent.enabled;
+  if (args.agentName === "historian") {
+    args.warnings.push('Removed invalid "historian.enabled" in-memory (run doctor to persist).');
+    args.patched.historian = agent;
+    return;
+  }
+  if (args.agentName === "dreamer") {
+    if (disable !== true && enabled === false) {
+      agent.disable = true;
+      args.warnings.push('Migrated "dreamer.enabled=false" → "dreamer.disable=true" in-memory (run doctor to persist). This now also disables manual /ctx-dream; for manual-only remove disable and set schedule="".');
+    }
+    args.patched.dreamer = agent;
+    return;
+  }
+  if (disable !== true && enabled === false) {
+    agent.disable = true;
+    args.warnings.push('Migrated "sidekick.enabled=false" → "sidekick.disable=true" in-memory (run doctor to persist).');
+  }
+  args.patched.sidekick = agent;
+}
+function migrateLegacyAgentEnabledInMemory(rawConfig, warnings) {
+  const shouldPatch = ["dreamer", "sidekick", "historian"].some((key) => {
+    const agent = rawConfig[key];
+    return typeof agent === "object" && agent !== null && !Array.isArray(agent) && "enabled" in agent;
+  });
+  if (!shouldPatch)
+    return rawConfig;
+  const patched = { ...rawConfig };
+  migrateLegacyEnabledForAgent({ patched, agentName: "dreamer", warnings });
+  migrateLegacyEnabledForAgent({ patched, agentName: "sidekick", warnings });
+  migrateLegacyEnabledForAgent({ patched, agentName: "historian", warnings });
+  return patched;
+}
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
@@ -141830,6 +141880,40 @@ function parseReportedLimit(message) {
   }
   return;
 }
+// ../plugin/src/features/magic-context/compartment-lease.ts
+var COMPARTMENT_LEASE_TTL_MS = 5 * 60 * 1000;
+var COMPARTMENT_LEASE_RENEWAL_MS = 60 * 1000;
+function acquireCompartmentLease(db, sessionId, holderId) {
+  const acquiredAt = Date.now();
+  const expiresAt = acquiredAt + COMPARTMENT_LEASE_TTL_MS;
+  const result = db.prepare(`INSERT INTO compartment_state_lease (session_id, holder_id, acquired_at, expires_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id) DO UPDATE SET
+                holder_id = excluded.holder_id,
+                acquired_at = excluded.acquired_at,
+                expires_at = excluded.expires_at
+             WHERE compartment_state_lease.holder_id = excluded.holder_id
+                OR compartment_state_lease.expires_at <= ?`).run(sessionId, holderId, acquiredAt, expiresAt, acquiredAt);
+  if (result.changes !== 1) {
+    return null;
+  }
+  return { sessionId, holderId, acquiredAt, expiresAt };
+}
+function renewCompartmentLease(db, sessionId, holderId) {
+  const now = Date.now();
+  const expiresAt = now + COMPARTMENT_LEASE_TTL_MS;
+  const result = db.prepare(`UPDATE compartment_state_lease
+             SET expires_at = ?, acquired_at = ?
+             WHERE session_id = ? AND holder_id = ? AND expires_at > ?`).run(expiresAt, now, sessionId, holderId, now);
+  return result.changes === 1;
+}
+function releaseCompartmentLease(db, sessionId, holderId) {
+  db.prepare("DELETE FROM compartment_state_lease WHERE session_id = ? AND holder_id = ?").run(sessionId, holderId);
+}
+function isCompartmentLeaseHeld(db, sessionId, holderId) {
+  const row = db.prepare("SELECT 1 FROM compartment_state_lease WHERE session_id = ? AND holder_id = ? AND expires_at > ?").get(sessionId, holderId, Date.now());
+  return row != null;
+}
 
 // ../plugin/src/features/magic-context/compartment-storage.ts
 var insertCompartmentStatements = new WeakMap;
@@ -141940,6 +142024,38 @@ function replaceAllCompartmentState(db, sessionId, compartments, facts) {
     db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
   })();
 }
+function replaceAllCompartmentStateAndBumpDepth(db, holderId, sessionId, compartments, facts, depthStartOrdinal, depthEndOrdinal) {
+  const now = Date.now();
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    if (!isCompartmentLeaseHeld(db, sessionId, holderId)) {
+      db.exec("ROLLBACK");
+      finished = true;
+      return false;
+    }
+    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+    insertCompartmentRows(db, sessionId, compartments, now);
+    insertFactRows(db, sessionId, facts, now);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
+    if (depthEndOrdinal >= depthStartOrdinal) {
+      const stmt = getIncrementDepthStatement(db);
+      for (let ordinal = depthStartOrdinal;ordinal <= depthEndOrdinal; ordinal += 1) {
+        stmt.run(sessionId, ordinal, getHarness());
+      }
+    }
+    db.exec("COMMIT");
+    finished = true;
+    return true;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
 function buildCompartmentBlock(compartments, facts, memoryBlock, dateRanges) {
   const lines = [];
   if (memoryBlock) {
@@ -142007,12 +142123,37 @@ function getRecompStaging(db, sessionId) {
     lastEndMessage: lastEnd
   };
 }
-function promoteRecompStaging(db, sessionId) {
+function promoteRecompStaging(db, sessionId, holderId) {
   const now = Date.now();
-  return db.transaction(() => {
+  if (!holderId) {
+    return db.transaction(() => {
+      const staging = getRecompStaging(db, sessionId);
+      if (!staging || staging.compartments.length === 0)
+        return null;
+      db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
+      db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+      insertCompartmentRows(db, sessionId, staging.compartments, now);
+      insertFactRows(db, sessionId, staging.facts, now);
+      db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
+      db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
+      db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
+      return { compartments: staging.compartments, facts: staging.facts };
+    })();
+  }
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    if (!isCompartmentLeaseHeld(db, sessionId, holderId)) {
+      db.exec("ROLLBACK");
+      finished = true;
+      return null;
+    }
     const staging = getRecompStaging(db, sessionId);
-    if (!staging || staging.compartments.length === 0)
+    if (!staging || staging.compartments.length === 0) {
+      db.exec("ROLLBACK");
+      finished = true;
       return null;
+    }
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
     insertCompartmentRows(db, sessionId, staging.compartments, now);
@@ -142020,8 +142161,16 @@ function promoteRecompStaging(db, sessionId) {
     db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
     db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
+    db.exec("COMMIT");
+    finished = true;
     return { compartments: staging.compartments, facts: staging.facts };
-  })();
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
 }
 function invalidateAllMemoryBlockCaches(db) {
   try {
@@ -142669,6 +142818,65 @@ var MIGRATIONS = [
         db.exec("ALTER TABLE session_meta ADD COLUMN pending_pi_compaction_marker_state TEXT");
       }
     }
+  },
+  {
+    version: 19,
+    description: "Add compartment state lease table",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS compartment_state_lease (
+                    session_id TEXT PRIMARY KEY NOT NULL,
+                    holder_id TEXT NOT NULL,
+                    acquired_at INTEGER NOT NULL,
+                    expires_at INTEGER NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_compartment_state_lease_expires
+                    ON compartment_state_lease(expires_at);
+            `);
+    }
+  },
+  {
+    version: 20,
+    description: "Add subagent invocation token accounting",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS subagent_invocations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    harness TEXT NOT NULL,
+                    subagent TEXT NOT NULL,
+                    task TEXT,
+                    provider_id TEXT,
+                    model_id TEXT,
+                    started_at INTEGER NOT NULL,
+                    ended_at INTEGER,
+                    status TEXT NOT NULL,
+                    input_tokens INTEGER NOT NULL DEFAULT 0,
+                    output_tokens INTEGER NOT NULL DEFAULT 0,
+                    cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+                    cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+                    error TEXT,
+                    parent_invocation_id INTEGER
+                );
+                CREATE INDEX IF NOT EXISTS idx_sai_session_started
+                    ON subagent_invocations(session_id, started_at DESC);
+                CREATE INDEX IF NOT EXISTS idx_sai_subagent
+                    ON subagent_invocations(subagent, started_at DESC);
+            `);
+    }
+  },
+  {
+    version: 21,
+    description: "Add session lifetime work metrics",
+    up: (db) => {
+      const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+      if (!cols.some((c) => c.name === "new_work_tokens")) {
+        db.exec("ALTER TABLE session_meta ADD COLUMN new_work_tokens INTEGER NOT NULL DEFAULT 0");
+      }
+      if (!cols.some((c) => c.name === "total_input_tokens")) {
+        db.exec("ALTER TABLE session_meta ADD COLUMN total_input_tokens INTEGER NOT NULL DEFAULT 0");
+      }
+    }
   }
 ];
 function ensureMigrationsTable(db) {
@@ -143124,6 +143332,15 @@ function initializeDatabase(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_compartments_session ON compartments(session_id);
 
+    CREATE TABLE IF NOT EXISTS compartment_state_lease (
+      session_id TEXT PRIMARY KEY NOT NULL,
+      holder_id TEXT NOT NULL,
+      acquired_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_compartment_state_lease_expires
+      ON compartment_state_lease(expires_at);
+
     CREATE TABLE IF NOT EXISTS compression_depth (
       session_id TEXT NOT NULL,
       message_ordinal INTEGER NOT NULL,
@@ -143320,12 +143537,37 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       -- is a valid JSON blob written via setPendingPiCompactionMarkerState.
       -- Excluded from healNullTextColumns.
       pending_pi_compaction_marker_state TEXT,
+      new_work_tokens INTEGER NOT NULL DEFAULT 0,
+      total_input_tokens INTEGER NOT NULL DEFAULT 0,
       -- deferred_execute_state: intentionally NULLABLE without a default.
       -- Absence is SQL NULL; presence is a JSON blob written via
       -- setDeferredExecutePendingIfAbsent. Excluded from healNullTextColumns.
       deferred_execute_state TEXT
     );
 
+    CREATE TABLE IF NOT EXISTS subagent_invocations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      harness TEXT NOT NULL,
+      subagent TEXT NOT NULL,
+      task TEXT,
+      provider_id TEXT,
+      model_id TEXT,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      status TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      error TEXT,
+      parent_invocation_id INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_sai_session_started
+      ON subagent_invocations(session_id, started_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_sai_subagent
+      ON subagent_invocations(subagent, started_at DESC);
+
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
     CREATE INDEX IF NOT EXISTS idx_tags_session_message_id ON tags(session_id, message_id);
     CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
@@ -143417,6 +143659,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "pending_compaction_marker_state", "TEXT");
   ensureColumn(db, "session_meta", "pending_pi_compaction_marker_state", "TEXT");
+  ensureColumn(db, "session_meta", "new_work_tokens", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "total_input_tokens", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "deferred_execute_state", "TEXT");
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -143480,7 +143724,9 @@ function healNullIntegerColumns(db) {
     ["tool_call_tokens", 0],
     ["note_nudge_trigger_pending", 0],
     ["observed_safe_input_tokens", 0],
-    ["cache_alert_sent", 0]
+    ["cache_alert_sent", 0],
+    ["new_work_tokens", 0],
+    ["total_input_tokens", 0]
   ];
   for (const [column, fallback] of columns) {
     try {
@@ -144046,6 +144292,7 @@ function getPendingPiCompactionMarkerState(db, sessionId) {
       return parsed;
     }
   } catch {}
+  db.prepare("UPDATE session_meta SET pending_pi_compaction_marker_state = NULL WHERE session_id = ? AND pending_pi_compaction_marker_state = ?").run(sessionId, raw);
   return null;
 }
 function setPendingPiCompactionMarkerState(db, sessionId, state) {
@@ -144089,6 +144336,12 @@ function clearDeferredExecutePendingIfMatches(db, sessionId, expected) {
              WHERE session_id = ? AND deferred_execute_state = ?`).run(sessionId, expectedBlob);
   return result.changes > 0;
 }
+function setSessionWorkMetrics(db, sessionId, newWorkTokens, totalInputTokens) {
+  ensureSessionMetaRow(db, sessionId);
+  db.prepare(`UPDATE session_meta
+         SET new_work_tokens = ?, total_input_tokens = ?
+         WHERE session_id = ?`).run(Math.max(0, Math.floor(newWorkTokens)), Math.max(0, Math.floor(totalInputTokens)), sessionId);
+}
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
 init_logger();
 await init_read_session_db();
@@ -144404,6 +144657,19 @@ function getSourceContents(db, sessionId, tagIds) {
   }
   return sources;
 }
+// ../plugin/src/features/magic-context/storage-subagent-invocations.ts
+function clampToken(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function recordSubagentInvocation(db, input) {
+  const result = db.prepare(`INSERT INTO subagent_invocations (
+                session_id, harness, subagent, task, provider_id, model_id,
+                started_at, ended_at, status,
+                input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+                error, parent_invocation_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.sessionId, input.harness, input.subagent, input.task ?? null, input.providerId ?? null, input.modelId ?? null, input.startedAt, input.endedAt, input.status, clampToken(input.inputTokens), clampToken(input.outputTokens), clampToken(input.cacheReadTokens), clampToken(input.cacheWriteTokens), input.error ?? null, input.parentInvocationId ?? null);
+  return Number(result.lastInsertRowid);
+}
 // ../plugin/src/features/magic-context/storage-tags.ts
 var insertTagStatements = new WeakMap;
 var updateTagStatusStatements = new WeakMap;
@@ -145266,10 +145532,98 @@ function isTodoItem(value) {
   return typeof todo.content === "string" && typeof todo.status === "string" && (todo.priority === undefined || typeof todo.priority === "string");
 }
 
+// ../plugin/src/shared/announcement.ts
+init_data_path();
+import * as fs2 from "node:fs";
+import * as path5 from "node:path";
+var ANNOUNCEMENT_VERSION = "0.21.7";
+var ANNOUNCEMENT_FEATURES = [
+  "Pi parity sweep: 44 audit findings fixed, including a critical SHIP-BLOCKER where /ctx-flush did not drain the pending Pi compaction queue.",
+  "Pi historian recovery fix: empty/no-op historian returns now clear emergency recovery so sessions cannot loop forever at 95%.",
+  "trimPiMessagesToBoundary now sweeps non-contiguous tool-result orphans, fixing provider 400s after compaction in long Pi sessions.",
+  "Hidden subagent tool isolation: historian, dreamer, and sidekick can no longer spawn subagents or run unsafe tools.",
+  "TUI sidebar and /ctx-status header now show execute threshold inline: '47.5% / 65%' on the left, '475K / 1.0M' on the right.",
+  "doctor --issue now caps GitHub issue bodies at ~60KB with a dedicated 'Recent errors' section so reports stay submittable."
+];
+var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU";
+var STATE_FILENAME = "last_announced_version";
+function getStateFilePath() {
+  return path5.join(getMagicContextStorageDir(), STATE_FILENAME);
+}
+function readLastAnnouncedVersion() {
+  try {
+    const file = getStateFilePath();
+    if (!fs2.existsSync(file))
+      return "";
+    return fs2.readFileSync(file, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function markAnnouncementSeen(version) {
+  if (!version)
+    return;
+  try {
+    const dir = getMagicContextStorageDir();
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(getStateFilePath(), version);
+  } catch {}
+}
+function shouldShowAnnouncement() {
+  if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0)
+    return false;
+  return readLastAnnouncedVersion() !== ANNOUNCEMENT_VERSION;
+}
+
 // src/index.ts
 init_data_path();
 init_logger();
 
+// ../plugin/src/shared/resolve-fallbacks.ts
+function resolveFallbackChain(agentName, userFallbacks) {
+  const userList = normalizeUserFallbacks(userFallbacks);
+  if (userList.length > 0) {
+    return dedupe(userList.filter(isValidModelSpec));
+  }
+  const builtin = getAgentFallbackModels(agentName);
+  if (!builtin || builtin.length === 0)
+    return [];
+  return dedupe(builtin.filter(isValidModelSpec));
+}
+function normalizeUserFallbacks(userFallbacks) {
+  if (!userFallbacks)
+    return [];
+  if (typeof userFallbacks === "string") {
+    const trimmed = userFallbacks.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function isValidModelSpec(spec) {
+  const slash = spec.indexOf("/");
+  return slash > 0 && slash < spec.length - 1;
+}
+function dedupe(list) {
+  const seen = new Set;
+  const out = [];
+  for (const item of list) {
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function parseProviderModel(spec) {
+  const slash = spec.indexOf("/");
+  if (slash < 1 || slash >= spec.length - 1)
+    return null;
+  return {
+    providerID: spec.slice(0, slash).trim(),
+    modelID: spec.slice(slash + 1).trim()
+  };
+}
+
 // ../plugin/src/features/magic-context/sidekick/core.ts
 var SIDEKICK_SYSTEM_PROMPT = `You are Sidekick, a focused memory-retrieval subagent for an AI coding assistant.
 
@@ -145295,17 +145649,108 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname3, join as join8, resolve as resolvePath } from "node:path";
+import { dirname as dirname3, join as join9, resolve as resolvePath } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
+
+// ../plugin/src/features/magic-context/subagent-token-capture.ts
+init_logger();
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function tokenObjectFromMessage(message) {
+  const info = message.info;
+  if (info && typeof info === "object") {
+    const tokens2 = info.tokens;
+    if (tokens2 && typeof tokens2 === "object")
+      return tokens2;
+  }
+  const tokens = message.tokens;
+  if (tokens && typeof tokens === "object")
+    return tokens;
+  return null;
+}
+function isAssistantMessage(message) {
+  if (!message || typeof message !== "object")
+    return false;
+  const record = message;
+  const info = record.info;
+  if (info && typeof info === "object") {
+    return info.role === "assistant";
+  }
+  return record.role === "assistant";
+}
+function modelFromMessage(message) {
+  const info = message.info;
+  const source = info && typeof info === "object" ? info : message;
+  return {
+    providerId: typeof source.providerID === "string" ? source.providerID : typeof source.providerId === "string" ? source.providerId : null,
+    modelId: typeof source.modelID === "string" ? source.modelID : typeof source.modelId === "string" ? source.modelId : null
+  };
+}
+function emptyTokenTotals() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function sumTokensFromChildMessages(messages) {
+  const totals = emptyTokenTotals();
+  for (const message of messages) {
+    if (!isAssistantMessage(message))
+      continue;
+    const tokens = tokenObjectFromMessage(message);
+    if (!tokens)
+      continue;
+    const cache = tokens.cache && typeof tokens.cache === "object" ? tokens.cache : {};
+    totals.input += asNumber(tokens.input);
+    totals.output += asNumber(tokens.output);
+    totals.cacheRead += asNumber(cache.read ?? tokens.cacheRead ?? tokens.cache_read);
+    totals.cacheWrite += asNumber(cache.write ?? tokens.cacheWrite ?? tokens.cache_write);
+  }
+  return totals;
+}
+function findLastAssistantModel(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (isAssistantMessage(message))
+      return modelFromMessage(message);
+  }
+  return { providerId: null, modelId: null };
+}
+function recordChildInvocation(input) {
+  const tokens = input.tokens ?? sumTokensFromChildMessages(input.messages ?? []);
+  const model = input.providerId !== undefined || input.modelId !== undefined ? { providerId: input.providerId ?? null, modelId: input.modelId ?? null } : findLastAssistantModel(input.messages ?? []);
+  try {
+    return recordSubagentInvocation(input.db, {
+      sessionId: input.parentSessionId,
+      harness: input.harness,
+      subagent: input.subagent,
+      task: input.task ?? null,
+      providerId: model.providerId,
+      modelId: model.modelId,
+      startedAt: input.startedAt,
+      endedAt: input.endedAt ?? Date.now(),
+      status: input.status,
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      cacheReadTokens: tokens.cacheRead,
+      cacheWriteTokens: tokens.cacheWrite,
+      error: input.error ? describeError(input.error).brief : null,
+      parentInvocationId: input.parentInvocationId ?? null
+    });
+  } catch (error) {
+    sessionLog(input.parentSessionId, "subagent token accounting failed:", describeError(error).brief);
+    return null;
+  }
+}
+
+// src/subagent-runner.ts
 function resolveBundledPiCli() {
   try {
     const require_ = createRequire3(import.meta.url);
     const pkgJson = require_.resolve("@earendil-works/pi-coding-agent/package.json");
-    const cliPath = join8(dirname3(pkgJson), "dist/cli.js");
-    if (existsSync6(cliPath))
+    const cliPath = join9(dirname3(pkgJson), "dist/cli.js");
+    if (existsSync7(cliPath))
       return cliPath;
     return null;
   } catch {
@@ -145316,7 +145761,7 @@ function resolveSubagentEntryPath() {
   try {
     const here = dirname3(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync6(candidate))
+    if (existsSync7(candidate))
       return candidate;
     return;
   } catch {
@@ -145329,6 +145774,17 @@ var DREAMER_ACTION_AGENTS = new Set([
   "dreamer",
   "magic-context-dreamer"
 ]);
+function inferAccountingSubagent(agent) {
+  if (agent.includes("sidekick"))
+    return "sidekick";
+  if (agent.includes("dreamer"))
+    return "dreamer";
+  if (agent.includes("compressor"))
+    return "compressor";
+  if (agent.includes("recomp"))
+    return "recomp";
+  return "historian";
+}
 
 class PiSubagentRunner {
   harness = "pi";
@@ -145348,22 +145804,67 @@ class PiSubagentRunner {
     this.spawnImpl = options.spawnImpl ?? childProcess.spawn;
   }
   async run(options) {
+    const models = [options.model, ...options.fallbackModels ?? []].filter((model) => typeof model === "string" && model.length > 0);
+    const attempts = models.length > 0 ? models : [undefined];
+    let lastResult = null;
+    for (let index = 0;index < attempts.length; index += 1) {
+      const model = attempts[index];
+      const attemptOptions = {
+        ...options,
+        model,
+        fallbackModels: undefined
+      };
+      const result = await this.runOnce(attemptOptions);
+      if (result.ok)
+        return result;
+      lastResult = result;
+      if (index >= attempts.length - 1 || !isFallbackEligible(result.reason)) {
+        return result;
+      }
+    }
+    return lastResult ?? this.runOnce({ ...options, fallbackModels: undefined });
+  }
+  async runOnce(options) {
     const startTime = Date.now();
+    let recordedAccounting = false;
+    const recordAccounting = (result, messages = []) => {
+      if (!options.accountingSessionId || recordedAccounting)
+        return;
+      recordedAccounting = true;
+      recordChildInvocation({
+        db: openDatabase(),
+        parentSessionId: options.accountingSessionId,
+        harness: "pi",
+        subagent: options.accountingSubagent ?? inferAccountingSubagent(options.agent),
+        task: options.accountingTask ?? null,
+        startedAt: startTime,
+        status: result.ok ? "completed" : result.reason === "abort" ? "aborted" : "failed",
+        messages,
+        providerId: typeof options.model === "string" ? options.model.split("/")[0] : null,
+        modelId: typeof options.model === "string" ? options.model.split("/").slice(1).join("/") : null,
+        error: result.ok ? null : result.error,
+        parentInvocationId: options.accountingParentInvocationId ?? null
+      });
+    };
     if (options.signal?.aborted) {
-      return {
+      const result = {
         ok: false,
         reason: "abort",
         error: "pi subagent aborted by caller",
         durationMs: Date.now() - startTime
       };
+      recordAccounting(result);
+      return result;
     }
     const args = buildArgs(options);
     return new Promise((resolve2) => {
+      let accountingMessages = [];
       let settled = false;
       const settle = (result) => {
         if (settled)
           return;
         settled = true;
+        recordAccounting(result, accountingMessages);
         resolve2(result);
       };
       const emitProgress = (event) => {
@@ -145433,6 +145934,7 @@ class PiSubagentRunner {
       let lastEventType = null;
       let lastEventTimestamp = 0;
       const accumulatedMessages = [];
+      accountingMessages = accumulatedMessages;
       rl.on("line", (line) => {
         if (line.length === 0)
           return;
@@ -145484,7 +145986,7 @@ class PiSubagentRunner {
           const m = e.message;
           if (m.role === "assistant") {
             const hasToolCall = Array.isArray(m.content) && m.content.some((c) => typeof c === "object" && c !== null && c.type === "toolCall");
-            const isTerminalStopReason = typeof m.stopReason === "string" && (m.stopReason === "stop" || m.stopReason === "length" || m.stopReason === "error" || m.stopReason === "aborted");
+            const isTerminalStopReason = typeof m.stopReason === "string" && (m.stopReason === "stop" || m.stopReason === "length" || m.stopReason === "aborted");
             if (isTerminalStopReason && !hasToolCall) {
               sawAgentEnd = true;
               const result = extractFinalAssistant(accumulatedMessages);
@@ -145506,6 +146008,10 @@ class PiSubagentRunner {
         }
         if (sawAgentEnd && !drainTimerStarted) {
           drainTimerStarted = true;
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = undefined;
+          }
           drainTimerHandle = setTimeout(() => {
             if (settled)
               return;
@@ -145588,6 +146094,20 @@ class PiSubagentRunner {
             });
             return;
           }
+          if (code !== 0 || signal !== null) {
+            settle({
+              ok: false,
+              reason: "non_zero_exit",
+              error: `pi exited (code=${code}, signal=${signal}) after terminal assistant event. stderr: ${stderr.slice(0, 500) || "(empty)"}`,
+              durationMs: Date.now() - startTime,
+              meta: {
+                stderr: stderr.length > 0 ? stderr : undefined,
+                exitCode: code,
+                signal
+              }
+            });
+            return;
+          }
           if (finalStopReason === "error" || finalStopReason === "aborted" || finalStopReason === "length") {
             settle({
               ok: false,
@@ -145649,6 +146169,9 @@ class PiSubagentRunner {
     });
   }
 }
+function isFallbackEligible(reason) {
+  return reason === "model_failed" || reason === "truncated" || reason === "non_zero_exit" || reason === "no_assistant";
+}
 function buildArgs(options) {
   const args = [
     "--print",
@@ -145659,7 +146182,8 @@ function buildArgs(options) {
     "--no-skills",
     "--no-prompt-templates"
   ];
-  if (SUBAGENT_ENTRY_PATH) {
+  const shouldLoadSubagentExtension = SUBAGENT_ENTRY_PATH && (options.agent === "sidekick" || DREAMER_ACTION_AGENTS.has(options.agent));
+  if (shouldLoadSubagentExtension) {
     args.push("--extension", SUBAGENT_ENTRY_PATH);
     if (DREAMER_ACTION_AGENTS.has(options.agent)) {
       args.push("--magic-context-dreamer-actions");
@@ -145668,11 +146192,8 @@ function buildArgs(options) {
   if (options.systemPrompt && options.systemPrompt.length > 0) {
     args.push("--system-prompt", options.systemPrompt);
   }
-  const models = [options.model, ...options.fallbackModels ?? []].filter((model) => typeof model === "string" && model.length > 0);
-  if (models.length > 1) {
-    args.push("--models", models.join(","));
-  } else if (models.length === 1) {
-    args.push("--model", models[0]);
+  if (typeof options.model === "string" && options.model.length > 0) {
+    args.push("--model", options.model);
   }
   if (options.thinkingLevel) {
     args.push("--thinking", options.thinkingLevel);
@@ -145762,10 +146283,13 @@ function registerCtxAugCommand(pi, config) {
         systemPrompt: config.systemPrompt ?? SIDEKICK_SYSTEM_PROMPT,
         userMessage: prompt,
         model: config.model,
+        fallbackModels: config.fallbackModels,
         timeoutMs: config.timeoutMs ?? 30000,
         cwd: ctx.cwd,
         signal: ctx.signal,
-        thinkingLevel: config.thinking_level
+        thinkingLevel: config.thinking_level,
+        accountingSessionId: sessionLabel,
+        accountingSubagent: "sidekick"
       });
       if (!result.ok) {
         log(`[magic-context][pi] /ctx-aug: sidekick failed (${result.reason}): ${result.error}`);
@@ -145972,61 +146496,14 @@ function clearStaleEntries(db, maxAgeMs) {
 // src/commands/ctx-dream.ts
 init_logger();
 // ../plugin/src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // ../plugin/src/shared/index.ts
 init_logger();
 
 // ../plugin/src/shared/model-suggestion-retry.ts
 init_logger();
-
-// ../plugin/src/shared/resolve-fallbacks.ts
-function resolveFallbackChain(agentName, userFallbacks) {
-  const userList = normalizeUserFallbacks(userFallbacks);
-  if (userList.length > 0) {
-    return dedupe(userList.filter(isValidModelSpec));
-  }
-  const builtin = getAgentFallbackModels(agentName);
-  if (!builtin || builtin.length === 0)
-    return [];
-  return dedupe(builtin.filter(isValidModelSpec));
-}
-function normalizeUserFallbacks(userFallbacks) {
-  if (!userFallbacks)
-    return [];
-  if (typeof userFallbacks === "string") {
-    const trimmed = userFallbacks.trim();
-    return trimmed ? [trimmed] : [];
-  }
-  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function isValidModelSpec(spec) {
-  const slash = spec.indexOf("/");
-  return slash > 0 && slash < spec.length - 1;
-}
-function dedupe(list) {
-  const seen = new Set;
-  const out = [];
-  for (const item of list) {
-    if (seen.has(item))
-      continue;
-    seen.add(item);
-    out.push(item);
-  }
-  return out;
-}
-function parseProviderModel(spec) {
-  const slash = spec.indexOf("/");
-  if (slash < 1 || slash >= spec.length - 1)
-    return null;
-  return {
-    providerID: spec.slice(0, slash).trim(),
-    modelID: spec.slice(slash + 1).trim()
-  };
-}
-
-// ../plugin/src/shared/model-suggestion-retry.ts
 function extractMessage(error) {
   if (typeof error === "string")
     return error;
@@ -146267,20 +146744,20 @@ init_logger();
 await init_sqlite();
 
 // ../plugin/src/features/magic-context/key-files/identify-key-files.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { join as join11 } from "node:path";
 init_logger();
 
 // ../plugin/src/features/magic-context/key-files/aft-availability.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var overrideAvailability = null;
-function parseConfig(path5) {
-  if (!existsSync7(path5))
+function parseConfig(path6) {
+  if (!existsSync8(path6))
     return null;
-  return import_comment_json.parse(readFileSync3(path5, "utf-8"));
+  return import_comment_json.parse(readFileSync4(path6, "utf-8"));
 }
 function entryMatchesAft(entry) {
   const value = Array.isArray(entry) ? entry[0] : entry;
@@ -146302,15 +146779,15 @@ function hasAftAtKeys(value, keys) {
 function getAftAvailability() {
   const home = process.env.HOME || homedir3();
   const opencodePaths = [
-    join9(home, ".config", "opencode", "opencode.jsonc"),
-    join9(home, ".config", "opencode", "opencode.json")
+    join10(home, ".config", "opencode", "opencode.jsonc"),
+    join10(home, ".config", "opencode", "opencode.json")
   ];
-  const piPaths = [join9(home, ".pi", "agent", "settings.json")];
+  const piPaths = [join10(home, ".pi", "agent", "settings.json")];
   const checkedPaths = [...opencodePaths, ...piPaths];
   let opencode = false;
-  for (const path5 of opencodePaths) {
+  for (const path6 of opencodePaths) {
     try {
-      const config = parseConfig(path5);
+      const config = parseConfig(path6);
       if (hasAftAtKeys(config, ["plugin", "plugins", "mcp", "mcp_servers"])) {
         opencode = true;
         break;
@@ -146318,9 +146795,9 @@ function getAftAvailability() {
     } catch {}
   }
   let pi = false;
-  for (const path5 of piPaths) {
+  for (const path6 of piPaths) {
     try {
-      const config = parseConfig(path5);
+      const config = parseConfig(path6);
       if (hasAftAtKeys(config, ["packages", "extensions"])) {
         pi = true;
         break;
@@ -146769,7 +147246,7 @@ async function runKeyFilesTask(args) {
     if (row.staleReason !== null || row.generationConfigHash !== configHash)
       return false;
     try {
-      return sha256(readFileSync4(join10(projectPath, row.path))) === row.contentHash;
+      return sha256(readFileSync5(join11(projectPath, row.path))) === row.contentHash;
     } catch {
       return false;
     }
@@ -147693,6 +148170,17 @@ function buildDreamTaskPrompt(task, args) {
 }
 
 // ../plugin/src/features/magic-context/user-memory/storage-user-memory.ts
+function insertUserMemoryCandidates(db, candidates) {
+  if (candidates.length === 0)
+    return;
+  const now = Date.now();
+  const stmt = db.prepare("INSERT INTO user_memory_candidates (content, session_id, source_compartment_start, source_compartment_end, created_at) VALUES (?, ?, ?, ?, ?)");
+  db.transaction(() => {
+    for (const c of candidates) {
+      stmt.run(c.content, c.sessionId, c.sourceCompartmentStart ?? null, c.sourceCompartmentEnd ?? null, now);
+    }
+  })();
+}
 function getUserMemoryCandidates(db) {
   const rows = db.prepare("SELECT id, content, session_id, source_compartment_start, source_compartment_end, created_at FROM user_memory_candidates ORDER BY created_at ASC").all();
   return rows.map((r) => ({
@@ -147799,6 +148287,23 @@ Return valid JSON (no markdown fencing):
 
 If no promotions are warranted, return empty arrays. Always consume reviewed candidates so they don't accumulate indefinitely.`;
   let agentSessionId = null;
+  const startedAt = Date.now();
+  let invocationRecorded = false;
+  const recordInvocation = (params) => {
+    if (!args.parentSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      harness: "opencode",
+      subagent: "user_memory_review",
+      startedAt,
+      status: params.status,
+      messages: params.messages,
+      error: params.error
+    });
+  };
   const abortController = new AbortController;
   const leaseInterval = setInterval(() => {
     try {
@@ -147820,8 +148325,11 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
     });
     const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof created?.id === "string" ? created.id : null;
-    if (!agentSessionId)
-      throw new Error("Could not create user memory review session.");
+    if (!agentSessionId) {
+      const error = new Error("Could not create user memory review session.");
+      recordInvocation({ status: "failed", error });
+      throw error;
+    }
     log(`[dreamer] user-memories: child session created ${agentSessionId}`);
     const remainingMs = Math.max(0, args.deadline - Date.now());
     await promptSyncWithModelSuggestionRetry(args.client, {
@@ -147845,6 +148353,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
     const messages = normalizeSDKResponse(messagesResponse, [], {
       preferResponseOnMissingData: true
     });
+    recordInvocation({ status: "completed", messages });
     const responseText = extractLatestAssistantText(messages);
     if (!responseText) {
       log("[dreamer] user-memories: no response from review agent");
@@ -147966,11 +148475,11 @@ function logWithStackHead(message, stackHead) {
   log(message, stackHead ? { stackHead } : undefined);
 }
 function getOpenCodeDbPath2() {
-  return join11(getDataDir(), "opencode", "opencode.db");
+  return join12(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync8(dbPath)) {
+  if (!existsSync9(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -148084,6 +148593,24 @@ async function runDream(args) {
       log(`[dreamer] starting task: ${taskName}`);
       const taskStartedAt = Date.now();
       let agentSessionId = null;
+      const invocationStartedAt = Date.now();
+      let invocationRecorded = false;
+      const recordInvocation = (params) => {
+        if (!parentSessionId || invocationRecorded)
+          return;
+        invocationRecorded = true;
+        recordChildInvocation({
+          db: args.db,
+          parentSessionId,
+          harness: "opencode",
+          subagent: "dreamer",
+          task: taskName,
+          startedAt: invocationStartedAt,
+          status: params.status,
+          messages: params.messages,
+          error: params.error
+        });
+      };
       const taskAbortController = new AbortController;
       const leaseRenewalInterval = setInterval(() => {
         try {
@@ -148101,8 +148628,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync8(join11(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync8(join11(docsDir, "STRUCTURE.md"))
+          architecture: existsSync9(join12(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync9(join12(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -148124,7 +148651,9 @@ async function runDream(args) {
         const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
         agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
         if (!agentSessionId) {
-          throw new Error("Dreamer could not create its child session.");
+          const error = new Error("Dreamer could not create its child session.");
+          recordInvocation({ status: "failed", error });
+          throw error;
         }
         log(`[dreamer] task ${taskName}: child session created ${agentSessionId}`);
         await promptSyncWithModelSuggestionRetry(args.client, {
@@ -148151,6 +148680,7 @@ async function runDream(args) {
         const messages = normalizeSDKResponse(messagesResponse, [], {
           preferResponseOnMissingData: true
         });
+        recordInvocation({ status: "completed", messages });
         const taskResult = extractLatestAssistantText(messages);
         if (!taskResult) {
           throw new Error("Dreamer returned no assistant output.");
@@ -148165,6 +148695,7 @@ async function runDream(args) {
         lastErrorSignature = null;
         consecutiveSameErrorFailures = 0;
       } catch (error) {
+        recordInvocation({ status: lostLease ? "aborted" : "failed", error });
         const durationMs = Date.now() - taskStartedAt;
         const errorDescription = describeError(error);
         logWithStackHead(`[dreamer] task ${taskName}: failed after ${(durationMs / 1000).toFixed(1)}s — ${errorDescription.brief}`, errorDescription.stackHead);
@@ -148434,6 +148965,24 @@ ${noteDescriptions}
 Only include notes whose conditions you could definitively evaluate against external signals. Skip notes where you cannot determine the status (they will be re-evaluated next run, or eventually archived as stale).`;
   const taskStartedAt = Date.now();
   let agentSessionId = null;
+  const startedAt = Date.now();
+  let invocationRecorded = false;
+  const recordInvocation = (params) => {
+    if (!args.parentSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      harness: "opencode",
+      subagent: "dreamer",
+      task: "smart-notes",
+      startedAt,
+      status: params.status,
+      messages: params.messages,
+      error: params.error
+    });
+  };
   const abortController = new AbortController;
   const leaseInterval = setInterval(() => {
     try {
@@ -148457,8 +149006,11 @@ Only include notes whose conditions you could definitively evaluate against exte
     });
     const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof created?.id === "string" ? created.id : null;
-    if (!agentSessionId)
-      throw new Error("Could not create smart note evaluation session.");
+    if (!agentSessionId) {
+      const error = new Error("Could not create smart note evaluation session.");
+      recordInvocation({ status: "failed", error });
+      throw error;
+    }
     log(`[dreamer] smart notes: child session created ${agentSessionId}`);
     const remainingMs = Math.max(0, args.deadline - Date.now());
     await promptSyncWithModelSuggestionRetry(args.client, {
@@ -148482,6 +149034,7 @@ Only include notes whose conditions you could definitively evaluate against exte
     const messages = normalizeSDKResponse(messagesResponse, [], {
       preferResponseOnMissingData: true
     });
+    recordInvocation({ status: "completed", messages });
     const output = extractLatestAssistantText(messages);
     if (!output)
       throw new Error("Smart note evaluation returned no output.");
@@ -149518,10 +150071,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -149929,11 +150482,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -150080,16 +150633,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path6 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -150116,17 +150669,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path6 = []) => {
     var _a2, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -150158,8 +150711,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -162618,13 +163171,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path6 = ref.slice(1).split("/").filter(Boolean);
+  if (path6.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path6[0] === defsKey) {
+    const key = path6[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -163093,7 +163646,6 @@ var DEFAULT_DREAMER_TASKS = [
 ];
 var PiThinkingLevelSchema = exports_external.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional();
 var DreamerConfigSchema = AgentOverrideConfigSchema.merge(exports_external.object({
-  enabled: exports_external.boolean().default(false),
   schedule: exports_external.string().default("02:00-06:00"),
   max_runtime_minutes: exports_external.number().min(10).default(120),
   tasks: exports_external.array(DreamingTaskSchema).default(DEFAULT_DREAMER_TASKS),
@@ -163111,7 +163663,6 @@ var DreamerConfigSchema = AgentOverrideConfigSchema.merge(exports_external.objec
   thinking_level: PiThinkingLevelSchema
 }));
 var SidekickConfigSchema = AgentOverrideConfigSchema.extend({
-  enabled: exports_external.boolean().default(false),
   timeout_ms: exports_external.number().default(30000),
   system_prompt: exports_external.string().optional(),
   thinking_level: PiThinkingLevelSchema
@@ -163295,9 +163846,9 @@ function getEmbeddingProviderIdentity(config2) {
 }
 
 // ../plugin/src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync as mkdirSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname4, join as join12 } from "node:path";
+import { dirname as dirname4, join as join13 } from "node:path";
 import { pathToFileURL } from "node:url";
 init_data_path();
 init_logger();
@@ -163364,7 +163915,7 @@ async function injectWasmOrtForElectron() {
       const { createRequire: createRequireFn } = await import("node:module");
       const requireFn = createRequireFn(import.meta.url);
       const pkgPath = requireFn.resolve("onnxruntime-web/package.json");
-      const distDir = join12(dirname4(pkgPath), "dist");
+      const distDir = join13(dirname4(pkgPath), "dist");
       const wasmPathsPrefix = `${pathToFileURL(distDir).href}/`;
       if (ortWeb.env?.wasm) {
         ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
@@ -163475,15 +164026,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join12(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync4(modelCacheDir, { recursive: true });
+          mkdirSync5(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join12(modelCacheDir, ".load.lock");
+        const lockPath = join13(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -164651,7 +165202,7 @@ async function startDreamScheduleTimer(args) {
   const db = openDatabase();
   await args.ensureRegistered(args.directory, db);
   const snapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
-  const dreamingEnabled = Boolean(args.dreamerConfig?.enabled && args.dreamerConfig.schedule?.trim());
+  const dreamingEnabled = Boolean(args.dreamerConfig && args.dreamerConfig.disable !== true && args.dreamerConfig.schedule?.trim());
   const embeddingSweepEnabled = snapshot?.enabled ?? false;
   const commitIndexingEnabled = snapshot?.gitCommitEnabled ?? false;
   if (!dreamingEnabled && !embeddingSweepEnabled && !commitIndexingEnabled) {
@@ -164707,7 +165258,7 @@ function runTick(origin) {
   })();
 }
 async function sweepProject(reg, origin, db = openDatabase(), gitCommitEnabled = getProjectEmbeddingSnapshot(reg.projectIdentity)?.gitCommitEnabled === true) {
-  const dreamingEnabled = Boolean(reg.dreamerConfig?.enabled && reg.dreamerConfig.schedule?.trim());
+  const dreamingEnabled = Boolean(reg.dreamerConfig && reg.dreamerConfig.disable !== true && reg.dreamerConfig.schedule?.trim());
   if (gitCommitEnabled && reg.gitCommitIndexing) {
     await sweepGitCommits({
       directory: reg.directory,
@@ -164835,12 +165386,12 @@ function handleUntrustedLoad(db, projectIdentity, directory, detailed) {
 }
 
 // src/config/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname5, isAbsolute, resolve as resolve3 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
@@ -164898,13 +165449,13 @@ function substituteConfigVariables(input) {
     } else if (!isAbsolute(filePath)) {
       filePath = resolve3(configDir, filePath);
     }
-    if (!existsSync9(filePath)) {
+    if (!existsSync10(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync5(filePath, "utf-8").trim();
+      contents = readFileSync6(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -164920,39 +165471,39 @@ function substituteConfigVariables(input) {
 var import_comment_json2 = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join13(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join14(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir5();
-  const basePath = join13(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join14(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path5) => existsSync10(path5));
+  return paths.find((path6) => existsSync11(path6));
 }
-function loadConfigFile(path5, scope) {
+function loadConfigFile(path6, scope) {
   try {
-    const rawText = readFileSync6(path5, "utf-8");
+    const rawText = readFileSync7(path6, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path5
+      configPath: path6
     });
     return {
-      path: path5,
+      path: path6,
       scope,
       config: import_comment_json2.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`),
+      warnings: substituted.warnings.map((warning) => `${path6}: ${warning}`),
       loadOutcome: substituted.warnings.length > 0 ? "substitution-failure" : "ok"
     };
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     return {
-      path: path5,
+      path: path6,
       scope,
       config: {},
       warnings: [
-        `${path5}: failed to load config: ${message}; using defaults for this file.`
+        `${path6}: failed to load config: ${message}; using defaults for this file.`
       ],
       loadOutcome: typeof error51.code === "string" ? "project-file-io-error" : "project-file-parse-error"
     };
@@ -164990,9 +165541,11 @@ function mergeRawConfigs(base, override) {
   return merged;
 }
 function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
-  const parsed = MagicContextConfigSchema.safeParse(rawConfig);
+  const preMigrationWarnings = [];
+  const migrated = migrateLegacyAgentEnabledInMemory(rawConfig, preMigrationWarnings);
+  const parsed = MagicContextConfigSchema.safeParse(migrated);
   if (parsed.success) {
-    return { config: parsed.data, warnings: [] };
+    return { config: parsed.data, warnings: preMigrationWarnings };
   }
   const defaults = MagicContextConfigSchema.parse({});
   const errorPaths = new Set;
@@ -165002,8 +165555,8 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
       errorPaths.add(String(topKey));
     }
   }
-  const patched = { ...rawConfig };
-  const warnings = [];
+  const patched = { ...migrated };
+  const warnings = [...preMigrationWarnings];
   for (const key of errorPaths) {
     recoveredTopLevelKeys.push(key);
     const isAgentConfig = key === "historian" || key === "dreamer" || key === "sidekick";
@@ -165077,9 +165630,9 @@ function bindSubstitutionFailures(loaded) {
   }
   const emptyPaths = collectEmptyStringPaths(loaded.config);
   return loaded.warnings.map((message) => {
-    const matchedPath = emptyPaths.find((path5) => {
-      const tail = path5.split(".").at(-1) ?? path5;
-      return message.includes(path5) || message.toLowerCase().includes(tail.toLowerCase());
+    const matchedPath = emptyPaths.find((path6) => {
+      const tail = path6.split(".").at(-1) ?? path6;
+      return message.includes(path6) || message.toLowerCase().includes(tail.toLowerCase());
     });
     return {
       keyPath: matchedPath ?? "<unknown>",
@@ -165175,7 +165728,7 @@ var sessionCounter = 0;
 var piSubagentRunnerFactory = () => new PiSubagentRunner;
 var startDreamScheduleTimerFn = startDreamScheduleTimer;
 function registerPiDreamerProject(opts) {
-  if (!opts.config.enabled) {
+  if (opts.config.disable === true) {
     return;
   }
   const existing = registeredProjects2.get(opts.projectIdentity);
@@ -165410,7 +165963,7 @@ function registerCtxDreamCommand(pi, deps) {
       if (deps.dreamerEnabled === false) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-dream",
-          text: "## /ctx-dream\n\nDreamer is not configured for this project (`dreamer.enabled=false`).",
+          text: "## /ctx-dream\n\nDreamer is disabled for this project (`dreamer.disable=true`).",
           level: "info"
         }, {
           projectDir: project.projectDir,
@@ -165456,6 +166009,8 @@ function registerCtxDreamCommand(pi, deps) {
         let summary;
         if (!result) {
           summary = "Dream queued, but another worker is already processing the queue.";
+        } else if (result.tasks.length === 0) {
+          summary = "Dreamer is configured, but no dream tasks are enabled for this project.";
         } else {
           const taskLines = result.tasks.map((task) => {
             const status = task.error ? `error: ${task.error}` : "ok";
@@ -165848,6 +166403,57 @@ function createTagger() {
   };
 }
 
+// ../plugin/src/features/magic-context/work-metrics.ts
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function getPiUsage(entry) {
+  if (!entry || typeof entry !== "object")
+    return null;
+  const record2 = entry;
+  const message = record2.message && typeof record2.message === "object" ? record2.message : record2;
+  if (message.role !== "assistant")
+    return null;
+  if (!message.usage || typeof message.usage !== "object")
+    return null;
+  const usage = message.usage;
+  return {
+    input: asNumber2(usage.input),
+    output: asNumber2(usage.output),
+    cacheRead: asNumber2(usage.cacheRead ?? usage.cache_read),
+    cacheWrite: asNumber2(usage.cacheWrite ?? usage.cache_write)
+  };
+}
+function computePiWorkMetrics(sessionEntries) {
+  let previousPrompt = 0;
+  let phasePeak = 0;
+  let newWorkTokens = 0;
+  let totalInputTokens = 0;
+  let lastOutput = 0;
+  let sawAssistant = false;
+  for (const entry of sessionEntries) {
+    const usage = getPiUsage(entry);
+    if (!usage)
+      continue;
+    const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+    if (sawAssistant && prompt < previousPrompt) {
+      totalInputTokens += phasePeak;
+      phasePeak = prompt;
+    } else {
+      phasePeak = Math.max(phasePeak, prompt);
+    }
+    newWorkTokens += Math.max(0, prompt - previousPrompt);
+    previousPrompt = prompt;
+    lastOutput = usage.output;
+    sawAssistant = true;
+  }
+  if (sawAssistant) {
+    totalInputTokens += phasePeak;
+    newWorkTokens += lastOutput;
+  }
+  return { newWorkTokens, totalInputTokens };
+}
+
 // ../plugin/src/hooks/magic-context/apply-operations.ts
 var USER_DROP_PREVIEW_CHARS = 250;
 function buildReplacementContent(tagId, target) {
@@ -167787,7 +168393,7 @@ function stripNestedSystemReminders(text) {
   return result;
 }
 function extractUserPromptText(message) {
-  return stripNestedSystemReminders(collectUserPromptParts(message)).replace(/§\d+§\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<!--\s*ALFONSO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
+  return stripNestedSystemReminders(collectUserPromptParts(message)).replace(/<!--[\s\S]*?-->/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/<\/?[a-zA-Z][^<>]*>/g, "").replace(/§\d+§\s*/g, "").replace(/[ \t]+\n/g, `
 `).replace(/\n{3,}/g, `
 
 `).trim();
@@ -167958,18 +168564,28 @@ function applyDeferredPiCompactionMarker(deps, sessionId, pending) {
       return { kind: "stale-skip", reason: "target-superseded" };
     }
     const branchEntries = deps.readBranchEntries();
-    if (!branchEntries.some((entry) => getEntryId(entry) === pending.firstKeptEntryId)) {
+    const pendingFirstKeptIndex = findEntryIndex(branchEntries, pending.firstKeptEntryId);
+    if (pendingFirstKeptIndex < 0) {
       return { kind: "stale-skip", reason: "entry-removed" };
     }
     const latestFirstKept = findLatestCompactionFirstKept(branchEntries);
-    if (latestFirstKept === pending.firstKeptEntryId) {
-      return { kind: "already-current" };
+    if (latestFirstKept !== null) {
+      const latestFirstKeptIndex = findEntryIndex(branchEntries, latestFirstKept);
+      if (latestFirstKeptIndex >= pendingFirstKeptIndex) {
+        return { kind: "already-current" };
+      }
     }
-    deps.appendCompaction(pending.summary, pending.firstKeptEntryId, pending.tokensBefore, {
+    const compactionId = deps.appendCompaction(pending.summary, pending.firstKeptEntryId, pending.tokensBefore, {
       source: "magic-context",
       lastCompactedOrdinal: pending.ordinal
     }, true);
-    sessionLog(sessionId, `Pi compaction-marker drain: applied firstKept=${pending.firstKeptEntryId} tokensBefore=${pending.tokensBefore}`);
+    if (typeof compactionId !== "string" || compactionId.length === 0) {
+      return {
+        kind: "retryable-failure",
+        error: new Error("Pi appendCompaction returned no compaction id")
+      };
+    }
+    sessionLog(sessionId, `Pi compaction-marker drain: applied compactionId=${compactionId} firstKept=${pending.firstKeptEntryId} endMessageId=${pending.endMessageId} ordinal=${pending.ordinal} tokensBefore=${pending.tokensBefore}`);
     return { kind: "applied", firstKeptEntryId: pending.firstKeptEntryId };
   } catch (err) {
     const error51 = err instanceof Error ? err : new Error(String(err));
@@ -167995,6 +168611,9 @@ function getEntryId(entry) {
   const id = entry.id;
   return typeof id === "string" ? id : null;
 }
+function findEntryIndex(branchEntries, entryId) {
+  return branchEntries.findIndex((entry) => getEntryId(entry) === entryId);
+}
 
 // src/detect-recent-commit.ts
 var COMMIT_LOOKBACK = 5;
@@ -168347,36 +168966,70 @@ function trimPiMessagesToBoundary(piMessages, entryIds, cutoffMessageId) {
   }
   if (cutoffIndex < 0)
     return 0;
-  const removedCallIds = new Set;
-  for (let i = 0;i <= cutoffIndex; i++) {
-    const msg = piMessages[i];
-    if (!msg || msg.role !== "assistant")
-      continue;
-    const assistantMsg = msg;
-    if (!Array.isArray(assistantMsg.content))
-      continue;
-    for (const part of assistantMsg.content) {
-      if (part && typeof part === "object" && part.type === "toolCall" && typeof part.id === "string") {
-        removedCallIds.add(part.id);
+  const remove = new Set;
+  for (let i = 0;i <= cutoffIndex; i++)
+    remove.add(i);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const removedCallIds = new Set;
+    const removedResultIds = new Set;
+    for (const index of remove) {
+      const msg = piMessages[index];
+      if (!msg)
+        continue;
+      if (msg.role === "assistant") {
+        for (const callId of getPiToolCallIds(msg))
+          removedCallIds.add(callId);
+      } else if (msg.role === "toolResult") {
+        const callId = getPiToolResultCallId(msg);
+        if (callId)
+          removedResultIds.add(callId);
       }
     }
-  }
-  if (removedCallIds.size > 0) {
-    let i = cutoffIndex + 1;
-    while (i < piMessages.length) {
+    for (let i = 0;i < piMessages.length; i++) {
+      if (remove.has(i))
+        continue;
       const msg = piMessages[i];
-      if (msg && msg.role === "toolResult" && typeof msg.toolCallId === "string" && removedCallIds.has(msg.toolCallId)) {
-        cutoffIndex = i;
-        i++;
-      } else {
-        break;
+      if (!msg)
+        continue;
+      if (msg.role === "toolResult") {
+        const callId = getPiToolResultCallId(msg);
+        if (callId && removedCallIds.has(callId)) {
+          remove.add(i);
+          changed = true;
+        }
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const callIds = getPiToolCallIds(msg);
+        if (callIds.some((callId) => removedResultIds.has(callId))) {
+          remove.add(i);
+          changed = true;
+        }
       }
     }
   }
-  const removed = cutoffIndex + 1;
-  piMessages.splice(0, removed);
+  const kept = piMessages.filter((_, index) => !remove.has(index));
+  const removed = piMessages.length - kept.length;
+  piMessages.splice(0, piMessages.length, ...kept);
   return removed;
 }
+function getPiToolCallIds(message) {
+  if (!Array.isArray(message.content))
+    return [];
+  const ids = [];
+  for (const part of message.content) {
+    if (part && typeof part === "object" && part.type === "toolCall" && typeof part.id === "string") {
+      ids.push(part.id);
+    }
+  }
+  return ids;
+}
+function getPiToolResultCallId(message) {
+  const callId = message.toolCallId;
+  return typeof callId === "string" && callId.length > 0 ? callId : null;
+}
 function injectHistoryBlockIntoFirstUserMessage(piMessages, historyBlock) {
   for (let i = 0;i < piMessages.length; i++) {
     const msg = piMessages[i];
@@ -168468,6 +169121,7 @@ ${prepared.block}
 // src/note-visibility-pi.ts
 var NOTE_TOOL_NAME = "ctx_note";
 var READ_ACTION = "read";
+var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
 function hasVisibleNoteReadCallPi(messages) {
   for (let i = messages.length - 1;i >= 0; i--) {
     const raw = messages[i];
@@ -168479,6 +169133,8 @@ function hasVisibleNoteReadCallPi(messages) {
     if (!Array.isArray(msg.content))
       continue;
     for (const part of msg.content) {
+      if (isSentinelPart(part))
+        continue;
       if (!part || typeof part !== "object")
         continue;
       const p = part;
@@ -168496,6 +169152,12 @@ function hasVisibleNoteReadCallPi(messages) {
   }
   return false;
 }
+function isSentinelPart(part) {
+  if (!part || typeof part !== "object")
+    return false;
+  const p = part;
+  return p.type === "text" && typeof p.text === "string" && (p.text === "" || p.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT);
+}
 
 // src/nudge-injector.ts
 var INSTRUCTION_NAME_PATTERN = /<instruction\s+name="([^"]+)">/;
@@ -168553,12 +169215,12 @@ function createAssistantNudgeMessage(text, messages) {
 function findLatestAssistantMessage(messages) {
   for (let i = messages.length - 1;i >= 0; i--) {
     const message = messages[i];
-    if (isAssistantMessage(message))
+    if (isAssistantMessage2(message))
       return message;
   }
   return;
 }
-function isAssistantMessage(message) {
+function isAssistantMessage2(message) {
   return getRole(message) === "assistant";
 }
 function createZeroUsage() {
@@ -169060,6 +169722,8 @@ async function runPiCompressionPassIfNeeded(deps) {
     sessionLog(sessionId, `compressor: history block ~${totalTokens} tokens within budget ${historyBudgetTokens}, skipping`);
     return false;
   }
+  const overage = totalTokens - historyBudgetTokens;
+  sessionLog(sessionId, `compressor: history block ~${totalTokens} tokens exceeds budget ${historyBudgetTokens} by ~${overage} tokens`);
   const lastEndMessage = compartments[compartments.length - 1]?.endMessage ?? 0;
   const floor = Math.max(1, Math.ceil(lastEndMessage / minCompartmentRatio));
   const floorHeadroom = compartments.length - floor;
@@ -169068,6 +169732,17 @@ async function runPiCompressionPassIfNeeded(deps) {
     return false;
   }
   const scored = scoreCompartments(db, sessionId, compartments);
+  const depthHistogram = new Map;
+  for (const scoredCompartment of scored) {
+    const bucket = Math.round(scoredCompartment.averageDepth);
+    depthHistogram.set(bucket, (depthHistogram.get(bucket) ?? 0) + 1);
+  }
+  const histText = [...depthHistogram.entries()].sort((a, b) => a[0] - b[0]).map(([depth, count]) => `d${depth}=${count}`).join(" ");
+  const histKey = `${scored.length}|${histText}`;
+  if (lastDepthHistogramBySession.get(sessionId) !== histKey) {
+    lastDepthHistogramBySession.set(sessionId, histKey);
+    sessionLog(sessionId, `compressor: depth histogram (${scored.length} total) ${histText}`);
+  }
   const band = selectPiCompressionBand(scored, {
     maxPickable: maxCompartmentsPerPass,
     maxMergeDepth,
@@ -169086,7 +169761,7 @@ async function runPiCompressionPassIfNeeded(deps) {
   const outputDepth = Math.min(5, Math.max(1, Math.round(avgDepth) + 1));
   const mergeRatio = COMPRESSOR_MERGE_RATIO_BY_DEPTH[outputDepth] ?? 2;
   const outputCount = mergeRatio > 0 ? Math.max(1, Math.ceil(band.length / mergeRatio)) : 1;
-  sessionLog(sessionId, `compressor: picked ${band.length} compartments (${selectedCompartments[0]?.startMessage}-${selectedCompartments[selectedCompartments.length - 1]?.endMessage}, ~${selectedTokens} tokens), avg_depth=${avgDepth.toFixed(1)} → output_depth=${outputDepth}`);
+  sessionLog(sessionId, `compressor: scored ${compartments.length}, picked ${band.length} contiguous (${selectedCompartments[0]?.startMessage}-${selectedCompartments[selectedCompartments.length - 1]?.endMessage}, ~${selectedTokens} tokens), avg_depth=${avgDepth.toFixed(1)} → output_depth=${outputDepth} (ratio=${mergeRatio}, target=${outputCount} compartments)`);
   if (outputDepth === 5) {
     const compressed = selectedCompartments.map((c) => ({
       startMessage: c.startMessage,
@@ -169106,7 +169781,8 @@ async function runPiCompressionPassIfNeeded(deps) {
       originalStart: selectedCompartments[0]?.startMessage ?? 0,
       originalEnd: selectedCompartments[selectedCompartments.length - 1]?.endMessage ?? 0,
       facts,
-      logLabel: `depth-5 title-only collapse (${selectedCompartments.length} → ${compressed.length})`
+      logLabel: `depth-5 title-only collapse (${selectedCompartments.length} → ${compressed.length})`,
+      holderId: deps.compartmentLeaseHolderId
     });
     if (ok2)
       onPublished?.();
@@ -169137,7 +169813,8 @@ async function runPiCompressionPassIfNeeded(deps) {
     originalStart: selectedCompartments[0]?.startMessage ?? 0,
     originalEnd: selectedCompartments[selectedCompartments.length - 1]?.endMessage ?? 0,
     facts,
-    logLabel: `depth-${outputDepth} (${selectedCompartments.length} → ${finalCompressed.length})`
+    logLabel: `depth-${outputDepth} (${selectedCompartments.length} → ${finalCompressed.length})`,
+    holderId: deps.compartmentLeaseHolderId
   });
   if (ok)
     onPublished?.();
@@ -169154,7 +169831,9 @@ async function runCompressorPass(args) {
       fallbackModels: args.fallbackModels,
       timeoutMs: args.historianTimeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
       cwd: args.directory,
-      thinkingLevel: args.thinkingLevel
+      thinkingLevel: args.thinkingLevel,
+      accountingSessionId: args.sessionId,
+      accountingSubagent: "compressor"
     });
     if (!result.ok) {
       sessionLog(args.sessionId, `compressor: subagent failed (${result.reason}): ${result.error}`);
@@ -169246,12 +169925,20 @@ function finalizeCompression(args) {
       sequence: leading.length + compressed.length + i
     }))
   ];
-  replaceAllCompartmentState(db, sessionId, allCompartments, args.facts);
-  incrementCompressionDepth(db, sessionId, originalStart, originalEnd);
+  const published = args.holderId ? replaceAllCompartmentStateAndBumpDepth(db, args.holderId, sessionId, allCompartments, args.facts, originalStart, originalEnd) : (() => {
+    replaceAllCompartmentState(db, sessionId, allCompartments, args.facts);
+    incrementCompressionDepth(db, sessionId, originalStart, originalEnd);
+    return true;
+  })();
+  if (!published) {
+    sessionLog(sessionId, "compressor: publish skipped because compartment lease is no longer held");
+    return false;
+  }
   sessionLog(sessionId, `compressor: completed ${args.logLabel}`);
   return true;
 }
 var lastCompressorRunBySession = new Map;
+var lastDepthHistogramBySession = new Map;
 function isPiCompressorOnCooldown(sessionId, cooldownMs) {
   const last = lastCompressorRunBySession.get(sessionId);
   return last !== undefined && Date.now() - last < cooldownMs;
@@ -169261,6 +169948,7 @@ function markPiCompressorRun(sessionId) {
 }
 function clearPiCompressorState(sessionId) {
   lastCompressorRunBySession.delete(sessionId);
+  lastDepthHistogramBySession.delete(sessionId);
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-drop-queue.ts
@@ -169491,27 +170179,27 @@ function getReducedRecompTokenBudget(currentBudget) {
 
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
 init_data_path();
-import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join14 } from "node:path";
+import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join15 } from "node:path";
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
 function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
     const dir = getProjectMagicContextHistorianDir(directory);
-    mkdirSync5(dir, { recursive: true });
-    const path5 = join14(dir, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync2(path5, existingState, "utf8");
-    return path5;
+    mkdirSync6(dir, { recursive: true });
+    const path6 = join15(dir, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync3(path6, existingState, "utf8");
+    return path6;
   } catch {
     return;
   }
 }
-function cleanupHistorianStateFile(path5) {
-  if (!path5)
+function cleanupHistorianStateFile(path6) {
+  if (!path6)
     return;
   try {
-    unlinkSync(path5);
+    unlinkSync(path6);
   } catch {}
 }
 
@@ -169628,7 +170316,7 @@ function convertEntriesToRawMessages(entries) {
       if (pendingToolParts.length > 0) {
         result.push({
           ordinal: nextOrdinal++,
-          id: pendingFirstRealId,
+          id: `synth-user-${pendingFirstRealId}`,
           role: "user",
           parts: pendingToolParts
         });
@@ -169653,7 +170341,7 @@ function convertEntriesToRawMessages(entries) {
   if (pendingToolParts.length > 0) {
     result.push({
       ordinal: nextOrdinal,
-      id: pendingFirstRealId,
+      id: `synth-user-${pendingFirstRealId}`,
       role: "user",
       parts: pendingToolParts
     });
@@ -169776,6 +170464,7 @@ async function runPiHistorian(deps) {
     memoryEnabled,
     autoPromote,
     onPublished,
+    compartmentLeaseHolderId,
     readBranchEntries,
     notifyIssue
   } = deps;
@@ -169802,23 +170491,27 @@ async function runPiHistorian(deps) {
       const existingValidationError = validateStoredCompartments(priorCompartments);
       if (existingValidationError) {
         sessionLog(sessionId, `historian failure: source=existing-validation reason="${existingValidationError}"`);
+        incrementHistorianFailure(db, sessionId, existingValidationError);
         await notify(`Historian skipped: existing stored compartments are invalid: ${existingValidationError}`);
         return;
       }
       const offset = priorCompartments.length > 0 ? priorCompartments[priorCompartments.length - 1].endMessage + 1 : 1;
       const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
       if (protectedTailStart <= offset) {
-        sessionLog(sessionId, `historian skip: protected tail covers all eligible history (offset=${offset}, protectedStart=${protectedTailStart})`);
+        sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} <= offset=${offset} — nothing to compact`);
+        clearEmergencyRecovery(db, sessionId);
         return;
       }
       const chunk = readSessionChunk(sessionId, historianChunkTokens, offset, protectedTailStart);
       if (!chunk.text || chunk.messageCount === 0) {
-        sessionLog(sessionId, `historian skip: empty chunk (offset=${offset}, protectedStart=${protectedTailStart})`);
+        sessionLog(sessionId, `historian no-op: chunk empty after filtering (messageCount=${chunk.messageCount}, textLen=${chunk.text?.length ?? 0}) range=${offset}-${protectedTailStart - 1}`);
+        clearEmergencyRecovery(db, sessionId);
         return;
       }
       const chunkCoverageError = validateChunkCoverage(chunk);
       if (chunkCoverageError) {
         sessionLog(sessionId, `historian failure: source=chunk-coverage reason="${chunkCoverageError}" chunkRange=${chunk.startIndex}-${chunk.endIndex}`);
+        incrementHistorianFailure(db, sessionId, chunkCoverageError);
         await notify(`Historian skipped: raw chunk could not be safely chunked: ${chunkCoverageError}`);
         return;
       }
@@ -169884,7 +170577,9 @@ ${chunk.text}`, { stateFilePath });
         timeoutMs: historianTimeoutMs,
         cwd: directory,
         thinkingLevel,
-        onProgress: buildProgressLogger("first")
+        onProgress: buildProgressLogger("first"),
+        accountingSessionId: sessionId,
+        accountingSubagent: "historian"
       });
       let validatedPass = await validateHistorianResult(firstResult, sessionId, chunk, priorCompartments, sequenceOffset);
       let validatedDraftText = firstResult.ok ? firstResult.assistantText : null;
@@ -169900,7 +170595,9 @@ ${chunk.text}`, { stateFilePath });
           timeoutMs: historianTimeoutMs,
           cwd: directory,
           thinkingLevel,
-          onProgress: buildProgressLogger("repair")
+          onProgress: buildProgressLogger("repair"),
+          accountingSessionId: sessionId,
+          accountingSubagent: "historian"
         });
         validatedPass = await validateHistorianResult(repairResult, sessionId, chunk, priorCompartments, sequenceOffset);
         if (validatedPass.kind === "ok" && repairResult.ok) {
@@ -169923,11 +170620,12 @@ ${chunk.text}`, { stateFilePath });
             systemPrompt: HISTORIAN_EDITOR_SYSTEM_PROMPT,
             userMessage: buildHistorianEditorPrompt(draftAssistantText),
             model: historianModel,
-            fallbackModels,
             timeoutMs: historianTimeoutMs,
             cwd: directory,
             thinkingLevel,
-            onProgress: buildProgressLogger("editor")
+            onProgress: buildProgressLogger("editor"),
+            accountingSessionId: sessionId,
+            accountingSubagent: "historian_editor"
           });
           const editorPass = await validateHistorianResult(editorResult, sessionId, chunk, priorCompartments, sequenceOffset);
           if (editorPass.kind === "ok") {
@@ -169961,10 +170659,30 @@ ${chunk.text}`, { stateFilePath });
           sessionLog(sessionId, `historian: native compaction queue lookup failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
         }
       }
-      db.transaction(() => {
+      if (!compartmentLeaseHolderId) {
+        sessionLog(sessionId, "historian publish skipped: missing compartment lease holder");
+        return;
+      }
+      let published = false;
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        if (!isCompartmentLeaseHeld(db, sessionId, compartmentLeaseHolderId)) {
+          db.exec("ROLLBACK");
+          sessionLog(sessionId, "historian publish skipped: compartment lease no longer held");
+          return;
+        }
         appendCompartments(db, sessionId, newCompartments);
         replaceSessionFacts(db, sessionId, validatedPass.facts ?? []);
         clearHistorianFailureState(db, sessionId);
+        clearEmergencyRecovery(db, sessionId);
+        if (validatedPass.userObservations?.length) {
+          insertUserMemoryCandidates(db, validatedPass.userObservations.map((obs) => ({
+            content: obs,
+            sessionId,
+            sourceCompartmentStart: newCompartments[0]?.startMessage,
+            sourceCompartmentEnd: lastNewEnd
+          })));
+        }
         if (firstKeptEntryId && lastNewEndMessageId) {
           setPendingPiCompactionMarkerState(db, sessionId, {
             firstKeptEntryId,
@@ -169975,13 +170693,24 @@ ${chunk.text}`, { stateFilePath });
             publishedAt: Date.now()
           });
         }
-      })();
+        db.exec("COMMIT");
+        published = true;
+      } finally {
+        if (!published) {
+          try {
+            db.exec("ROLLBACK");
+          } catch {}
+        }
+      }
       onNoteTrigger(db, sessionId, "historian_complete");
       onPublished?.();
       if (memoryEnabled !== false && autoPromote !== false) {
         promoteSessionFactsToMemory(db, sessionId, projectPath, validatedPass.facts ?? []);
       }
       queueDropsForCompartmentalizedMessages(db, sessionId, lastNewEnd);
+      if (validatedPass.userObservations?.length) {
+        sessionLog(sessionId, `stored ${validatedPass.userObservations.length} user memory candidate(s)`);
+      }
       sessionLog(sessionId, `historian: published ${newCompartments.length} compartment(s), ${validatedPass.facts?.length ?? 0} fact(s) covering messages ${chunk.startIndex}-${lastNewEnd}`);
       completedSuccessfully = true;
     });
@@ -170453,8 +171182,8 @@ function stripPiDroppedPlaceholderMessages(args) {
 
 // src/system-prompt.ts
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { join as join17 } from "node:path";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -170544,16 +171273,16 @@ Prefer many small targeted operations over one large blanket operation. Compress
 }
 
 // ../plugin/src/hooks/magic-context/key-files-block.ts
-import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
-import { join as join15, sep as sep2 } from "node:path";
+import { readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
+import { join as join16, sep as sep2 } from "node:path";
 init_logger();
 var cachedKeyFilesBySession = new Map;
 var staleUpdates = new Map;
 function staleKey(update) {
   return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
 }
-function queueStaleUpdate(projectPath, path5, generatedAtWitness, staleReason) {
-  const update = { projectPath, path: path5, generatedAtWitness, staleReason };
+function queueStaleUpdate(projectPath, path6, generatedAtWitness, staleReason) {
+  const update = { projectPath, path: path6, generatedAtWitness, staleReason };
   staleUpdates.set(staleKey(update), update);
 }
 function flushStaleUpdates(db) {
@@ -170598,13 +171327,13 @@ function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBud
     let nextStale = null;
     let observed = false;
     try {
-      const absPath = join15(projectPath, row.path);
+      const absPath = join16(projectPath, row.path);
       const real = realpathSync3(absPath);
       if (!isUnderProject(projectPath, real)) {
         nextStale = "missing";
         observed = true;
       } else {
-        const diskHash = sha256(readFileSync7(real));
+        const diskHash = sha256(readFileSync8(real));
         if (diskHash !== row.contentHash)
           nextStale = "content_drift";
         observed = true;
@@ -170681,10 +171410,10 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join16(directory, filename);
+    const filePath = join17(directory, filename);
     try {
-      if (existsSync11(filePath)) {
-        const content = readFileSync8(filePath, "utf-8").trim();
+      if (existsSync12(filePath)) {
+        const content = readFileSync9(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
 ${escapeXmlContent(content)}
@@ -171438,6 +172167,16 @@ var recentReduceBySession = new Map;
 var liveModelBySession = new Map;
 var toolUsageSinceUserTurn = new Map;
 var latestUserMessageBySession = new Map;
+var RECENT_REDUCE_TTL_MS = 5 * 60 * 1000;
+function hasRecentPiCtxReduceExecution(sessionId) {
+  const recordedAt = recentReduceBySession.get(sessionId);
+  if (recordedAt === undefined)
+    return false;
+  if (Date.now() - recordedAt <= RECENT_REDUCE_TTL_MS)
+    return true;
+  recentReduceBySession.delete(sessionId);
+  return false;
+}
 function logTransformTiming(sessionId, stage, start, extra) {
   const elapsed = (performance.now() - start).toFixed(1);
   const suffix = extra ? ` ${extra}` : "";
@@ -171527,7 +172266,7 @@ function recordPiToolExecution(sessionId) {
 function onPiNewUserMessage(args) {
   const sessionMeta = getOrCreateSessionMeta(args.db, args.sessionId);
   const turnUsage = toolUsageSinceUserTurn.get(args.sessionId);
-  const agentAlreadyReduced = recentReduceBySession.has(args.sessionId);
+  const agentAlreadyReduced = hasRecentPiCtxReduceExecution(args.sessionId);
   if (!sessionMeta.isSubagent && !agentAlreadyReduced && getPersistedStickyTurnReminder(args.db, args.sessionId) === null && turnUsage !== undefined && turnUsage >= TOOL_HEAVY_TURN_REMINDER_THRESHOLD) {
     setPersistedStickyTurnReminder(args.db, args.sessionId, TOOL_HEAVY_TURN_REMINDER_TEXT);
   }
@@ -171648,7 +172387,8 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEn
       continue;
     }
     const fingerprint = piMessageEntryFingerprint(msg);
-    const fingerprintId = fingerprint ? entryIdsByFingerprint.get(fingerprint)?.find((candidate) => !consumedFingerprintIds.has(candidate)) : undefined;
+    const fingerprintBucket = fingerprint ? entryIdsByFingerprint.get(fingerprint) : undefined;
+    const fingerprintId = fingerprintBucket?.length === 1 && !consumedFingerprintIds.has(fingerprintBucket[0]) ? fingerprintBucket[0] : undefined;
     if (typeof fingerprintId === "string") {
       consumedFingerprintIds.add(fingerprintId);
       result[i] = fingerprintId;
@@ -171784,8 +172524,10 @@ function registerPiContextHandler(pi, options) {
         });
         clearHistorianFailureState(options.db, sessionId);
         clearPersistedReasoningWatermark(options.db, sessionId);
-        clearDetectedContextLimit(options.db, sessionId);
-        clearEmergencyRecovery(options.db, sessionId);
+        if (modelChanged) {
+          clearDetectedContextLimit(options.db, sessionId);
+          clearEmergencyRecovery(options.db, sessionId);
+        }
         sessionMetaForUsage.lastContextPercentage = 0;
         sessionMetaForUsage.lastInputTokens = 0;
         sessionMetaForUsage.observedSafeInputTokens = 0;
@@ -171855,6 +172597,10 @@ function registerPiContextHandler(pi, options) {
         setDeferredExecutePendingIfAbsent(options.db, sessionId, flagPayload);
       }
       schedulerDecision = midTurnAdjustedSchedulerDecision;
+      const deferredExecutePending = peekDeferredExecutePending(options.db, sessionId);
+      if (deferredExecutePending !== null && schedulerDecision === "defer" && !midTurn) {
+        schedulerDecision = "execute";
+      }
       sessionLog(sessionId, `[boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
       const forceMaterialization = usagePercentage >= FORCE_MATERIALIZATION_PERCENTAGE;
       const isEmergency = usagePercentage >= EMERGENCY_BLOCK_PERCENTAGE;
@@ -171933,7 +172679,7 @@ function registerPiContextHandler(pi, options) {
           db: options.db,
           messages: outputMessages,
           entryIds: entryIds ?? null,
-          hasRecentReduceCall: recentReduceBySession.has(sessionId),
+          hasRecentReduceCall: hasRecentPiCtxReduceExecution(sessionId),
           isCacheBustingPass: cacheBustingPass
         });
       } catch (err) {
@@ -171960,8 +172706,7 @@ function registerPiContextHandler(pi, options) {
           db: options.db,
           messages: outputMessages,
           projectIdentity,
-          entryIds: strictEntryIds,
-          isCacheBusting
+          entryIds: strictEntryIds
         });
       } catch (err) {
         sessionLog(sessionId, `note nudges failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -172002,6 +172747,12 @@ function registerPiContextHandler(pi, options) {
       } catch (err) {
         sessionLog(sessionId, `synthetic todowrite injection failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      try {
+        const metrics = computePiWorkMetrics(outputMessages);
+        setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
+      } catch (err) {
+        sessionLog(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       logTransformTiming(sessionId, "postTransformPhase", tPostTransform);
       sessionLog(sessionId, `transform completed in ${(performance.now() - transformStartTime).toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       clearLastTransformErrorIfSet(options.db, sessionId);
@@ -172084,6 +172835,13 @@ function resolveHistoryBudgetTokensForPi(args) {
     contextLimit: derivedLimit
   }) / 100) * historyBudgetPercentage);
 }
+function startPiCompartmentLeaseRenewal(db, sessionId, holderId) {
+  return setInterval(() => {
+    if (!renewCompartmentLease(db, sessionId, holderId)) {
+      sessionLog(sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+    }
+  }, COMPARTMENT_LEASE_RENEWAL_MS);
+}
 function maybeFireCompressor(args) {
   const { ctx, sessionId, db, historian } = args;
   const compressor = historian.compressor;
@@ -172109,30 +172867,46 @@ function maybeFireCompressor(args) {
   });
   if (!historyBudgetTokens || historyBudgetTokens <= 0)
     return;
-  const runPromise = runPiCompressionPassIfNeeded({
-    db,
-    sessionId,
-    directory: ctx.cwd,
-    runner: historian.runner,
-    historianModel: historian.model,
-    fallbackModels: historian.fallbackModels,
-    historyBudgetTokens,
-    historianTimeoutMs: historian.timeoutMs,
-    thinkingLevel: historian.thinkingLevel,
-    minCompartmentRatio: compressor.minCompartmentRatio,
-    maxMergeDepth: compressor.maxMergeDepth,
-    maxCompartmentsPerPass: compressor.maxCompartmentsPerPass,
-    graceCompartments: compressor.graceCompartments,
-    onPublished: () => {
-      if (!isContextHandlerSessionActive(sessionId)) {
-        sessionLog(sessionId, "compressor publication ignored: session was cleared");
-        return;
-      }
-      signalPiDeferredHistoryRefresh(sessionId);
-      signalPiDeferredMaterialization(sessionId);
-      historian.onStatusChange?.(ctx, sessionId);
+  const holderId = crypto2.randomUUID();
+  const runPromise = (async () => {
+    const lease2 = acquireCompartmentLease(db, sessionId, holderId);
+    if (!lease2) {
+      sessionLog(sessionId, "compressor skipped: compartment lease held by another process");
+      return false;
+    }
+    const renewal = startPiCompartmentLeaseRenewal(db, sessionId, holderId);
+    try {
+      return await runPiCompressionPassIfNeeded({
+        db,
+        sessionId,
+        directory: ctx.cwd,
+        runner: historian.runner,
+        historianModel: historian.model,
+        fallbackModels: historian.fallbackModels,
+        historyBudgetTokens,
+        historianTimeoutMs: historian.timeoutMs,
+        thinkingLevel: historian.thinkingLevel,
+        minCompartmentRatio: compressor.minCompartmentRatio,
+        maxMergeDepth: compressor.maxMergeDepth,
+        maxCompartmentsPerPass: compressor.maxCompartmentsPerPass,
+        graceCompartments: compressor.graceCompartments,
+        compartmentLeaseHolderId: holderId,
+        onPublished: () => {
+          const sessionStillActive = isContextHandlerSessionActive(sessionId);
+          signalPiDeferredHistoryRefresh(sessionId);
+          signalPiDeferredMaterialization(sessionId);
+          if (sessionStillActive) {
+            historian.onStatusChange?.(ctx, sessionId);
+          } else {
+            sessionLog(sessionId, "compressor publication recorded after session clear; status callback skipped");
+          }
+        }
+      });
+    } finally {
+      clearInterval(renewal);
+      releaseCompartmentLease(db, sessionId, holderId);
     }
-  }).then((didPublish) => {
+  })().then((didPublish) => {
     if (didPublish === true) {
       markPiCompressorRun(sessionId);
     }
@@ -172170,37 +172944,53 @@ function sendPiIgnoredNotification(ctx, message) {
 }
 function spawnPiHistorianRun(args) {
   const { ctx, sessionId, db, historian, provider: provider2, unregister } = args;
-  const runPromise = runPiHistorian({
-    db,
-    sessionId,
-    directory: ctx.cwd,
-    provider: provider2,
-    appendCompaction: resolvePiAppendCompaction(ctx),
-    readBranchEntries: resolvePiReadBranchEntries(ctx),
-    runner: historian.runner,
-    historianModel: historian.model,
-    fallbackModels: historian.fallbackModels,
-    historianChunkTokens: historian.historianChunkTokens,
-    historianTimeoutMs: historian.timeoutMs,
-    twoPass: historian.twoPass,
-    thinkingLevel: historian.thinkingLevel,
-    memoryEnabled: historian.memoryEnabled,
-    autoPromote: historian.autoPromote,
-    onPublished: () => {
-      if (!isContextHandlerSessionActive(sessionId)) {
-        sessionLog(sessionId, "historian publication ignored: session was cleared");
-        return;
-      }
-      try {
-        clearEmergencyRecovery(db, sessionId);
-      } catch (err) {
-        sessionLog(sessionId, `historian: clearEmergencyRecovery failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      signalPiDeferredHistoryRefresh(sessionId);
-      signalPiDeferredMaterialization(sessionId);
-      historian.onStatusChange?.(ctx, sessionId);
+  const holderId = crypto2.randomUUID();
+  const runPromise = (async () => {
+    const lease2 = acquireCompartmentLease(db, sessionId, holderId);
+    if (!lease2) {
+      sessionLog(sessionId, "historian skipped: compartment lease held by another process");
+      return;
     }
-  }).finally(() => {
+    const renewal = startPiCompartmentLeaseRenewal(db, sessionId, holderId);
+    try {
+      await runPiHistorian({
+        db,
+        sessionId,
+        directory: ctx.cwd,
+        provider: provider2,
+        appendCompaction: resolvePiAppendCompaction(ctx),
+        readBranchEntries: resolvePiReadBranchEntries(ctx),
+        runner: historian.runner,
+        historianModel: historian.model,
+        fallbackModels: historian.fallbackModels,
+        historianChunkTokens: historian.historianChunkTokens,
+        historianTimeoutMs: historian.timeoutMs,
+        twoPass: historian.twoPass,
+        thinkingLevel: historian.thinkingLevel,
+        memoryEnabled: historian.memoryEnabled,
+        autoPromote: historian.autoPromote,
+        compartmentLeaseHolderId: holderId,
+        onPublished: () => {
+          const sessionStillActive = isContextHandlerSessionActive(sessionId);
+          try {
+            clearEmergencyRecovery(db, sessionId);
+          } catch (err) {
+            sessionLog(sessionId, `historian: clearEmergencyRecovery failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          signalPiDeferredHistoryRefresh(sessionId);
+          signalPiDeferredMaterialization(sessionId);
+          if (sessionStillActive) {
+            historian.onStatusChange?.(ctx, sessionId);
+          } else {
+            sessionLog(sessionId, "historian publication recorded after session clear; status callback skipped");
+          }
+        }
+      });
+    } finally {
+      clearInterval(renewal);
+      releaseCompartmentLease(db, sessionId, holderId);
+    }
+  })().finally(() => {
     inFlightHistorian.delete(sessionId);
     unregister();
     if (isContextHandlerSessionActive(sessionId)) {
@@ -172221,12 +173011,11 @@ function resolvePiReadBranchEntries(ctx) {
   if (typeof sm?.getBranch !== "function")
     return;
   return () => {
-    try {
-      const entries = sm.getBranch?.call(sm);
-      return Array.isArray(entries) ? entries : [];
-    } catch {
-      return [];
+    const entries = sm.getBranch?.call(sm);
+    if (!Array.isArray(entries)) {
+      throw new Error("Pi sessionManager.getBranch() did not return an array");
     }
+    return entries;
   };
 }
 function maybeFireHistorian(args) {
@@ -172328,6 +173117,7 @@ Historian previously failed ${failureState.failureCount} time(s), so magic-conte
 async function runPipeline(args) {
   let executedWorkThisPass = false;
   let historyWasConsumedThisPass = false;
+  let materializationSatisfiedThisPass = false;
   let suppressDeferredHistoryDrain = false;
   let casLost = false;
   const deferredHistoryWasPendingAtPassStart = deferredHistoryRefreshSessions.has(args.sessionId);
@@ -172349,7 +173139,7 @@ async function runPipeline(args) {
     return findLatestUserMessageIdPi(args.messages, ids)?.messageId ?? null;
   })();
   const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
-  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
+  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || hasPendingMaterialization(args.sessionId) || deferredMaterializationSessions.has(args.sessionId) || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const tTag = performance.now();
   const { targets } = tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
     skipPrefixInjection: !args.ctxReduceEnabled
@@ -172372,22 +173162,26 @@ async function runPipeline(args) {
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
+  const deferredExecuteWasPending = peekDeferredExecutePending(args.db, args.sessionId) !== null;
   const pendingOps = getPendingOps(args.db, args.sessionId);
-  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal;
+  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || deferredExecuteWasPending;
   const canConsumeDeferredLate = baseShouldApplyPendingOps || shouldRunHeuristics;
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
   const shouldApplyPendingOps = baseShouldApplyPendingOps || deferredMaterialize;
   if (shouldApplyPendingOps) {
-    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
+    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredExecuteWasPending ? "deferred_boundary_execute" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
     try {
       const tApplyPending = performance.now();
       applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, undefined, pendingOps);
       logTransformTiming(args.sessionId, "applyPendingOperations", tApplyPending);
       executedWorkThisPass = true;
+      materializationSatisfiedThisPass = true;
       if (hasPendingMaterializeSignal) {
-        consumePendingMaterialization(args.sessionId);
+        if (args.heuristics === undefined) {
+          consumePendingMaterialization(args.sessionId);
+        }
       }
       if (deferredMaterialize) {
         consumeDeferredMaterialization(args.sessionId);
@@ -172467,6 +173261,9 @@ async function runPipeline(args) {
       }, activeTags);
       heuristicsExecuted = true;
       executedWorkThisPass = true;
+      if (hasPendingMaterializeSignal) {
+        consumePendingMaterialization(args.sessionId);
+      }
       if (currentTurnId !== null) {
         lastHeuristicsTurnIdBySession.set(args.sessionId, currentTurnId);
       }
@@ -172501,7 +173298,9 @@ async function runPipeline(args) {
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", tClearReasoning);
       logTransformTiming(args.sessionId, "watermarkCleanup", tClearReasoning);
-      executedWorkThisPass = true;
+      if (combinedWatermark > prevWatermark || clearOutcome.cleared > 0 || stripOutcome.stripped > 0) {
+        executedWorkThisPass = true;
+      }
     } catch (err) {
       sessionLog(args.sessionId, `reasoning clearing failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -172531,7 +173330,7 @@ async function runPipeline(args) {
     messages: args.messages,
     isCacheBusting: args.isCacheBusting
   });
-  const deferredHistoryDrainEligible = historyWasConsumedThisPass && deferredHistoryWasPendingAtPassStart && !suppressDeferredHistoryDrain && !casLost;
+  const deferredHistoryDrainEligible = historyWasConsumedThisPass && materializationSatisfiedThisPass && (deferredHistoryWasPendingAtPassStart || hasPendingMaterializeSignal) && !suppressDeferredHistoryDrain && !casLost;
   if (deferredHistoryDrainEligible) {
     try {
       const pending = getPendingPiCompactionMarkerState(args.db, args.sessionId);
@@ -172621,7 +173420,7 @@ function applyStickyTurnReminder(args) {
   const messageIdByIndex = buildPiMessageIdByIndex(args.messages, args.entryIds);
   if (reminder.messageId) {
     const reinjected = appendReminderToUserMessageByIdPi(args.messages, messageIdByIndex, reminder.messageId, reminder.text);
-    if (!reinjected && args.isCacheBustingPass && args.entryIds !== null) {
+    if (!reinjected && args.isCacheBustingPass && args.entryIds !== null && !args.entryIds.includes(undefined) && !args.entryIds.includes(reminder.messageId)) {
       clearPersistedStickyTurnReminder(args.db, args.sessionId);
     }
     return args.messages;
@@ -172638,14 +173437,15 @@ function applyStickyTurnReminder(args) {
   return args.messages;
 }
 function applyNoteNudges(args) {
-  const { sessionId, db, messages, projectIdentity, entryIds, isCacheBusting } = args;
+  const { sessionId, db, messages, projectIdentity, entryIds } = args;
   const messageIdByIndex = buildPiMessageIdByIndex(messages, entryIds);
+  const replayMessageIdByIndex = buildPiMessageIdByIndex(messages, entryIds, true);
   for (const anchor of getNoteNudgeAnchors(db, sessionId)) {
-    appendReminderToUserMessageByIdPi(messages, messageIdByIndex, anchor.messageId, anchor.text);
+    appendReminderToUserMessageByIdPi(messages, replayMessageIdByIndex, anchor.messageId, anchor.text);
   }
   for (const decision of getAutoSearchHintDecisions(db, sessionId)) {
     if (decision.decision === "hint") {
-      appendReminderToUserMessageByIdPi(messages, messageIdByIndex, decision.messageId, decision.text);
+      appendReminderToUserMessageByIdPi(messages, replayMessageIdByIndex, decision.messageId, decision.text);
     }
   }
   const latestUser = findLatestUserMessageIdPi(messages, messageIdByIndex);
@@ -172661,14 +173461,18 @@ function applyNoteNudges(args) {
 
 <instruction name="deferred_notes">${deferredNoteText}</instruction>`;
     const anchoredId = latestUser?.messageId ?? null;
+    if (!anchoredId) {
+      sessionLog(sessionId, "Pi note-nudge: latest user message has no resolved SessionEntry id; deferring delivery to next pass");
+      return messages;
+    }
     const outcome = markNoteNudgeDelivered(db, sessionId, noteInstruction, anchoredId);
-    if (latestUser && anchoredId && outcome.ok) {
+    if (latestUser && outcome.ok) {
       appendReminderToPiUserMessage(messages[latestUser.index], noteInstruction);
-    } else if (anchoredId && !outcome.ok) {
+    } else if (!outcome.ok) {
       sessionLog(sessionId, `Pi note-nudge delivery skipped wire append: ${outcome.kind}`);
     }
   }
-  if (isCacheBusting && entryIds !== null) {
+  if (entryIds !== null && !entryIds.includes(undefined)) {
     const visibleIds = new Set(entryIds.filter((id) => typeof id === "string"));
     pruneNoteNudgeAnchors(db, sessionId, visibleIds);
     pruneAutoSearchHintDecisions(db, sessionId, visibleIds);
@@ -172700,7 +173504,7 @@ function hasMeaningfulUserTextPi(message) {
   }
   return false;
 }
-function buildPiMessageIdByIndex(messages, entryIds) {
+function buildPiMessageIdByIndex(messages, entryIds, includeMessageIdFallback = false) {
   const ids = new Map;
   for (let index = 0;index < messages.length; index += 1) {
     const entryId = entryIds?.[index];
@@ -172708,9 +173512,11 @@ function buildPiMessageIdByIndex(messages, entryIds) {
       ids.set(index, entryId);
       continue;
     }
-    const messageId = messages[index]?.id;
-    if (typeof messageId === "string") {
-      ids.set(index, messageId);
+    if (includeMessageIdFallback) {
+      const messageId = messages[index]?.id;
+      if (typeof messageId === "string") {
+        ids.set(index, messageId);
+      }
     }
   }
   return ids;
@@ -172841,7 +173647,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -172862,7 +173668,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join17(getDataDir(), "opencode", "opencode.db");
+  return join18(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -173031,7 +173837,7 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
 // ../plugin/src/hooks/magic-context/compartment-runner-compressor.ts
 init_logger();
 var HISTORIAN_AGENT2 = "historian";
-var lastDepthHistogramBySession = new Map;
+var lastDepthHistogramBySession2 = new Map;
 function cavemanLevelForDepth2(outputDepth) {
   if (outputDepth <= 1)
     return null;
@@ -173045,6 +173851,10 @@ function cavemanLevelForDepth2(outputDepth) {
 }
 async function runCompressionPassIfNeeded(deps) {
   const { db, sessionId, historyBudgetTokens } = deps;
+  if (deps.historianRunnable === false) {
+    sessionLog(sessionId, "compressor: skipped because historian.disable=true");
+    return false;
+  }
   const minCompartmentRatio = deps.minCompartmentRatio ?? DEFAULT_COMPRESSOR_MIN_COMPARTMENT_RATIO;
   const maxMergeDepth = deps.maxMergeDepth ?? DEFAULT_COMPRESSOR_MAX_MERGE_DEPTH;
   const compartments = getCompartments(db, sessionId);
@@ -173084,8 +173894,8 @@ ${c.content}
   }
   const histText = [...depthHistogram.entries()].sort((a, b) => a[0] - b[0]).map(([d, n]) => `d${d}=${n}`).join(" ");
   const histKey = `${scored.length}|${histText}`;
-  if (lastDepthHistogramBySession.get(sessionId) !== histKey) {
-    lastDepthHistogramBySession.set(sessionId, histKey);
+  if (lastDepthHistogramBySession2.get(sessionId) !== histKey) {
+    lastDepthHistogramBySession2.set(sessionId, histKey);
     sessionLog(sessionId, `compressor: depth histogram (${scored.length} total) ${histText}`);
   }
   const floorHeadroom = compartments.length - floor;
@@ -173131,7 +173941,8 @@ ${c.content}
       originalStart: selectedCompartments[0].startMessage,
       originalEnd: selectedCompartments[selectedCompartments.length - 1].endMessage,
       facts,
-      logLabel: `depth-5 title-only collapse (${selectedCompartments.length} → ${selectedCompartments.length})`
+      logLabel: `depth-5 title-only collapse (${selectedCompartments.length} → ${selectedCompartments.length})`,
+      holderId: deps.compartmentLeaseHolderId
     });
   }
   try {
@@ -173161,7 +173972,8 @@ ${c.content}
       originalStart: selectedCompartments[0].startMessage,
       originalEnd: selectedCompartments[selectedCompartments.length - 1].endMessage,
       facts,
-      logLabel: `depth-${outputDepth} (${selectedCompartments.length} → ${finalCompressed.length})`
+      logLabel: `depth-${outputDepth} (${selectedCompartments.length} → ${finalCompressed.length})`,
+      holderId: deps.compartmentLeaseHolderId
     });
   } catch (error51) {
     sessionLog(sessionId, "compressor: unexpected error:", getErrorMessage(error51));
@@ -173286,7 +174098,8 @@ function finalizeCompression2(args) {
     originalStart,
     originalEnd,
     facts,
-    logLabel
+    logLabel,
+    holderId
   } = args;
   const compressedStart = compressed[0].startMessage;
   const compressedEnd = compressed[compressed.length - 1].endMessage;
@@ -173337,8 +174150,16 @@ function finalizeCompression2(args) {
       content: c.content
     }))
   ];
-  replaceAllCompartmentState(db, sessionId, allCompartments, facts.map((f) => ({ category: f.category, content: f.content })));
-  incrementCompressionDepth(db, sessionId, originalStart, originalEnd);
+  const factInputs = facts.map((f) => ({ category: f.category, content: f.content }));
+  const published = holderId ? replaceAllCompartmentStateAndBumpDepth(db, holderId, sessionId, allCompartments, factInputs, originalStart, originalEnd) : (() => {
+    replaceAllCompartmentState(db, sessionId, allCompartments, factInputs);
+    incrementCompressionDepth(db, sessionId, originalStart, originalEnd);
+    return true;
+  })();
+  if (!published) {
+    sessionLog(sessionId, "compressor: publish skipped because compartment lease is no longer held");
+    return false;
+  }
   sessionLog(sessionId, `compressor: completed ${logLabel}`);
   return true;
 }
@@ -173357,6 +174178,27 @@ async function runCompressorPass2(args) {
   } = args;
   const prompt = buildCompressorPrompt(compartments, currentTokens, targetTokens, outputDepth, outputCount);
   let agentSessionId = null;
+  const startedAt = Date.now();
+  let invocationRecorded = false;
+  const recordInvocation = (params) => {
+    if (invocationRecorded)
+      return;
+    invocationRecorded = true;
+    try {
+      recordChildInvocation({
+        db: openDatabase(),
+        parentSessionId: sessionId,
+        harness: "opencode",
+        subagent: "compressor",
+        startedAt,
+        status: params.status,
+        messages: params.messages,
+        error: params.error
+      });
+    } catch (error51) {
+      sessionLog(sessionId, "subagent token accounting unavailable", getErrorMessage(error51));
+    }
+  };
   try {
     const createResponse = await client.session.create({
       body: { parentID: sessionId, title: "magic-context-compressor" },
@@ -173366,6 +174208,7 @@ async function runCompressorPass2(args) {
     agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
     if (!agentSessionId) {
       sessionLog(sessionId, "compressor: could not create child session");
+      recordInvocation({ status: "failed", error: "could not create child session" });
       return null;
     }
     await promptSyncWithModelSuggestionRetry(client, {
@@ -173387,6 +174230,7 @@ async function runCompressorPass2(args) {
     const messages = normalizeSDKResponse(messagesResponse, [], {
       preferResponseOnMissingData: true
     });
+    recordInvocation({ status: "completed", messages });
     const result = extractLatestAssistantText(messages);
     if (!result) {
       sessionLog(sessionId, "compressor: historian returned no output");
@@ -173407,6 +174251,7 @@ async function runCompressorPass2(args) {
     }
     return snapped.result;
   } catch (error51) {
+    recordInvocation({ status: "failed", error: error51 });
     sessionLog(sessionId, "compressor: historian call failed:", getErrorMessage(error51));
     return null;
   } finally {
@@ -173419,8 +174264,8 @@ async function runCompressorPass2(args) {
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join19 } from "node:path";
 init_data_path();
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
@@ -173445,7 +174290,8 @@ async function runValidatedHistorianPass(args) {
       ...args,
       draftXml: firstRun.result,
       draftValidation: firstValidation,
-      draftDumpPath: firstRun.dumpPath
+      draftDumpPath: firstRun.dumpPath,
+      draftInvocationId: firstRun.invocationId ?? null
     }) : firstValidation;
     cleanupHistorianDump(args.parentSessionId, firstRun.dumpPath);
     return finalResult;
@@ -173471,7 +174317,8 @@ async function runValidatedHistorianPass(args) {
       ...args,
       draftXml: repairRun.result,
       draftValidation: repairValidation,
-      draftDumpPath: repairRun.dumpPath
+      draftDumpPath: repairRun.dumpPath,
+      draftInvocationId: repairRun.invocationId ?? null
     }) : repairValidation;
     cleanupHistorianDump(args.parentSessionId, repairRun.dumpPath);
     return finalResult;
@@ -173492,7 +174339,8 @@ async function runEditorPassOrFallback(args) {
     prompt: buildHistorianEditorPrompt(args.draftXml),
     timeoutMs: args.timeoutMs,
     dumpLabel: `${args.dumpLabelBase}-editor`,
-    agentId: HISTORIAN_EDITOR_AGENT
+    agentId: HISTORIAN_EDITOR_AGENT,
+    parentInvocationId: args.draftInvocationId ?? null
   });
   if (!editorRun.ok || !editorRun.result) {
     sessionLog(args.parentSessionId, "historian two-pass: editor call failed", {
@@ -173519,9 +174367,29 @@ async function runHistorianPrompt(args) {
     dumpLabel,
     modelOverride,
     agentId = HISTORIAN_AGENT,
-    fallbackModels
+    fallbackModels,
+    subagentKind,
+    parentInvocationId
   } = args;
   let agentSessionId = null;
+  const startedAt = Date.now();
+  let invocationRecorded = false;
+  const recordInvocation = (params) => {
+    if (invocationRecorded)
+      return null;
+    invocationRecorded = true;
+    return recordChildInvocation({
+      db: openDatabase(),
+      parentSessionId,
+      harness: "opencode",
+      subagent: agentId === HISTORIAN_EDITOR_AGENT ? "historian_editor" : subagentKind ?? "historian",
+      startedAt,
+      status: params.status,
+      messages: params.messages,
+      error: params.error,
+      parentInvocationId: agentId === HISTORIAN_EDITOR_AGENT ? parentInvocationId ?? null : null
+    });
+  };
   try {
     sessionLog(parentSessionId, `historian: creating child session (agent=${agentId}, model=${modelOverride ? `${modelOverride.providerID}/${modelOverride.modelID}` : `agent:${agentId}`})`);
     const createResponse = await client.session.create({
@@ -173534,6 +174402,10 @@ async function runHistorianPrompt(args) {
     const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
     if (!agentSessionId) {
+      recordInvocation({
+        status: "failed",
+        error: "Historian could not create its child session."
+      });
       return { ok: false, error: "Historian could not create its child session." };
     }
     for (let retryIndex = 0;retryIndex <= MAX_HISTORIAN_RETRIES; retryIndex += 1) {
@@ -173572,15 +174444,21 @@ async function runHistorianPrompt(args) {
     const messages = normalizeSDKResponse(messagesResponse, [], {
       preferResponseOnMissingData: true
     });
+    const invocationId = recordInvocation({ status: "completed", messages });
     const result = extractLatestAssistantText(messages);
     if (!result) {
-      return { ok: false, error: "Historian returned no assistant output." };
+      return {
+        ok: false,
+        error: "Historian returned no assistant output.",
+        invocationId: invocationId ?? undefined
+      };
     }
     const dumpPath = dumpHistorianResponse(parentSessionId, sessionDirectory, dumpLabel ?? "historian-response", result);
-    return { ok: true, result, dumpPath };
+    return { ok: true, result, dumpPath, invocationId: invocationId ?? undefined };
   } catch (modelError) {
     const desc = describeError(modelError);
     sessionLog(parentSessionId, `historian prompt failed: ${desc.brief} promptLength=${prompt.length}${desc.stackHead ? ` stackHead="${desc.stackHead}"` : ""}`);
+    recordInvocation({ status: "failed", error: modelError });
     return {
       ok: false,
       error: `Historian failed while processing this session: ${desc.brief}`
@@ -173671,11 +174549,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 function dumpHistorianResponse(sessionId, directory, label, text) {
   try {
     const dumpDir = historianResponseDumpDir(directory);
-    mkdirSync6(dumpDir, { recursive: true });
+    mkdirSync7(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join18(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync3(dumpPath, text, "utf8");
+    const dumpPath = join19(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync4(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -173856,6 +174734,12 @@ async function executePartialRecompInternal(deps, range) {
     getNotificationParams
   } = deps;
   const notifParams = () => getNotificationParams?.() ?? {};
+  const holderId = deps.compartmentLeaseHolderId;
+  if (!holderId) {
+    return `## Magic Recomp — Failed
+
+Could not acquire the compartment-state lease for this session.`;
+  }
   updateSessionMeta(db, sessionId, { compartmentInProgress: true });
   try {
     let promoteFinal = function() {
@@ -173892,7 +174776,7 @@ async function executePartialRecompInternal(deps, range) {
         return null;
       }
       saveRecompStagingPass(db, sessionId, passCount + 1, merged, currentFacts);
-      const promoted = promoteRecompStaging(db, sessionId);
+      const promoted = promoteRecompStaging(db, sessionId, holderId);
       if (!promoted) {
         log("[magic-context] partial recomp promote returned null");
         return null;
@@ -174100,6 +174984,7 @@ Staging preserved for resume on next attempt.`;
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-recomp.ts
+init_logger();
 async function executeContextRecompInternal(deps) {
   const {
     client,
@@ -174111,6 +174996,12 @@ async function executeContextRecompInternal(deps) {
     getNotificationParams
   } = deps;
   const notifParams = () => getNotificationParams?.() ?? {};
+  const holderId = deps.compartmentLeaseHolderId;
+  if (!holderId) {
+    return `## Magic Recomp — Skipped
+
+Could not acquire the compartment-state lease for this session.`;
+  }
   let currentStateFilePath;
   updateSessionMeta(db, sessionId, { compartmentInProgress: true });
   try {
@@ -174147,7 +175038,7 @@ Found ${existingStaging.compartments.length} staged compartment(s) from ${existi
       if (mergedError)
         return null;
       saveRecompStagingPass(db, sessionId, passCount, candidateCompartments, candidateFacts);
-      const promoted2 = promoteRecompStaging(db, sessionId);
+      const promoted2 = promoteRecompStaging(db, sessionId, holderId);
       if (!promoted2)
         return null;
       clearCompressionDepth(db, sessionId);
@@ -174228,6 +175119,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         fallbackModelId: deps.fallbackModelId,
         fallbackModels: deps.fallbackModels,
         twoPass: deps.historianTwoPass,
+        subagentKind: "recomp",
         callbacks: {
           onRepairRetry: async (error51) => {
             await sendIgnoredMessage(client, sessionId, `## Magic Recomp
@@ -174298,10 +175190,12 @@ Recomp completed ${passCount} pass${passCount === 1 ? "" : "es"} but produced an
 Nothing was written.`;
     }
     saveRecompStagingPass(db, sessionId, passCount, candidateCompartments, candidateFacts);
-    const promoted = promoteRecompStaging(db, sessionId);
+    const promoted = promoteRecompStaging(db, sessionId, holderId);
     if (!promoted) {
-      replaceAllCompartmentState(db, sessionId, candidateCompartments, candidateFacts);
-      clearRecompStaging(db, sessionId);
+      sessionLog(sessionId, "recomp publish skipped: compartment lease no longer held");
+      return `## Magic Recomp — Skipped
+
+Another process acquired the compartment-state lease before recomp could publish. No state was written.`;
     }
     clearCompressionDepth(db, sessionId);
     if (deps.preserveInjectionCacheUntilConsumed !== true) {
@@ -174370,12 +175264,32 @@ function withPublishedCallback(deps) {
     }
   };
 }
-async function executeContextRecomp(deps, options = {}) {
+function startLeaseRenewal(deps, holderId) {
+  return setInterval(() => {
+    if (!renewCompartmentLease(deps.db, deps.sessionId, holderId)) {
+      sessionLog(deps.sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+    }
+  }, COMPARTMENT_LEASE_RENEWAL_MS);
+}
+async function executeContextRecompWithResult(deps, options = {}) {
   const { sessionId } = deps;
   if (activeRuns.has(sessionId)) {
-    return "## Magic Recomp\n\nHistorian is already running for this session. Wait for it to finish, then try `/ctx-recomp` again.";
+    return {
+      message: "## Magic Recomp\n\nHistorian is already running for this session. Wait for it to finish, then try `/ctx-recomp` again.",
+      published: false
+    };
+  }
+  const holderId = crypto.randomUUID();
+  const lease2 = acquireCompartmentLease(deps.db, sessionId, holderId);
+  if (!lease2) {
+    sessionLog(sessionId, "recomp skipped: compartment lease held by another process");
+    return {
+      message: "## Magic Recomp\n\nAnother process is already mutating compartment state for this session. Wait for it to finish, then try `/ctx-recomp` again.",
+      published: false
+    };
   }
-  const runnerDeps = withPublishedCallback(deps);
+  const renewal = startLeaseRenewal(deps, holderId);
+  const runnerDeps = withPublishedCallback({ ...deps, compartmentLeaseHolderId: holderId });
   const promise2 = options.range ? executePartialRecompInternal(runnerDeps, options.range) : executeContextRecompInternal(runnerDeps);
   const wrappedPromise = promise2.then(() => {
     return;
@@ -174384,8 +175298,14 @@ async function executeContextRecomp(deps, options = {}) {
   });
   activeRuns.set(sessionId, { promise: wrappedPromise, published: false });
   try {
-    return await promise2;
+    const message = await promise2;
+    return {
+      message,
+      published: activeRuns.get(sessionId)?.published === true
+    };
   } finally {
+    clearInterval(renewal);
+    releaseCompartmentLease(deps.db, sessionId, holderId);
     if (activeRuns.get(sessionId)?.promise === wrappedPromise) {
       activeRuns.delete(sessionId);
     }
@@ -174558,7 +175478,7 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
         projectIdentity: ctx.cwd
       });
       try {
-        const result = await executeContextRecomp({
+        const result = await executeContextRecompWithResult({
           client: createPiRecompClient({
             runner: deps.runner,
             model: deps.historianModel,
@@ -174566,6 +175486,7 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
             timeoutMs: deps.historianTimeoutMs,
             thinkingLevel: deps.historianThinkingLevel,
             directory: ctx.cwd,
+            accountingSessionId: sessionId,
             notify: (text) => {
               sendCtxStatusMessage(pi, {
                 title: "/ctx-recomp",
@@ -174584,9 +175505,12 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
         }, parsed.kind === "partial" ? { range: parsed.range } : {});
         sendCtxStatusMessage(pi, {
           title: "/ctx-recomp",
-          text: result,
-          level: inferLevel(result)
+          text: result.message,
+          level: inferLevel(result.message)
         });
+        if (!result.published) {
+          return;
+        }
         queueAndApplyPiRecompMarker({ db: deps.db, sessionId, ctx });
         signalPiHistoryRefresh(sessionId);
         signalPiPendingMaterialization(sessionId);
@@ -174749,7 +175673,9 @@ function createPiRecompClient(args) {
       fallbackModels: args.fallbackModels,
       timeoutMs: args.timeoutMs,
       cwd: args.directory,
-      thinkingLevel: args.thinkingLevel
+      thinkingLevel: args.thinkingLevel,
+      accountingSessionId: args.accountingSessionId,
+      accountingSubagent: "recomp"
     });
     if (!result.ok) {
       throw new Error(`Pi recomp historian failed (${result.reason}): ${result.error}`);
@@ -174780,8 +175706,8 @@ function createPiRecompClient(args) {
 function readPathId(input) {
   if (typeof input !== "object" || input === null)
     return "";
-  const path5 = input.path;
-  return typeof path5?.id === "string" ? path5.id : "";
+  const path6 = input.path;
+  return typeof path6?.id === "string" ? path6.id : "";
 }
 function readBody(input) {
   if (typeof input !== "object" || input === null)
@@ -174932,10 +175858,20 @@ import {
   truncateToWidth,
   visibleWidth
 } from "@earendil-works/pi-tui";
+
+// ../plugin/src/shared/format-threshold.ts
+function formatThresholdPercent(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return "—";
+  const rounded = Math.round(value);
+  if (Math.abs(value - rounded) < 0.05)
+    return String(rounded);
+  return value.toFixed(1);
+}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.21.6",
+  version: "0.21.8",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -175099,7 +176035,7 @@ function renderInner(s, theme, innerWidth) {
   lines.push(theme.fg("muted", "Tags"));
   lines.push(`Active ${s.activeTags} (~${formatBytes(s.activeBytes)}) · Dropped ${s.droppedTags} · Total ${s.totalTags}`);
   lines.push(theme.fg("muted", "Rolling Nudges / Context"));
-  lines.push(`Execute threshold ${s.executeThreshold}% · Anchor ${fmt2(s.lastNudgeTokens)} tok · Interval ${fmt2(s.nudgeInterval)} tok · Next ${fmt2(s.nextNudgeAfter)} tok`);
+  lines.push(`Execute threshold ${formatThresholdPercent(s.executeThreshold)}% · Anchor ${fmt2(s.lastNudgeTokens)} tok · Interval ${fmt2(s.nudgeInterval)} tok · Next ${fmt2(s.nextNudgeAfter)} tok`);
   lines.push(`Protected tags ${s.protectedTagCount} · Subagent ${s.isSubagent ? "yes" : "no"} · History block ~${fmt2(s.historyBlockTokens)} tok${s.compressionBudget ? ` · Budget ~${fmt2(s.compressionBudget)} tok (${s.compressionUsage} used)` : ""}`);
   if (s.lastTransformError)
     lines.push(theme.fg("error", `⚠ ${s.lastTransformError}`));
@@ -175447,7 +176383,7 @@ function buildStatusDetails(deps, sessionId) {
       status: ["pending", "ready"]
     }).length,
     dreamer: {
-      enabled: deps.dreamer?.enabled === true,
+      enabled: deps.dreamer?.runnable === true,
       schedule: deps.dreamer?.schedule ?? null,
       lastRunAt: readNumberState(deps.db, `last_dream_at:${deps.projectIdentity}`)
     },
@@ -180661,7 +181597,7 @@ var PLUGIN_VERSION = (() => {
 setHarness("pi");
 function resolveSidekickFromConfig(config2) {
   const sidekick = config2.sidekick;
-  if (!sidekick?.enabled)
+  if (!sidekick || sidekick.disable === true)
     return;
   const model = sidekick.model?.trim();
   if (!model || model.length === 0)
@@ -180670,18 +181606,20 @@ function resolveSidekickFromConfig(config2) {
     model,
     systemPrompt: sidekick.system_prompt,
     timeoutMs: sidekick.timeout_ms,
-    thinking_level: sidekick.thinking_level
+    thinking_level: sidekick.thinking_level,
+    fallbackModels: resolveFallbackChain("sidekick", sidekick.fallback_models)
   };
 }
 function resolveHistorianFromConfig(config2) {
   const historian = config2.historian;
+  if (historian?.disable === true)
+    return;
   const model = historian?.model?.trim();
   if (!model || model.length === 0)
     return;
   const historianContextLimit = resolveHistorianContextLimit(model);
   const historianChunkTokens = deriveHistorianChunkTokens(historianContextLimit);
-  const fbRaw = historian?.fallback_models;
-  const fallbackModels = typeof fbRaw === "string" ? [fbRaw] : fbRaw;
+  const fallbackModels = resolveFallbackChain("historian", historian?.fallback_models);
   return {
     runner: new PiSubagentRunner,
     model,
@@ -180730,11 +181668,11 @@ function resolveAutoSearchFromConfig(config2) {
   };
 }
 function resolveDreamerFromConfig(config2) {
-  return config2.dreamer;
+  return config2.dreamer?.disable === true ? undefined : config2.dreamer;
 }
 async function src_default2(pi) {
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join19(storageDir, "context.db");
+  const dbPath = join20(storageDir, "context.db");
   let db;
   try {
     db = openDatabase();
@@ -180750,6 +181688,7 @@ async function src_default2(pi) {
     const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
     for (const sid of pendingPiMarkerSessions) {
       signalPiDeferredHistoryRefresh(sid);
+      signalPiPendingMaterialization(sid);
     }
     if (pendingPiMarkerSessions.length > 0) {
       log(`${PREFIX2} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
@@ -180781,7 +181720,7 @@ async function src_default2(pi) {
     allowDreamerActions: false,
     ctxReduceEnabled: config2.ctx_reduce_enabled === true,
     protectedTags: config2.protected_tags ?? 20,
-    dreamerEnabled: config2.dreamer?.enabled === true
+    dreamerEnabled: isDreamerRunnable(config2)
   });
   info(`registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand${config2.ctx_reduce_enabled === true ? ", ctx_reduce" : ""}`);
   const historianConfig = resolveHistorianFromConfig(config2);
@@ -180825,7 +181764,7 @@ async function src_default2(pi) {
   info(autoSearchConfig.enabled ? `registered auto-search hint (threshold=${autoSearchConfig.scoreThreshold}, minChars=${autoSearchConfig.minPromptChars})` : "registered auto-search hint: DISABLED (experimental.auto_search.enabled=false)");
   const sidekickConfig = resolveSidekickFromConfig(config2);
   registerCtxAugCommand(pi, sidekickConfig);
-  info(sidekickConfig ? `registered /ctx-aug (sidekick model=${sidekickConfig.model})` : "registered /ctx-aug (sidekick disabled — set sidekick.enabled=true and sidekick.model in config)");
+  info(sidekickConfig ? `registered /ctx-aug (sidekick model=${sidekickConfig.model})` : "registered /ctx-aug (sidekick disabled — set sidekick.disable=false and sidekick.model in config)");
   registerCtxStatusCommand(pi, {
     db,
     projectIdentity,
@@ -180837,7 +181776,7 @@ async function src_default2(pi) {
     commitClusterTrigger: config2.commit_cluster_trigger,
     executeThresholdTokens: config2.execute_threshold_tokens,
     dreamer: {
-      enabled: config2.dreamer?.enabled ?? false,
+      runnable: isDreamerRunnable(config2),
       schedule: config2.dreamer?.schedule
     }
   });
@@ -180863,7 +181802,7 @@ async function src_default2(pi) {
     projectDir,
     projectIdentity,
     resolveProject: resolveCurrentProject,
-    dreamerEnabled: config2.dreamer?.enabled ?? false,
+    dreamerEnabled: isDreamerRunnable(config2),
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
   });
   info("registered /ctx-dream");
@@ -180879,11 +181818,28 @@ async function src_default2(pi) {
       gitCommitIndexing: config2.experimental.git_commit_indexing,
       onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
     });
-    info(dreamerConfig.enabled ? `registered dreamer (schedule=${dreamerConfig.schedule}, tasks=[${dreamerConfig.tasks.join(",")}])` : "registered dreamer: DISABLED (dreamer.enabled=false)");
+    info(`registered dreamer (schedule=${dreamerConfig.schedule || "manual-only"}, tasks=[${dreamerConfig.tasks.join(",")}])`);
   } else {
-    info("registered dreamer: DISABLED (no dreamer config)");
+    info(isDreamerRunnable(config2) ? "registered dreamer: DISABLED (no dreamer config)" : "registered dreamer: DISABLED (dreamer.disable=true or no dreamer config)");
   }
   pi.on("before_agent_start", async (event, ctx) => {
+    try {
+      if (ctx.hasUI && shouldShowAnnouncement()) {
+        const featureText = ANNOUNCEMENT_FEATURES.map((line) => `  • ${line}`).join(`
+`);
+        const sections = [
+          `✨ Magic Context v${ANNOUNCEMENT_VERSION} — what's new:`,
+          "",
+          featureText
+        ];
+        if (ANNOUNCEMENT_FOOTER && ANNOUNCEMENT_FOOTER.trim().length > 0) {
+          sections.push("", ANNOUNCEMENT_FOOTER);
+        }
+        ctx.ui.notify(sections.join(`
+`), "info");
+        markAnnouncementSeen(ANNOUNCEMENT_VERSION);
+      }
+    } catch {}
     try {
       const currentProject = resolveCurrentProject(ctx);
       seenDreamerProjectIdentities.add(currentProject.projectIdentity);
@@ -180915,16 +181871,16 @@ async function src_default2(pi) {
         cwd: currentProject.projectDir,
         sessionId,
         memoryEnabled: config2.memory.enabled,
-        injectDocs: config2.dreamer?.inject_docs ?? true,
+        injectDocs: isDreamerRunnable(config2) && (config2.dreamer?.inject_docs ?? true),
         includeGuidance: true,
         protectedTags: config2.protected_tags,
         ctxReduceEnabled: config2.ctx_reduce_enabled,
-        dreamerEnabled: config2.dreamer?.enabled ?? false,
+        dreamerEnabled: isDreamerRunnable(config2),
         dropToolStructure: config2.drop_tool_structure,
         temporalAwarenessEnabled: config2.experimental?.temporal_awareness ?? false,
         cavemanTextCompressionEnabled: config2.ctx_reduce_enabled === false && config2.experimental?.caveman_text_compression?.enabled === true,
-        userMemoriesEnabled: (config2.dreamer?.enabled ?? false) && (config2.dreamer?.user_memories?.enabled ?? false),
-        pinKeyFilesEnabled: (config2.dreamer?.enabled ?? false) && (config2.dreamer?.pin_key_files?.enabled ?? false),
+        userMemoriesEnabled: config2.dreamer?.user_memories?.enabled ?? false,
+        pinKeyFilesEnabled: config2.dreamer?.pin_key_files?.enabled ?? false,
         pinKeyFilesTokenBudget: config2.dreamer?.pin_key_files?.token_budget ?? 1e4,
         isCacheBusting,
         existingSystemPrompt: event.systemPrompt
@@ -181063,7 +182019,7 @@ ${block}` : event.systemPrompt;
                 continue;
               if (typeof b.name !== "string")
                 continue;
-              if (!/^todo.*write$|^write.*todo$|^todowrite$/i.test(b.name)) {
+              if (b.name !== "todowrite") {
                 continue;
               }
               const args = b.arguments;
@@ -181149,6 +182105,9 @@ ${block}` : event.systemPrompt;
   });
 }
 export {
+  resolveSidekickFromConfig,
+  resolveHistorianFromConfig,
+  resolveDreamerFromConfig,
   persistPiPressureFromMessageEnd,
   persistPiMessageEndModelMeta,
   src_default2 as default