@cortexkit/pi-magic-context 0.34.1 → 0.35.0

package/dist/index.js

@@ -40,6 +40,8 @@ import {
   buildCompartmentSummaryFallbackText,
   buildPrimaryLanguageDirective,
   buildSyntheticTodoPart,
+  buildToolArcs,
+  buildTrueRawTokenIndex,
   bumpEpochsForWorkspaceMembers,
   bumpProjectUserProfileVersion,
   byteSize,
@@ -67,8 +69,10 @@ import {
   clearPersistedTodoSyntheticAnchor,
   clearRecompStaging,
   closeQuietly,
+  completedToolArcCrossesBoundary,
   computeCueContentHash,
   computeNormalizedHash,
+  computeRawRangeFingerprint,
   computeWorkspaceEpochFingerprint,
   contentSha256,
   convertEntriesToRawMessages,
@@ -76,6 +80,8 @@ import {
   cosineSimilarity,
   countPrimerCandidatesForProject,
   createPrimer,
+  createPromptSurfaceGuidanceEpochCache,
+  createPromptSurfaceRuntime,
   decodeCachedM0UpgradeIdentity,
   deleteMemory,
   deleteUserMemoryCandidates,
@@ -98,10 +104,12 @@ import {
   escapeXmlAttr,
   escapeXmlContent,
   estimateTokens,
+  estimateTrueRawMessageTokens,
   expandWorkspaceIdentitySetWithAliases,
   extractM0Block,
   extractTexts,
   extractToolCallSummaries,
+  fenceBoundaryForToolArcs,
   findAdoptableFallbackTags,
   findLastModelKeyFromBranch,
   findPiFallbackToolOwnerTags,
@@ -213,6 +221,7 @@ import {
   insertUserMemory,
   insertUserMemoryCandidates,
   invalidateMemory,
+  invalidateTrueRawTokenCache,
   isCompactionEnabled,
   isCompartmentLeaseHeld,
   isDreamerRunnable,
@@ -253,6 +262,7 @@ import {
   primerOccurrenceKey,
   primerOccurrenceUtcDay,
   promoteSessionFactsDurable,
+  promptSurfaceHashMaterial,
   pruneAutoSearchHintDecisions,
   pruneExpiredUserMemoryCandidates,
   pruneNoteNudgeAnchors,
@@ -270,6 +280,7 @@ import {
   recordHistorianDrainFailure,
   recordMemoryMapping,
   recordMemoryVerifications,
+  recordMuralCueRejection,
   recordOverflowDetected,
   recordProtectedTailNoEligibleHead,
   recordProtectedTailPublicationFloor,
@@ -297,6 +308,7 @@ import {
   resolveCompactionModeRecord,
   resolveGitTopLevel,
   resolveLimit,
+  resolveModelConfigOrDefault,
   resolveModelRefForPi,
   resolveMuralWire,
   resolvePiStableId,
@@ -330,7 +342,6 @@ import {
   setStoragePrivatePermissionEnforcement,
   setTodoSnapshot,
   sourceNameForMemory,
-  stableStringify,
   stripMemoryMuralBlock,
   stripPersistedAssistantText,
   stripTagPrefix,
@@ -362,7 +373,7 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-ekzg3w5y.js";
+} from "./index-xbk9epe8.js";
 import {
   pushNotification
 } from "./index-hw34xmzk.js";
@@ -583,6 +594,15 @@ function formatFailClosedBlockingProcesses(processes) {
 }
 function formatFailClosedBlockingMessage(reason) {
   if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      const arm = reason.unreadableArm ?? "io";
+      const recovery = arm === "io" ? `If no OpenCode server is running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop OpenCode before deleting it.`;
+      return [
+        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live OpenCode server cannot be proven.`,
+        recovery,
+        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+      ].join(" ");
+    }
     return [
       `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
       "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
@@ -1478,16 +1498,7 @@ function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
     return cacheTtl;
   }
-  if (modelKey && typeof cacheTtl[modelKey] === "string") {
-    return cacheTtl[modelKey];
-  }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
-      return cacheTtl[bareModelId];
-    }
-  }
-  return cacheTtl.default ?? "5m";
+  return resolveModelConfigOrDefault(cacheTtl, modelKey, cacheTtl.default ?? "5m");
 }
 var clampWarnSeen = new Set;
 function isFinitePositive(v) {
@@ -3286,6 +3297,70 @@ function backoffMs(failureCount) {
   return minutes * 60 * 1000;
 }
 
+// ../plugin/src/features/magic-context/dreamer/storage-task-schedule.ts
+function toRow(r) {
+  return {
+    projectPath: r.project_path,
+    task: r.task,
+    lastRunAt: r.last_run_at,
+    nextDueAt: r.next_due_at,
+    schedule: r.schedule ?? null,
+    lastStatus: r.last_status ?? null,
+    lastError: r.last_error,
+    retryCount: r.retry_count ?? 0,
+    lastCheckedCommit: r.last_checked_commit ?? null,
+    lastBroadRunAt: r.last_broad_run_at ?? null,
+    retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
+  };
+}
+var SELECT_COLUMNS = "project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms";
+function getTaskScheduleState(db, projectPath, task) {
+  const row = db.prepare(`SELECT ${SELECT_COLUMNS} FROM task_schedule_state WHERE project_path = ? AND task = ?`).get(projectPath, task);
+  return row ? toRow(row) : null;
+}
+function getMostRecentTaskRunAt(db, projectPath) {
+  const row = db.prepare("SELECT MAX(last_run_at) AS max_at FROM task_schedule_state WHERE project_path = ?").get(projectPath);
+  const value = row?.max_at ?? null;
+  return typeof value === "number" && value > 0 ? value : null;
+}
+function pruneNonCanonicalTaskRows(db, projectPath, canonicalTasks) {
+  if (canonicalTasks.length === 0)
+    return 0;
+  const placeholders = canonicalTasks.map(() => "?").join(", ");
+  const result = db.prepare(`DELETE FROM task_schedule_state WHERE project_path = ? AND task NOT IN (${placeholders})`).run(projectPath, ...canonicalTasks);
+  return Number(result.changes ?? 0);
+}
+function deleteTaskScheduleRowsForProject(db, projectPath) {
+  const result = db.prepare("DELETE FROM task_schedule_state WHERE project_path = ?").run(projectPath);
+  return Number(result.changes ?? 0);
+}
+function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, schedule) {
+  db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
+}
+function writeTaskScheduleState(db, row) {
+  const broadCycleUpdate = row.lastBroadRunAt === undefined ? "last_broad_run_at = task_schedule_state.last_broad_run_at" : "last_broad_run_at = excluded.last_broad_run_at";
+  db.prepare(`INSERT INTO task_schedule_state
+           (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(project_path, task) DO UPDATE SET
+           last_run_at          = excluded.last_run_at,
+           next_due_at          = excluded.next_due_at,
+           schedule             = excluded.schedule,
+           last_status          = excluded.last_status,
+           last_error           = excluded.last_error,
+           retry_count          = excluded.retry_count,
+           last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
+           ${broadCycleUpdate},
+           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
+}
+function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
+  const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
+  return row != null;
+}
+function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
+  db.prepare("INSERT INTO retrospective_processed_windows (project_path, window_key, processed_at) VALUES (?, ?, ?) ON CONFLICT(project_path, window_key) DO NOTHING").run(projectPath, windowKey, Date.now());
+}
+
 // ../plugin/src/features/magic-context/dreamer/task-gates.ts
 function countActiveMemories(db, projectPath) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
@@ -3331,6 +3406,19 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND v.verified_at = 0`).get(projectPath);
   return row?.cnt ?? 0;
 }
+function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories m
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND (
+                    SELECT MAX(v.verified_at)
+                      FROM memory_verifications v
+                     WHERE v.memory_id = m.id
+                       AND v.file_path <> ''
+                ) < ?`).get(projectPath, cycleStartAt);
+  return row?.cnt ?? 0;
+}
 function countCueCandidates(db, projectPath) {
   if (!hasMuralCueColumns(db))
     return countActiveMemories(db, projectPath);
@@ -3386,7 +3474,9 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     }
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
-      return { pending: total, total };
+      const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
+      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      return { pending, total };
     }
     case "curate": {
       const total = countActiveMemories(db, projectPath);
@@ -3445,7 +3535,7 @@ function evaluateTaskGate(task, ctx) {
     case "verify":
       return countActiveMemories(db, project) > 0;
     case "verify-broad":
-      return countActiveMemories(db, project) > 0;
+      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countActiveMemories(db, project) > 0;
     case "curate":
       return countActiveMemories(db, project) > 0;
     case "compress-cues":
@@ -3490,7 +3580,7 @@ function openOpenCodeDb() {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
 
 // ../plugin/src/agents/dreamer.ts
@@ -4075,6 +4165,9 @@ function parseFields(json) {
   return {};
 }
 
+// ../plugin/src/features/magic-context/mural/compress-cues.ts
+import { createHash as createHash2 } from "node:crypto";
+
 // ../plugin/src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -4299,6 +4392,64 @@ function assertManifestCoversExactly(ids, expectedIds, rootName) {
   }
 }
 
+// ../plugin/src/features/magic-context/dreamer/module-apply.ts
+class DreamerModuleFailureError extends Error {
+  transient = true;
+  constructor(operation, cause) {
+    super(`Rust dreamer ${operation} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "DreamerModuleFailureError";
+    this.cause = cause;
+  }
+}
+async function resolveDreamerModuleRoute(args) {
+  const transport = args.transformMode === "ts" ? undefined : args.moduleClient;
+  if (!transport?.authorityStatus)
+    return;
+  const contextStoreUuid = getContextStoreUuid(args.db);
+  if (!contextStoreUuid)
+    throw new Error("Rust dreamer requires a context store identity");
+  const result = await transport.authorityStatus({
+    context_store_uuid: contextStoreUuid,
+    project: args.projectIdentity,
+    projectRoot: args.projectRoot,
+    domain: "memories"
+  });
+  if (result.authority?.state !== "MODULE")
+    return;
+  const generation = result.authority.generation;
+  if (typeof generation !== "number")
+    throw new Error("Rust authority status omitted generation");
+  return {
+    moduleClient: transport,
+    moduleSessionId: args.projectIdentity,
+    moduleProjectRoot: args.projectRoot,
+    moduleContextStoreUuid: contextStoreUuid,
+    moduleAuthorityGeneration: generation,
+    moduleCommandId: args.commandId
+  };
+}
+function getModuleMemoryIdentities(db, projectIdentity, contextIds) {
+  if (contextIds.length === 0)
+    return new Map;
+  const placeholders = contextIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT identity.context_row_id, identity.module_row_id, live.normalized_hash
+               FROM mirror_identity identity
+               LEFT JOIN mirror_live_memory_rows live
+                 ON live.module_project = identity.module_project
+                AND live.module_row_id = identity.module_row_id
+              WHERE identity.domain = 'memories' AND identity.module_project = ?
+                AND identity.context_row_id IN (${placeholders})`).all(projectIdentity, ...contextIds);
+  return new Map(rows.flatMap((row) => Number.isInteger(row.context_row_id) && Number.isInteger(row.module_row_id) && typeof row.normalized_hash === "string" ? [
+    [
+      row.context_row_id,
+      {
+        moduleId: row.module_row_id,
+        normalizedHash: row.normalized_hash
+      }
+    ]
+  ] : []));
+}
+
 // ../plugin/src/features/magic-context/mural/compress-cues-prompt.ts
 var CUE_BUDGET_HIGH = 90;
 var CUE_BUDGET_LOW = 50;
@@ -4370,7 +4521,7 @@ function hasBalancedParentheses(cue) {
   }
   return depth === 0;
 }
-function validateCue(cue, importance) {
+function validateCue(cue, importance, ownId) {
   const trimmed = cue.trim();
   if (trimmed.length === 0)
     return { reason: "empty" };
@@ -4378,8 +4529,9 @@ function validateCue(cue, importance) {
   const length = [...trimmed].length;
   if (length > budget)
     return { reason: `over-budget ${length}>${budget}` };
-  if (/#\d+/.test(trimmed))
+  if (ownId !== undefined && new RegExp(`#${ownId}\\b`).test(trimmed)) {
     return { reason: "leaked-id" };
+  }
   if (!hasBalancedParentheses(trimmed))
     return { reason: "unbalanced-parens" };
   const markers = trimmed.split("⊘").length - 1;
@@ -4395,6 +4547,7 @@ function validateCue(cue, importance) {
 // ../plugin/src/features/magic-context/mural/compress-cues.ts
 var COMPRESS_CUES_CHUNK_SIZE = 40;
 var CHUNK_TIMEOUT_FLOOR_MS = 240000;
+var CUE_REJECTION_LATCH_THRESHOLD = 3;
 var CONSECUTIVE_TIMEOUT_LIMIT = 2;
 function toPromptMemory(candidate) {
   const memory = candidate.memory;
@@ -4405,6 +4558,38 @@ function toPromptMemory(candidate) {
     content: memory.content
   };
 }
+function stripOwnIdToken(value, ownId) {
+  return value.replace(new RegExp(`#${ownId}\\b`, "g"), "");
+}
+function truncateCue(value, budget) {
+  const trimmed = value.trim();
+  const codepoints = [...trimmed];
+  if (codepoints.length <= budget)
+    return trimmed;
+  const prefix = codepoints.slice(0, budget).join("");
+  const boundary = prefix.search(/\s+\S*$/);
+  return (boundary > 0 ? prefix.slice(0, boundary) : prefix).trim();
+}
+function sanitizeCue(value, candidate) {
+  return truncateCue(stripOwnIdToken(value, candidate.memory.id), cueBudgetFor(candidate.memory.importance ?? 50));
+}
+function deterministicFallbackCue(candidate, lastCandidate) {
+  const importance = candidate.memory.importance ?? 50;
+  const budget = cueBudgetFor(importance);
+  const sanitizedCandidate = sanitizeCue(lastCandidate, candidate);
+  if (validateCue(sanitizedCandidate, importance, candidate.memory.id) === null) {
+    return sanitizedCandidate;
+  }
+  const sourceSlice = sanitizeCue(candidate.memory.content, candidate);
+  if (validateCue(sourceSlice, importance, candidate.memory.id) === null) {
+    return sourceSlice;
+  }
+  const grammarSafe = truncateCue(sourceSlice.replaceAll("⊘", "").replace(/[()]/g, "").replace(/\b(?:must not|never|without|instead of|exclude|excludes)\b/gi, "").replace(/\s+/g, " "), budget);
+  if (validateCue(grammarSafe, importance, candidate.memory.id) === null) {
+    return grammarSafe;
+  }
+  return "memory";
+}
 function selectCandidates(db, projectIdentity) {
   const memories = getMemoriesByProject(db, projectIdentity, ["active", "permanent"]);
   const cueState = getMuralCueState(db, memories.map((memory) => memory.id));
@@ -4536,7 +4721,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         return text;
       }
     });
-    return applyCues(args, chunk, run.validated);
+    return args.moduleRoute ? await applyCuesThroughModule(args, chunk, run.validated, signal) : applyCues(args, chunk, run.validated);
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] compress-cues chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
@@ -4573,10 +4758,19 @@ function applyCues(args, chunk, manifestText) {
       const candidate = byId.get(entry.id);
       if (!candidate)
         throw new Error(`cues manifest contains unknown id ${entry.id}`);
-      const failure = validateCue(entry.cue, candidate.memory.importance ?? 50);
+      const importance = candidate.memory.importance ?? 50;
+      const failure = validateCue(entry.cue, importance, candidate.memory.id);
       if (failure) {
+        const rejectionCount = recordMuralCueRejection(args.db, args.projectIdentity, entry.id, candidate.contentHash);
+        if (rejectionCount >= CUE_REJECTION_LATCH_THRESHOLD) {
+          const fallback = deterministicFallbackCue(candidate, entry.cue);
+          setMuralCue(args.db, args.projectIdentity, entry.id, fallback, candidate.contentHash);
+          compressed += 1;
+          log(`[dreamer] compress-cues: fallback cue for memory ${entry.id} (${failure.reason}; ${rejectionCount} rejections; fallback)`);
+          continue;
+        }
         skipped += 1;
-        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason})`);
+        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
         continue;
       }
       setMuralCue(args.db, args.projectIdentity, entry.id, entry.cue.trim(), candidate.contentHash);
@@ -4585,6 +4779,111 @@ function applyCues(args, chunk, manifestText) {
   });
   return { compressed, skipped };
 }
+async function applyCuesThroughModule(args, chunk, manifestText, signal) {
+  const route = args.moduleRoute;
+  if (!route)
+    throw new Error("module cue apply called without a module route");
+  const byId = new Map(chunk.map((candidate) => [candidate.memory.id, candidate]));
+  const parsed = parseCuesManifest(manifestText);
+  assertManifestCoversExactly(parsed.map((entry) => entry.id), new Set(byId.keys()), "cues");
+  const state2 = getMuralCueState(args.db, chunk.map((candidate) => candidate.memory.id));
+  const identities = getModuleMemoryIdentities(args.db, args.projectIdentity, chunk.map((candidate) => candidate.memory.id));
+  const updates = [];
+  for (const entry of parsed) {
+    const candidate = byId.get(entry.id);
+    if (!candidate)
+      throw new Error(`cues manifest contains unknown id ${entry.id}`);
+    const identity = identities.get(candidate.memory.id);
+    if (!identity) {
+      throw new Error(`module mirror identity missing for memory ${candidate.memory.id}`);
+    }
+    const failure = validateCue(entry.cue, candidate.memory.importance ?? 50, candidate.memory.id);
+    if (!failure) {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: entry.cue.trim(),
+        rejectionCount: 0,
+        kind: "compressed"
+      });
+      continue;
+    }
+    const previous = state2.get(candidate.memory.id);
+    const rejectionCount = previous?.hash === candidate.contentHash ? (previous.rejectionCount ?? 0) + 1 : 1;
+    if (rejectionCount >= CUE_REJECTION_LATCH_THRESHOLD) {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: deterministicFallbackCue(candidate, entry.cue),
+        rejectionCount: 0,
+        kind: "compressed"
+      });
+      log(`[dreamer] compress-cues: fallback cue for memory ${entry.id} (${failure.reason}; ${rejectionCount} rejections; fallback)`);
+    } else {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: null,
+        rejectionCount,
+        kind: "skipped"
+      });
+      log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
+    }
+  }
+  const commandId = `mural-cues:${route.moduleCommandId}:${createHash2("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
+  let response;
+  try {
+    response = await route.moduleClient.call({
+      sessionId: route.moduleSessionId,
+      projectRoot: route.moduleProjectRoot,
+      method: "memory.set_mural_cue",
+      body: {
+        name: "memory.set_mural_cue",
+        arguments: {
+          memory_project: args.projectIdentity,
+          context_store_uuid: route.moduleContextStoreUuid,
+          authority_generation: route.moduleAuthorityGeneration,
+          command_id: commandId,
+          rows: updates.map((update) => ({
+            memory_id: update.moduleId,
+            content_hash_at_prompt: update.contentHash,
+            cue: update.cue,
+            rejection_count: update.rejectionCount
+          }))
+        }
+      },
+      signal
+    });
+  } catch (error) {
+    throw new DreamerModuleFailureError("mural cue apply", error);
+  }
+  const result = response?.result ?? response;
+  if (!result || typeof result !== "object") {
+    throw new Error("module returned invalid mural cue apply result");
+  }
+  const accepted = result.accepted;
+  if (!Array.isArray(accepted) || !accepted.every((id) => Number.isInteger(id))) {
+    throw new Error("module returned no mural cue acceptance list");
+  }
+  const acceptedIds = new Set(accepted);
+  const rejected = result.rejected;
+  const rejectedReasons = new Map;
+  for (const row of Array.isArray(rejected) ? rejected : []) {
+    const reason = row && typeof row === "object" && typeof row.reason === "string" ? row.reason : "unknown";
+    rejectedReasons.set(reason, (rejectedReasons.get(reason) ?? 0) + 1);
+  }
+  if ([...rejectedReasons].some(([reason]) => reason !== "stale")) {
+    throw new Error(`module rejected mural cues (${[...rejectedReasons].map(([reason, count]) => `${reason}=${count}`).join(", ")})`);
+  }
+  return updates.reduce((counts, update) => {
+    if (acceptedIds.has(update.moduleId))
+      counts[update.kind] += 1;
+    return counts;
+  }, { compressed: 0, skipped: 0 });
+}
 
 // ../plugin/src/features/magic-context/dreamer/task-prompts.ts
 var PROJECT_MEMORY_TAXONOMY = `## Memory taxonomy (5 categories)
@@ -5099,7 +5398,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
 }
 
 // ../plugin/src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // ../plugin/src/plugin/rust-tool-backends.ts
 function isRustAuthorityDrainingError(error) {
@@ -5367,64 +5666,6 @@ function parseClassifyManifest(text) {
   return out;
 }
 
-// ../plugin/src/features/magic-context/dreamer/module-apply.ts
-class DreamerModuleFailureError extends Error {
-  transient = true;
-  constructor(operation, cause) {
-    super(`Rust dreamer ${operation} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-    this.name = "DreamerModuleFailureError";
-    this.cause = cause;
-  }
-}
-async function resolveDreamerModuleRoute(args) {
-  const transport = args.transformMode === "ts" ? undefined : args.moduleClient;
-  if (!transport?.authorityStatus)
-    return;
-  const contextStoreUuid = getContextStoreUuid(args.db);
-  if (!contextStoreUuid)
-    throw new Error("Rust dreamer requires a context store identity");
-  const result = await transport.authorityStatus({
-    context_store_uuid: contextStoreUuid,
-    project: args.projectIdentity,
-    projectRoot: args.projectRoot,
-    domain: "memories"
-  });
-  if (result.authority?.state !== "MODULE")
-    return;
-  const generation = result.authority.generation;
-  if (typeof generation !== "number")
-    throw new Error("Rust authority status omitted generation");
-  return {
-    moduleClient: transport,
-    moduleSessionId: args.projectIdentity,
-    moduleProjectRoot: args.projectRoot,
-    moduleContextStoreUuid: contextStoreUuid,
-    moduleAuthorityGeneration: generation,
-    moduleCommandId: args.commandId
-  };
-}
-function getModuleMemoryIdentities(db, projectIdentity, contextIds) {
-  if (contextIds.length === 0)
-    return new Map;
-  const placeholders = contextIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT identity.context_row_id, identity.module_row_id, live.normalized_hash
-               FROM mirror_identity identity
-               LEFT JOIN mirror_live_memory_rows live
-                 ON live.module_project = identity.module_project
-                AND live.module_row_id = identity.module_row_id
-              WHERE identity.domain = 'memories' AND identity.module_project = ?
-                AND identity.context_row_id IN (${placeholders})`).all(projectIdentity, ...contextIds);
-  return new Map(rows.flatMap((row) => Number.isInteger(row.context_row_id) && Number.isInteger(row.module_row_id) && typeof row.normalized_hash === "string" ? [
-    [
-      row.context_row_id,
-      {
-        moduleId: row.module_row_id,
-        normalizedHash: row.normalized_hash
-      }
-    ]
-  ] : []));
-}
-
 // ../plugin/src/features/magic-context/dreamer/classify.ts
 var MIN_POOL_TO_CLASSIFY = 10;
 var FULL_POOL_CEILING = 100;
@@ -5661,7 +5902,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       v: 1,
       session_id: args.moduleSessionId,
       task: "classify",
-      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash2("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
+      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash3("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
       authority_generation: args.moduleAuthorityGeneration,
       payload: {
         prompt_body: prompt,
@@ -6299,7 +6540,7 @@ function throwIfAborted2(signal) {
 }
 
 // ../plugin/src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/smart-notes/compiler-prompt.ts
 var SMART_NOTE_COMPILER_SYSTEM_PROMPT = `You are the Magic Context smart-note compiler for the magic-context system.
@@ -6723,7 +6964,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash3("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash4("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
 }
 function extractJsonObject(output) {
   const fenced = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -7403,7 +7644,7 @@ function enforceMaintainDocsProtectedRegions(args) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/dreamer/map-memories-prompt.ts
 import { existsSync as existsSync6, statSync } from "node:fs";
@@ -7664,7 +7905,7 @@ async function applyBatchMappings(args, batch, manifestText) {
             memory_project: args.projectIdentity,
             context_store_uuid: args.moduleRoute.moduleContextStoreUuid,
             authority_generation: args.moduleRoute.moduleAuthorityGeneration,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash4("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash5("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -8721,77 +8962,100 @@ function insertDreamRun(db, run) {
   getInsertDreamRunStatement(db).run(run.projectPath, run.startedAt, run.finishedAt, run.holderId, JSON.stringify(run.tasks), run.tasksSucceeded, run.tasksFailed, run.smartNotesSurfaced, run.smartNotesPending, run.memoryChanges ? JSON.stringify(run.memoryChanges) : null, run.parentSessionId ?? null);
 }
 
-// ../plugin/src/features/magic-context/dreamer/storage-task-schedule.ts
-function toRow(r) {
-  return {
-    projectPath: r.project_path,
-    task: r.task,
-    lastRunAt: r.last_run_at,
-    nextDueAt: r.next_due_at,
-    schedule: r.schedule ?? null,
-    lastStatus: r.last_status ?? null,
-    lastError: r.last_error,
-    retryCount: r.retry_count ?? 0,
-    lastCheckedCommit: r.last_checked_commit ?? null,
-    lastBroadRunAt: r.last_broad_run_at ?? null,
-    retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
-  };
-}
-var SELECT_COLUMNS = "project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms";
-function getTaskScheduleState(db, projectPath, task) {
-  const row = db.prepare(`SELECT ${SELECT_COLUMNS} FROM task_schedule_state WHERE project_path = ? AND task = ?`).get(projectPath, task);
-  return row ? toRow(row) : null;
-}
-function getMostRecentTaskRunAt(db, projectPath) {
-  const row = db.prepare("SELECT MAX(last_run_at) AS max_at FROM task_schedule_state WHERE project_path = ?").get(projectPath);
-  const value = row?.max_at ?? null;
-  return typeof value === "number" && value > 0 ? value : null;
-}
-function pruneNonCanonicalTaskRows(db, projectPath, canonicalTasks) {
-  if (canonicalTasks.length === 0)
-    return 0;
-  const placeholders = canonicalTasks.map(() => "?").join(", ");
-  const result = db.prepare(`DELETE FROM task_schedule_state WHERE project_path = ? AND task NOT IN (${placeholders})`).run(projectPath, ...canonicalTasks);
-  return Number(result.changes ?? 0);
-}
-function deleteTaskScheduleRowsForProject(db, projectPath) {
-  const result = db.prepare("DELETE FROM task_schedule_state WHERE project_path = ?").run(projectPath);
-  return Number(result.changes ?? 0);
-}
-function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, schedule) {
-  db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
-}
-function writeTaskScheduleState(db, row) {
-  db.prepare(`INSERT INTO task_schedule_state
-           (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(project_path, task) DO UPDATE SET
-           last_run_at          = excluded.last_run_at,
-           next_due_at          = excluded.next_due_at,
-           schedule             = excluded.schedule,
-           last_status          = excluded.last_status,
-           last_error           = excluded.last_error,
-           retry_count          = excluded.retry_count,
-           last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
-           last_broad_run_at    = COALESCE(excluded.last_broad_run_at, task_schedule_state.last_broad_run_at),
-           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
+// ../plugin/src/features/magic-context/dreamer/verify.ts
+import { createHash as createHash7 } from "node:crypto";
+
+// ../plugin/src/features/magic-context/dreamer/provider-output-failure.ts
+import { createHash as createHash6 } from "node:crypto";
+var MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
+
+class DreamerProviderOutputFailureError extends Error {
+  fingerprint;
+  outputTokens;
+  reasoningTokens;
+  transient = true;
+  constructor(fingerprint, outputTokens, reasoningTokens, responseText) {
+    const preview = responseText.trim().replace(/\s+/g, " ").slice(0, 160);
+    super(`verify provider-outage completion (output_tokens=${outputTokens}, reasoning_tokens=${reasoningTokens}): ${JSON.stringify(preview)}`);
+    this.fingerprint = fingerprint;
+    this.outputTokens = outputTokens;
+    this.reasoningTokens = reasoningTokens;
+    this.name = "DreamerProviderOutputFailureError";
+  }
 }
-function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
-  return row != null;
+function finiteTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 }
-function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  db.prepare("INSERT INTO retrospective_processed_windows (project_path, window_key, processed_at) VALUES (?, ?, ?) ON CONFLICT(project_path, window_key) DO NOTHING").run(projectPath, windowKey, Date.now());
+function completionShape(value) {
+  if (!isRecord(value))
+    return null;
+  const info = isRecord(value.info) ? value.info : value;
+  if (info.role !== "assistant")
+    return null;
+  const time = isRecord(info.time) ? info.time : null;
+  const tokens = isRecord(info.tokens) ? info.tokens : null;
+  return {
+    createdAt: typeof time?.created === "number" ? time.created : 0,
+    finish: typeof info.finish === "string" ? info.finish : typeof info.finish_reason === "string" ? info.finish_reason : typeof info.finishReason === "string" ? info.finishReason : null,
+    error: info.error,
+    outputTokens: finiteTokenCount(tokens?.output),
+    reasoningTokens: finiteTokenCount(tokens?.reasoning)
+  };
+}
+function latestAssistantCompletion(messages) {
+  if (!Array.isArray(messages))
+    return null;
+  let latest = null;
+  for (const message of messages) {
+    const completion = completionShape(message);
+    if (completion && (!latest || completion.createdAt >= latest.createdAt))
+      latest = completion;
+  }
+  return latest;
+}
+function providerOutputFailureFromInvalidManifest(messages, responseText) {
+  const completion = latestAssistantCompletion(messages);
+  if (completion?.finish?.toLowerCase() !== "stop")
+    return null;
+  if (completion.error != null || completion.outputTokens === null || completion.outputTokens > MAX_NEAR_ZERO_OUTPUT_TOKENS || completion.reasoningTokens !== 0) {
+    return null;
+  }
+  const normalized = responseText.trim().replace(/\s+/g, " ").toLowerCase();
+  if (!normalized)
+    return null;
+  const fingerprint = createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
+  return new DreamerProviderOutputFailureError(fingerprint, completion.outputTokens, completion.reasoningTokens, responseText);
 }
-
-// ../plugin/src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash5 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/dreamer/verify-gate.ts
 import path5 from "node:path";
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
+function ensureBroadCycleStart(args) {
+  const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+  if (current?.lastBroadRunAt != null && current.lastBroadRunAt > 0) {
+    return current.lastBroadRunAt;
+  }
+  if (!current)
+    return args.runStartedAt;
+  if (!args.holderId || !args.leaseKey) {
+    throw new Error("verify-broad cycle opening requires the task lease");
+  }
+  return runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const latest = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (!latest)
+      return args.runStartedAt;
+    if (latest.lastBroadRunAt != null && latest.lastBroadRunAt > 0) {
+      return latest.lastBroadRunAt;
+    }
+    writeTaskScheduleState(args.db, {
+      ...latest,
+      lastBroadRunAt: args.runStartedAt
+    });
+    return args.runStartedAt;
+  });
+}
 async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject(args.db, args.projectIdentity);
@@ -8803,6 +9067,29 @@ async function partitionVerifyScope(args) {
     content: m.content,
     mappedFiles: verById.get(m.id)?.files ?? []
   });
+  if (args.forceBroad) {
+    const broadCycleStartAt = ensureBroadCycleStart({
+      db: args.db,
+      projectIdentity: args.projectIdentity,
+      holderId: args.holderId,
+      leaseKey: args.leaseKey,
+      runStartedAt
+    });
+    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+      const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
+      const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
+      return verifiedAtA - verifiedAtB || a.id - b.id;
+    });
+    return {
+      runStartedAt,
+      mode: "broad",
+      inScope: broadCandidates.map(toPrompt),
+      inScopeIds: broadCandidates.map((m) => m.id),
+      skippedIds: candidates.filter((m) => !broadCandidates.some((candidate) => candidate.id === m.id)).map((m) => m.id),
+      broadCycleStartAt,
+      reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
+    };
+  }
   if (candidates.length === 0) {
     return {
       runStartedAt,
@@ -8813,16 +9100,6 @@ async function partitionVerifyScope(args) {
       reason: "no file-mapped memories in scope"
     };
   }
-  if (args.forceBroad) {
-    return {
-      runStartedAt,
-      mode: "broad",
-      inScope: candidates.map(toPrompt),
-      inScopeIds: candidates.map((m) => m.id),
-      skippedIds: [],
-      reason: "broad full-pool verification of file-mapped memories"
-    };
-  }
   const allInScope = (mode, reason) => ({
     runStartedAt,
     mode,
@@ -8941,7 +9218,26 @@ function parseVerifyManifest(text) {
 
 // ../plugin/src/features/magic-context/dreamer/verify.ts
 var VERIFY_BATCH_SIZE = 50;
+var IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT = 2;
+function closeBroadCycle(args, cycleStartAt) {
+  if (!args.forceBroad || cycleStartAt === undefined)
+    return;
+  if (!getTaskScheduleState(args.db, args.projectIdentity, "verify-broad"))
+    return;
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (current?.lastBroadRunAt !== cycleStartAt)
+      return;
+    if (!current)
+      return;
+    writeTaskScheduleState(args.db, {
+      ...current,
+      lastBroadRunAt: null
+    });
+  });
+}
 async function runVerify(args) {
+  const runStartedAt = Date.now();
   const result = {
     verified: 0,
     updated: 0,
@@ -8956,20 +9252,29 @@ async function runVerify(args) {
     db: args.db,
     projectIdentity: args.projectIdentity,
     projectDirectory: args.sessionDirectory,
-    forceBroad: args.forceBroad
+    forceBroad: args.forceBroad,
+    now: runStartedAt,
+    holderId: args.holderId,
+    leaseKey: args.leaseKey
   });
   result.mode = gate.mode;
+  result.broadCycleStartAt = gate.broadCycleStartAt;
   result.inScope = gate.inScope.length;
   result.remaining = gate.inScope.length;
   log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"} gate: mode=${gate.mode} in_scope=${gate.inScope.length} skipped=${gate.skippedIds.length} reason=${gate.reason}`);
-  if (gate.inScope.length === 0)
+  if (gate.inScope.length === 0) {
+    closeBroadCycle(args, gate.broadCycleStartAt);
     return result;
+  }
   const batches = [];
   for (let i = 0;i < gate.inScope.length; i += VERIFY_BATCH_SIZE) {
     batches.push(gate.inScope.slice(i, i + VERIFY_BATCH_SIZE));
   }
   const abortController = new AbortController;
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort());
+  let consecutiveProviderFailures = 0;
+  let priorProviderFailureFingerprint = null;
+  let lastProviderFailure = null;
   try {
     for (let i = 0;i < batches.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
@@ -8984,8 +9289,28 @@ async function runVerify(args) {
       result.remaining -= counts.verified + counts.updated + counts.archived;
       result.batches += 1;
       args.onProgress?.(result.verified + result.updated + result.archived);
+      if (counts.providerFailure) {
+        lastProviderFailure = counts.providerFailure;
+        if (counts.providerFailure.fingerprint === priorProviderFailureFingerprint) {
+          consecutiveProviderFailures += 1;
+        } else {
+          priorProviderFailureFingerprint = counts.providerFailure.fingerprint;
+          consecutiveProviderFailures = 1;
+        }
+        if (consecutiveProviderFailures >= IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT) {
+          log(`[dreamer] verify run aborting after ${consecutiveProviderFailures} identical provider-failure batches`);
+          throw counts.providerFailure;
+        }
+      } else {
+        priorProviderFailureFingerprint = null;
+        consecutiveProviderFailures = 0;
+      }
     }
+    if (lastProviderFailure)
+      throw lastProviderFailure;
     result.complete = result.remaining === 0;
+    if (result.complete)
+      closeBroadCycle(args, gate.broadCycleStartAt);
     log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
     return result;
   } finally {
@@ -9040,7 +9365,14 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("verify returned no output");
-        parseVerifyManifest(text);
+        try {
+          parseVerifyManifest(text);
+        } catch (error) {
+          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+          if (providerFailure)
+            throw providerFailure;
+          throw error;
+        }
         return text;
       }
     });
@@ -9048,11 +9380,12 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     return await applyVerifyManifest(args, batch, run.validated);
   } catch (error) {
     const desc = describeError(error);
-    log(`[dreamer] verify batch failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
+    const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
+    log(`[dreamer] verify batch ${providerFailure ? "provider failure" : "failed"}: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation4(args, startedAt, { status: "failed", error });
     if (error instanceof DreamerModuleFailureError || signal.aborted)
       throw error;
-    return { verified: 0, updated: 0, archived: 0 };
+    return { verified: 0, updated: 0, archived: 0, providerFailure };
   } finally {
     if (agentSessionId && !shouldKeepSubagents()) {
       await args.client.session.delete({
@@ -9124,7 +9457,7 @@ async function applyVerifyManifest(args, batch, manifestText) {
             memory_project: args.projectIdentity,
             context_store_uuid: args.moduleRoute.moduleContextStoreUuid,
             authority_generation: args.moduleRoute.moduleAuthorityGeneration,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash5("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash7("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -9319,7 +9652,7 @@ function createDreamTaskExecutor(deps) {
               resultChars: 0,
               ...error ? { error } : {},
               backlog: (() => {
-                const end = getDreamTaskBacklog(db, projectIdentity, config.task);
+                const end = extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task);
                 const processed = processedDreamTaskItems(backlogAtStart.pending, end.pending);
                 const value = {
                   pendingAtStart: backlogAtStart.pending,
@@ -9368,12 +9701,6 @@ function createDreamTaskExecutor(deps) {
           recordRun("completed", null);
           return { status: "completed" };
         }
-        if (moduleRoute) {
-          const reason = "compress-cues parked: MODULE memory authority has no cue write facade";
-          log(`[dreamer] compress-cues: skipped (${reason})`);
-          recordRun("failed", reason);
-          return { status: "failed", transient: true, error: reason };
-        }
         const result = await runCompressCues({
           db,
           client: deps.client,
@@ -9385,6 +9712,7 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model ?? deps.mural.model ?? deps.dreamerModel,
           fallbackModels: config.fallbackModels,
+          moduleRoute,
           onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] compress-cues: compressed=${result.compressed} skipped=${result.skipped} chunks=${result.chunks} remaining=${result.remaining}`);
@@ -9454,19 +9782,31 @@ function createDreamTaskExecutor(deps) {
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
           moduleRoute,
-          onProgress: (processed) => reportProgress(processed)
+          onProgress: (processed2) => reportProgress(processed2)
         });
+        const processed = result.verified + result.updated + result.archived;
+        const broadProgress = config.task === "verify-broad" ? `verify-broad cycle ${result.broadCycleStartAt ?? "open"}: verified ${processed}, ${result.remaining} remain` : null;
+        const backlogAfter = config.task === "verify-broad" ? { pending: result.remaining, total: backlogAtStart.total } : undefined;
         if (!result.complete) {
+          if (broadProgress && processed > 0) {
+            recordRun("completed", broadProgress, {
+              memoryChanges: computeMemoryDelta(memoryBefore),
+              backlogAfter
+            });
+            return { status: "completed", error: broadProgress };
+          }
           const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
-            memoryChanges: computeMemoryDelta(memoryBefore)
+            memoryChanges: computeMemoryDelta(memoryBefore),
+            backlogAfter
           });
           return { status: "failed", transient: true, error };
         }
-        recordRun("completed", null, {
-          memoryChanges: computeMemoryDelta(memoryBefore)
+        recordRun("completed", broadProgress, {
+          memoryChanges: computeMemoryDelta(memoryBefore),
+          backlogAfter
         });
-        return { status: "completed" };
+        return broadProgress ? { status: "completed", error: broadProgress } : { status: "completed" };
       }
       if (config.task === "classify-memories") {
         let moduleArgs;
@@ -9654,7 +9994,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash6("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash8("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -12757,513 +13097,6 @@ function replayCavemanCompression(sessionId, db, targets, tags) {
   return replayed;
 }
 
-// ../plugin/src/hooks/magic-context/read-session-true-raw-tokens.ts
-var MAX_MESSAGE_CACHE_ENTRIES = 1e5;
-var MAX_MESSAGE_CACHE_KEY_BYTES = 64 * 1024 * 1024;
-var FNV1A_32_OFFSET = 2166136261;
-var FNV1A_32_PRIME = 16777619;
-var messageEstimateCache = new Map;
-var messageEstimateCacheBytes = 0;
-var EMPTY_BREAKDOWN = {
-  text: 0,
-  reasoning: 0,
-  toolInput: 0,
-  toolOutput: 0,
-  image: 0,
-  other: 0,
-  total: 0
-};
-function addBreakdown(target, kind, value) {
-  if (kind === "total")
-    return;
-  const safeValue = Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
-  target[kind] += safeValue;
-  target.total += safeValue;
-}
-function estimateStructured(value) {
-  if (typeof value === "string")
-    return estimateTokens(value);
-  if (value === undefined || value === null)
-    return 0;
-  return estimateTokens(stableStringify(value));
-}
-function firstStringField(record, fields) {
-  for (const field of fields) {
-    const value = record[field];
-    if (typeof value === "string" && value.length > 0)
-      return value;
-  }
-  return null;
-}
-function stringValue(value) {
-  if (typeof value === "string")
-    return value;
-  if (value === undefined || value === null)
-    return "";
-  return stableStringify(value);
-}
-function textFromToolResultContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    const pieces = [];
-    for (const entry of content) {
-      if (typeof entry === "string") {
-        pieces.push(entry);
-      } else if (isRecord(entry)) {
-        const text = firstStringField(entry, ["text", "content", "value"]);
-        pieces.push(text ?? stableStringify(entry));
-      } else if (entry !== null && entry !== undefined) {
-        pieces.push(String(entry));
-      }
-    }
-    return pieces.join(`
-`);
-  }
-  return stringValue(content);
-}
-function looksImageLike(part) {
-  const type = typeof part.type === "string" ? part.type.toLowerCase() : "";
-  const mime = typeof part.mime === "string" ? part.mime.toLowerCase() : "";
-  const mediaType = typeof part.mediaType === "string" ? part.mediaType.toLowerCase() : "";
-  return type.includes("image") || mime.startsWith("image/") || mediaType.startsWith("image/") || part.image_url !== undefined || part.imageUrl !== undefined || part.image !== undefined;
-}
-function defaultImageTokenHeuristic(part) {
-  if (isRecord(part)) {
-    const width = part.width;
-    const height = part.height;
-    if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
-      return Math.max(256, Math.min(4096, Math.ceil(width * height / 750)));
-    }
-  }
-  return 1024;
-}
-function partType(part) {
-  return typeof part.type === "string" ? part.type : "";
-}
-function hasOwn(record, key) {
-  return Object.hasOwn(record, key);
-}
-function recursiveByteLength(value) {
-  if (value === null || value === undefined)
-    return 0;
-  if (typeof value === "string")
-    return value.length;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value).length;
-  }
-  if (Array.isArray(value)) {
-    return value.reduce((sum, item) => sum + recursiveByteLength(item), value.length);
-  }
-  if (isRecord(value)) {
-    let total = Object.keys(value).length;
-    for (const [key, child] of Object.entries(value)) {
-      total += key.length + recursiveByteLength(child);
-    }
-    return total;
-  }
-  return String(value).length;
-}
-function updateFnv1a32(hash, text) {
-  let next = hash;
-  for (let index = 0;index < text.length; index += 1) {
-    next ^= text.charCodeAt(index);
-    next = Math.imul(next, FNV1A_32_PRIME) >>> 0;
-  }
-  return next;
-}
-function contentStringsHash(fields) {
-  let hash = FNV1A_32_OFFSET;
-  for (const field of fields) {
-    hash = updateFnv1a32(hash, `${field.length}:`);
-    hash = updateFnv1a32(hash, field);
-    hash = updateFnv1a32(hash, "\x00");
-  }
-  return hash.toString(16).padStart(8, "0");
-}
-function rawPartVersion(part) {
-  return part.__magicContextPartUpdatedAt ?? part.updated_at ?? part.updatedAt ?? part.version ?? part.revision ?? "";
-}
-function callIdFromPart(part) {
-  const direct = firstStringField(part, ["callID", "callId", "toolCallId", "tool_call_id", "id"]);
-  if (direct)
-    return direct;
-  const state2 = isRecord(part.state) ? part.state : null;
-  return state2 ? firstStringField(state2, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
-}
-function toolSignalFromPart(part) {
-  if (!isRecord(part))
-    return null;
-  const type = partType(part);
-  const state2 = isRecord(part.state) ? part.state : null;
-  const callId = callIdFromPart(part);
-  if (!callId && type !== "tool")
-    return null;
-  if (type === "tool") {
-    const hasInput = state2 !== null && hasOwn(state2, "input");
-    const outputKey = state2 ? hasOwn(state2, "output") ? "output" : hasOwn(state2, "error") ? "error" : hasOwn(state2, "result") ? "result" : null : null;
-    const hasOutput = outputKey !== null;
-    const outputValue = outputKey && state2 ? state2[outputKey] : undefined;
-    const providerExecuted = part.providerExecuted === true;
-    const openInvocation = !providerExecuted && !hasOutput;
-    return {
-      callId,
-      hasInput: hasInput || openInvocation,
-      hasOutput,
-      inputText: hasInput && state2 ? stringValue(state2.input) : "",
-      outputText: hasOutput ? stringValue(outputValue) : ""
-    };
-  }
-  if (type === "tool-invocation") {
-    const args = part.args ?? part.input;
-    return {
-      callId,
-      hasInput: args !== undefined,
-      hasOutput: false,
-      inputText: args !== undefined ? stringValue(args) : "",
-      outputText: ""
-    };
-  }
-  if (type === "tool_use") {
-    const input = part.input;
-    return {
-      callId,
-      hasInput: input !== undefined,
-      hasOutput: false,
-      inputText: input !== undefined ? stringValue(input) : "",
-      outputText: ""
-    };
-  }
-  if (type === "tool_result") {
-    const content = part.content ?? part.output ?? part.result;
-    return {
-      callId,
-      hasInput: false,
-      hasOutput: content !== undefined,
-      inputText: "",
-      outputText: content !== undefined ? textFromToolResultContent(content) : ""
-    };
-  }
-  return null;
-}
-function partCheapFingerprint(part) {
-  if (!isRecord(part))
-    return `${typeof part}:${recursiveByteLength(part)}`;
-  const version = rawPartVersion(part);
-  const type = typeof part.type === "string" ? part.type : "";
-  return `${type}:${String(version)}:${recursiveByteLength(part)}`;
-}
-function messageCacheKey(message, options) {
-  const namespace = "cacheNamespace" in options ? options.cacheNamespace : "estimate";
-  const cheapFingerprint = message.parts.map(partCheapFingerprint).join("|");
-  return [
-    namespace,
-    options.providerShapeVersion,
-    message.id || `ordinal:${message.ordinal}`,
-    message.role,
-    message.parts.length,
-    cheapFingerprint
-  ].join("\x00");
-}
-function setCachedEstimate(key, breakdown) {
-  const keyEstimateBytes = key.length * 2 + 64;
-  const existing = messageEstimateCache.get(key);
-  if (existing)
-    messageEstimateCacheBytes -= existing.keyEstimateBytes;
-  messageEstimateCache.set(key, { breakdown, keyEstimateBytes });
-  messageEstimateCacheBytes += keyEstimateBytes;
-  while (messageEstimateCache.size > MAX_MESSAGE_CACHE_ENTRIES || messageEstimateCacheBytes > MAX_MESSAGE_CACHE_KEY_BYTES) {
-    const first = messageEstimateCache.keys().next().value;
-    if (typeof first !== "string")
-      break;
-    const removed = messageEstimateCache.get(first);
-    if (removed)
-      messageEstimateCacheBytes -= removed.keyEstimateBytes;
-    messageEstimateCache.delete(first);
-  }
-}
-function cloneBreakdown(value) {
-  return { ...value };
-}
-function estimateNonToolPart(part, options, breakdown) {
-  if (!isRecord(part)) {
-    if (part !== null && part !== undefined)
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    return true;
-  }
-  const type = partType(part);
-  if (type === "step-start" || type === "step-finish" || type === "meta" && Object.keys(part).length <= 1) {
-    return true;
-  }
-  if (type === "text") {
-    const text = firstStringField(part, ["text", "content"]);
-    if (text)
-      addBreakdown(breakdown, "text", estimateTokens(text));
-    return true;
-  }
-  if (type === "reasoning" || type === "thinking" || type === "redacted_thinking") {
-    const text = firstStringField(part, ["thinking", "text", "content", "reasoning"]);
-    if (text) {
-      addBreakdown(breakdown, "reasoning", estimateTokens(text));
-    } else {
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    }
-    return true;
-  }
-  const reasoningText = firstStringField(part, ["thinking", "reasoning"]);
-  if (reasoningText && type.length === 0) {
-    addBreakdown(breakdown, "reasoning", estimateTokens(reasoningText));
-    return true;
-  }
-  if (looksImageLike(part)) {
-    addBreakdown(breakdown, "image", options.imageTokenHeuristic?.(part) ?? defaultImageTokenHeuristic(part));
-    const altText = firstStringField(part, ["alt", "text", "description"]);
-    if (altText)
-      addBreakdown(breakdown, "text", estimateTokens(altText));
-    return true;
-  }
-  if (type.includes("file") || type === "source") {
-    const content = firstStringField(part, ["content", "text", "source"]);
-    if (content)
-      addBreakdown(breakdown, "text", estimateTokens(content));
-    else
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    return true;
-  }
-  return false;
-}
-function estimateTrueRawMessageTokens(message, options) {
-  const breakdown = cloneBreakdown(EMPTY_BREAKDOWN);
-  const countedInput = new Set;
-  const countedOutput = new Set;
-  let ordinalToolIndex = 0;
-  for (const part of message.parts) {
-    const signal = toolSignalFromPart(part);
-    if (signal) {
-      const localKey = `${signal.callId || "tool"}:${message.ordinal}:${ordinalToolIndex}`;
-      ordinalToolIndex += 1;
-      if (signal.hasInput) {
-        const key = `${signal.callId}:input:${message.ordinal}`;
-        if (!countedInput.has(key)) {
-          countedInput.add(key);
-          addBreakdown(breakdown, "toolInput", estimateTokens(signal.inputText));
-        }
-      }
-      if (signal.hasOutput) {
-        const key = `${signal.callId}:output:${message.ordinal}:${localKey}`;
-        if (!countedOutput.has(key)) {
-          countedOutput.add(key);
-          addBreakdown(breakdown, "toolOutput", estimateTokens(signal.outputText));
-        }
-      }
-      continue;
-    }
-    if (!estimateNonToolPart(part, options, breakdown)) {
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    }
-  }
-  return breakdown;
-}
-function buildToolArcs(messages) {
-  const openQueues = new Map;
-  const arcs = [];
-  for (const message of messages) {
-    for (const part of message.parts) {
-      const signal = toolSignalFromPart(part);
-      if (!signal || signal.callId.length === 0)
-        continue;
-      if (signal.hasInput && signal.hasOutput) {
-        arcs.push({
-          callId: signal.callId,
-          invOrdinal: message.ordinal,
-          resOrdinal: message.ordinal
-        });
-        continue;
-      }
-      if (signal.hasInput) {
-        const queue = openQueues.get(signal.callId) ?? [];
-        queue.push(message.ordinal);
-        openQueues.set(signal.callId, queue);
-        continue;
-      }
-      if (signal.hasOutput) {
-        const queue = openQueues.get(signal.callId) ?? [];
-        const invOrdinal = queue.shift();
-        if (queue.length === 0)
-          openQueues.delete(signal.callId);
-        else
-          openQueues.set(signal.callId, queue);
-        if (invOrdinal !== undefined) {
-          arcs.push({ callId: signal.callId, invOrdinal, resOrdinal: message.ordinal });
-        }
-      }
-    }
-  }
-  for (const [callId, queue] of openQueues) {
-    for (const invOrdinal of queue) {
-      arcs.push({ callId, invOrdinal, resOrdinal: null });
-    }
-  }
-  return arcs.sort((a, b) => a.invOrdinal - b.invOrdinal || (a.resOrdinal ?? Number.MAX_SAFE_INTEGER) - (b.resOrdinal ?? Number.MAX_SAFE_INTEGER));
-}
-function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
-  let boundary = candidate;
-  for (const arc of arcs) {
-    if (arc.resOrdinal !== null) {
-      if (arc.invOrdinal < boundary && boundary <= arc.resOrdinal) {
-        boundary = arc.resOrdinal + 1;
-      }
-      continue;
-    }
-    if (arc.invOrdinal < recentOpenArcCutoff)
-      continue;
-    if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
-      return arc.invOrdinal;
-    }
-    if (arc.invOrdinal >= boundary) {
-      return arc.invOrdinal;
-    }
-  }
-  return boundary;
-}
-function tokenForMessage(message, options) {
-  const key = messageCacheKey(message, options);
-  const cached = messageEstimateCache.get(key);
-  if (cached)
-    return cloneBreakdown(cached.breakdown);
-  const breakdown = estimateTrueRawMessageTokens(message, options);
-  setCachedEstimate(key, breakdown);
-  return cloneBreakdown(breakdown);
-}
-function buildTrueRawTokenIndex(sessionId, messages, options) {
-  const ordered = [...messages].sort((a, b) => a.ordinal - b.ordinal);
-  const sliceCount = ordered.length;
-  const firstOrdinal = ordered.length > 0 ? ordered[0].ordinal : 1;
-  const terminalOrdinal = ordered.length > 0 ? ordered[ordered.length - 1].ordinal : 0;
-  const rawMessageCount = Math.max(sliceCount, terminalOrdinal, options.absoluteMessageCount ?? sliceCount);
-  const ordinalSpan = terminalOrdinal >= firstOrdinal ? terminalOrdinal - firstOrdinal + 1 : 0;
-  const tokensByOrdinal = new Map;
-  const idsByOrdinal = new Map;
-  const prefix = new Array(ordinalSpan + 1).fill(0);
-  for (const message of ordered) {
-    const stored = options.storedTotalForMessage?.(message);
-    const total = stored !== undefined && stored !== null ? stored : tokenForMessage(message, options).total;
-    tokensByOrdinal.set(message.ordinal, total);
-    idsByOrdinal.set(message.ordinal, message.id);
-    const relative = message.ordinal - firstOrdinal + 1;
-    if (relative >= 1 && relative <= ordinalSpan) {
-      prefix[relative] = total;
-    }
-  }
-  for (let k = 1;k <= ordinalSpan; k += 1) {
-    prefix[k] += prefix[k - 1];
-  }
-  const ordinalToIndex = (ordinal) => Math.max(0, Math.min(ordinalSpan, ordinal - firstOrdinal));
-  return {
-    sessionId,
-    providerShapeVersion: options.providerShapeVersion,
-    rawMessageCount,
-    tokenForOrdinal(ordinal) {
-      return tokensByOrdinal.get(ordinal) ?? 0;
-    },
-    messageIdAtOrdinal(ordinal) {
-      return idsByOrdinal.get(ordinal) ?? null;
-    },
-    suffixTokensFromOrdinal(ordinal) {
-      if (ordinal <= firstOrdinal)
-        return prefix[ordinalSpan];
-      if (ordinal > terminalOrdinal)
-        return 0;
-      return prefix[ordinalSpan] - prefix[ordinalToIndex(ordinal)];
-    },
-    rangeTokens(startInclusive, endExclusive) {
-      const start = Math.max(firstOrdinal, startInclusive);
-      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
-      return prefix[end - firstOrdinal] - prefix[start - firstOrdinal];
-    },
-    findSuffixStartForTokens(tokens) {
-      if (!Number.isFinite(tokens) || tokens <= 0)
-        return terminalOrdinal + 1;
-      const target = Math.max(0, Math.floor(tokens));
-      const total = prefix[ordinalSpan];
-      if (total < target)
-        return firstOrdinal;
-      const cut = total - target;
-      let lo = 0;
-      let hi = ordinalSpan;
-      let best = 0;
-      while (lo <= hi) {
-        const mid = lo + hi >> 1;
-        if (prefix[mid] <= cut) {
-          best = mid;
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
-        }
-      }
-      return firstOrdinal + best;
-    },
-    findHeadEndForCap(startInclusive, endExclusive, capTokens) {
-      const start = Math.max(firstOrdinal, Math.min(terminalOrdinal + 1, startInclusive));
-      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
-      if (!Number.isFinite(capTokens) || capTokens <= 0)
-        return start;
-      const startIndex = start - firstOrdinal;
-      const endIndex = end - firstOrdinal;
-      const cut = prefix[startIndex] + Math.floor(capTokens);
-      let lo = startIndex + 1;
-      let hi = endIndex;
-      let bestEndIndex = startIndex;
-      while (lo <= hi) {
-        const mid = lo + hi >> 1;
-        if (prefix[mid] <= cut) {
-          bestEndIndex = mid;
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
-        }
-      }
-      let bestEnd = firstOrdinal + bestEndIndex;
-      if (bestEnd === start && start < end)
-        bestEnd = start + 1;
-      return Math.min(bestEnd, end);
-    }
-  };
-}
-function partContentFingerprint(part) {
-  if (!isRecord(part))
-    return `${typeof part}:${recursiveByteLength(part)}`;
-  const tool = toolSignalFromPart(part);
-  if (tool) {
-    return contentStringsHash([tool.inputText, tool.outputText]);
-  }
-  const text = firstStringField(part, ["text", "thinking", "reasoning", "content", "url"]) ?? "";
-  return contentStringsHash([text]);
-}
-function computeRawRangeFingerprint(messages, startInclusive, endExclusive) {
-  const pieces = [];
-  for (const message of messages) {
-    if (message.ordinal < startInclusive || message.ordinal >= endExclusive)
-      continue;
-    const partFingerprint = message.parts.map(partContentFingerprint).join(",");
-    pieces.push(`${message.ordinal}:${message.id}:${message.parts.length}:${partFingerprint}`);
-  }
-  return pieces.join("|");
-}
-function invalidateTrueRawTokenCache(args) {
-  const sessionNeedle = args.sessionId ? `${args.sessionId}` : null;
-  const messageNeedle = args.messageId ? `\x00${args.messageId}\x00` : null;
-  for (const [key, value] of messageEstimateCache) {
-    const sessionMatches = sessionNeedle === null || key.includes(sessionNeedle);
-    const messageMatches = messageNeedle === null || key.includes(messageNeedle);
-    if (sessionMatches && messageMatches) {
-      messageEstimateCache.delete(key);
-      messageEstimateCacheBytes -= value.keyEstimateBytes;
-    }
-  }
-  args.reason;
-}
-
 // ../plugin/src/hooks/magic-context/protected-tail-boundary.ts
 var ALPHA = 0.3;
 var FLOOR_RATIO = 0.08;
@@ -13384,7 +13217,7 @@ function fenceWrapupBoundaryForToolArcs(args) {
       if (arc.resOrdinal === null) {
         continue;
       }
-      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && arc.invOrdinal < next && next <= arc.resOrdinal) {
+      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && completedToolArcCrossesBoundary(arc.invOrdinal, arc.resOrdinal, next)) {
         next = arc.invOrdinal;
       }
     }
@@ -14401,7 +14234,7 @@ function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
 }
 
 // ../plugin/src/shared/tag-transcript.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // ../plugin/src/hooks/magic-context/image-token-estimate.ts
 var IMAGE_TOKEN_DIVISOR = 750;
@@ -14556,7 +14389,7 @@ function readUint32BE(b, offset) {
 // ../plugin/src/shared/tag-transcript.ts
 var TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
 function textIdentityDigest(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function buildContentDerivedTextIds(messageId, parts) {
   const sources = parts.filter((part) => part.kind === "text").map((part) => stripTagPrefix(part.getText() ?? ""));
@@ -18443,6 +18276,7 @@ function mapParsedCompartmentsToChunk(compartments, chunk, sequenceOffset) {
 
 // ../plugin/src/hooks/magic-context/compartment-runner-validation.ts
 var MIN_RECOMP_CHUNK_TOKEN_BUDGET = 20;
+var HISTORIAN_BOUNDARY_HEALING_SLACK = 2;
 function healCompartmentGaps(compartments, toolOnlyRanges = []) {
   for (let i = 1;i < compartments.length; i++) {
     const prev = compartments[i - 1];
@@ -18458,6 +18292,36 @@ function healCompartmentGaps(compartments, toolOnlyRanges = []) {
     }
   }
 }
+function boundarySplitsCompletedToolArc(boundary, arcs = []) {
+  return arcs.some((arc) => completedToolArcCrossesBoundary(arc.start, arc.end, boundary));
+}
+function healTerminalCompletedToolArc(compartments, unprocessedFrom, arcs = [], chunkEnd) {
+  const last = compartments[compartments.length - 1];
+  if (!last)
+    return unprocessedFrom;
+  const originalEnd = last.endMessage;
+  for (let pass = 0;pass <= arcs.length; pass += 1) {
+    const boundary = last.endMessage + 1;
+    let nextEnd = last.endMessage;
+    for (const arc of arcs) {
+      if (arc.end <= chunkEnd && completedToolArcCrossesBoundary(arc.start, arc.end, boundary)) {
+        nextEnd = Math.max(nextEnd, arc.end);
+      }
+    }
+    if (nextEnd === last.endMessage)
+      break;
+    last.endMessage = nextEnd;
+  }
+  return last.endMessage !== originalEnd && unprocessedFrom !== null ? last.endMessage + 1 : unprocessedFrom;
+}
+function shouldDiscardLastHistorianCompartment(compartments, chunk) {
+  if (compartments.length < 2)
+    return false;
+  const last = compartments[compartments.length - 1];
+  const previous = compartments[compartments.length - 2];
+  const lookaheadMargin = chunk.endIndex - last.endMessage;
+  return lookaheadMargin <= HISTORIAN_BOUNDARY_HEALING_SLACK && !boundarySplitsCompletedToolArc(previous.endMessage + 1, chunk.completedToolArcs);
+}
 function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, sequenceOffset) {
   const parsed = parseCompartmentOutput(text);
   if (parsed.compartments.length === 0) {
@@ -18467,6 +18331,7 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
     };
   }
   healCompartmentGaps(parsed.compartments, chunk.toolOnlyRanges);
+  parsed.unprocessedFrom = healTerminalCompletedToolArc(parsed.compartments, parsed.unprocessedFrom, chunk.completedToolArcs, chunk.endIndex);
   const mapped = mapParsedCompartmentsToChunk(parsed.compartments, chunk, sequenceOffset);
   if (!mapped.ok) {
     return {
@@ -18481,6 +18346,13 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
       error: `Historian returned invalid compartment output: ${parsedValidationError}`
     };
   }
+  const last = parsed.compartments[parsed.compartments.length - 1];
+  if (last && boundarySplitsCompletedToolArc(last.endMessage + 1, chunk.completedToolArcs)) {
+    return {
+      ok: false,
+      error: "Historian terminal boundary splits a completed tool invocation/result arc"
+    };
+  }
   return {
     ok: true,
     compartments: mapped.compartments,
@@ -20910,17 +20782,14 @@ ${chunkText}`,
           }
         }
       }
-      const BOUNDARY_HEALING_SLACK = 2;
       const inEmergency = getOverflowState(db, sessionId).needsEmergencyRecovery;
       const emittedCompartments = validatedPass.compartments;
       let newCompartments = emittedCompartments;
-      if (!inEmergency && !forceKeepLastCompartmentForChunk && emittedCompartments.length >= 2) {
+      if (!inEmergency && !forceKeepLastCompartmentForChunk && shouldDiscardLastHistorianCompartment(emittedCompartments, chunk)) {
         const lastEmitted = emittedCompartments[emittedCompartments.length - 1];
         const lookaheadMargin = chunk.endIndex - lastEmitted.endMessage;
-        if (lookaheadMargin <= BOUNDARY_HEALING_SLACK) {
-          newCompartments = emittedCompartments.slice(0, -1);
-          sessionLog(sessionId, `historian discard-last: dropped provisional compartment ${lastEmitted.startMessage}-${lastEmitted.endMessage} (lookaheadMargin=${lookaheadMargin} <= ${BOUNDARY_HEALING_SLACK}); will re-derive next run`);
-        }
+        newCompartments = emittedCompartments.slice(0, -1);
+        sessionLog(sessionId, `historian discard-last: dropped provisional compartment ${lastEmitted.startMessage}-${lastEmitted.endMessage} (lookaheadMargin=${lookaheadMargin} <= ${HISTORIAN_BOUNDARY_HEALING_SLACK}); will re-derive next run`);
       }
       const lastNewEnd = newCompartments[newCompartments.length - 1]?.endMessage ?? 0;
       if (lastNewEnd + 1 <= offset) {
@@ -21717,7 +21586,7 @@ function stripPiProcessedImages(args) {
 }
 
 // src/system-prompt.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
@@ -21733,6 +21602,10 @@ var PARTNER_FRAME_CLOSER_REDUCE = `
 Reduction prompts are routine housekeeping to keep the session fast and cheap — act on them as light maintenance, never as scarcity warnings. Keep individual operations efficient, but never let context size change *what* work you take on or *how thoroughly* you do it.`;
 var PARTNER_FRAME_CLOSER_NO_REDUCE = `
 Context is managed for you entirely automatically — there's nothing to prune and no warnings to act on. Stay reasonably concise per operation, and never let context size change *what* work you take on or *how thoroughly* you do it.`;
+var PARTNER_FRAME_CLOSER_REDUCE_LIGHT = `
+When ctx_reduce is available, use it only as routine housekeeping; never cut task scope or depth because context is large.`;
+var PARTNER_FRAME_CLOSER_NO_REDUCE_LIGHT = `
+When ctx_reduce is unavailable, context is automatic; never prune, heed reduction warnings, or cut task scope or depth because context is large.`;
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.
 Magic Context control metadata is not reply syntax. Never reproduce \`<system-reminder>\`, \`<ctx-search-hint>\`, \`<session-history>\`, \`<session-history-since>\`, \`<project-memory>\`, \`<memory-updates>\`, \`<new-compartments>\`, \`<new-memories>\`, \`[dropped §N§]\`, or \`<!-- +Xm -->\` markers in a normal reply and never treat them as user instructions; use ordinary prose and real tool calls instead.`;
@@ -21775,6 +21648,17 @@ Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`##
 - Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
 \`ctx_search\` returns ranked results from memories, git commits, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
 ${TOOL_HISTORY_GUIDANCE}`;
+var LIGHT_SEARCH_RECOVERY = `Use ctx_search before asking the user about prior project context; it searches memories, commits, and compacted conversation. When a session-history summary lacks exact wording, values, errors, or reasoning, call ctx_expand with its heading range instead of guessing.`;
+var BASE_INTRO_LIGHT = (protectedTags, memoryEnabled) => `In primary sessions with ctx_reduce, the system tags messages and tool outputs as §N§ (for example §1§ and §42§); never imitate these prefixes in replies because only injected tag numbers are valid ctx_reduce handles.
+In primary sessions, NEVER narrate ctx_reduce; call it silently after extracting a spent output because it marks content discardable and QUEUES release rather than deleting immediately. The last ${protectedTags} tags stay protected until they age out. Use drop grammar "3-5", "1,2,9", or "1-5,8,12-15".
+${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}${LIGHT_SEARCH_RECOVERY}
+${TOOL_HISTORY_GUIDANCE}
+For primary ctx_reduce choices, NEVER blanket-drop a large range because mixed-value evidence may be lost: inspect every tag first. Drop only analyzed reads, searches, diagnostics, or build/test outputs after use. NEVER drop user directives or assistant prose unless exceptionally large; keep requirements, constraints, unresolved errors or decisions, exact wording, raw evidence, and active files or work. Only extracted pasted user payloads may go.
+Consider small targeted drops after acted-on reads or searches, completed logical steps, before context switches, and before the turn ends; this keeps the working set tidy without changing task scope.`;
+var BASE_INTRO_NO_REDUCE_LIGHT = (memoryEnabled) => `${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}${LIGHT_SEARCH_RECOVERY}
+${TOOL_HISTORY_GUIDANCE}`;
 var GENERIC_SECTION = `
 ### Reduction Triggers
 - After reading files or search results you already acted on — drop raw outputs.
@@ -21791,21 +21675,27 @@ var GENERIC_SECTION = `
 - Your current task requirements and constraints.
 - Recent errors and unresolved decisions.
 - Active work context and files being edited.`;
+var SMART_NOTE_GUIDANCE_LIGHT = `
+surface_condition creates a smart note checked nightly against external signals on ctx_note write.`;
 var TEMPORAL_AWARENESS_GUIDANCE = `
 **Temporal awareness**: User messages may be preceded by HTML comments like \`<!-- +12m -->\`, \`<!-- +2h 15m -->\`, or \`<!-- +3d 4h -->\` indicating time elapsed since the previous message's completion. Compartments in \`<session-history>\` carry \`start-date\` and \`end-date\` attributes (YYYY-MM-DD) showing real-time boundaries. Use these when reasoning about workflow pacing, log durations, build times, or how long ago something happened.`;
 var SUBAGENT_REDUCE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
 Use \`ctx_reduce\` to drop tool outputs you have already finished with, keeping your working context lean. Syntax: "3-5", "1,2,9", or "1-5,8,12-15". The last ${protectedTags} tags are protected.
 Drop silently — do not narrate it. NEVER drop large ranges blindly (e.g., "1-50"); review each tag first. Do not drop user or assistant text messages — only large tool outputs are worth dropping.
 Older tool calls may show \`[dropped §N§]\` sentinels; that is normal context management, not a pattern to copy. ALWAYS make fresh real tool calls when you need data again; never fabricate or inline tool output.`;
+var SUBAGENT_REDUCE_INTRO_LIGHT = (protectedTags) => `In bounded subagent sessions, the system tags messages and tool outputs as §N§; use only those IDs in ctx_reduce drop ranges such as "3-5", "1,2,9", or "1-5,8,12-15". The last ${protectedTags} tags stay protected.
+When dropping, do it silently and NEVER choose a large range before reviewing every tag; drop only finished large tool outputs, never user or assistant messages.
+If older calls show [dropped §N§], never copy that system sentinel because it is not reply syntax; make a fresh real tool call and never fabricate or inline output.`;
 var CAVEMAN_COMPRESSION_WARNING = `
 **BEWARE**: History compression is on; older user AND assistant text — including your own earlier responses — has been deterministically rewritten in a terse caveman style (dropped articles, missing auxiliaries, \`//\` instead of connectives like \`because\`). This is automatic context compression that runs after the fact, not your actual prior wording or the user's. **DO NOT mimic this style in new turns.** Write fresh responses in normal prose. If you notice your output drifting into caveman cadence, that drift is in-context-learning bleeding from the compressed history — consciously revert to full sentences.`;
-function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
+function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true, preset = "full", primaryOverride) {
   if (subagentMode) {
+    const intro = preset === "light" ? SUBAGENT_REDUCE_INTRO_LIGHT(protectedTags) : SUBAGENT_REDUCE_INTRO(protectedTags);
     return `## Magic Context
 
-${SUBAGENT_REDUCE_INTRO(protectedTags)}`;
+${intro}`;
   }
-  const smartNoteGuidance = dreamerEnabled ? `
+  const smartNoteGuidance = dreamerEnabled ? preset === "light" ? SMART_NOTE_GUIDANCE_LIGHT : `
 When \`surface_condition\` is provided with \`write\`, the note becomes a project-scoped smart note.
 The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
 Example: \`ctx_note(action="write", content="Implement X because Y", surface_condition="When PR #42 is merged in this repo")\`` : "";
@@ -21815,13 +21705,32 @@ Example: \`ctx_note(action="write", content="Implement X because Y", surface_con
   const languageGuidance = languageDirective ? `
 
 ${languageDirective}` : "";
+  if (primaryOverride !== undefined) {
+    return `${primaryOverride}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+  }
   if (!ctxReduceCallable) {
+    if (preset === "light") {
+      return `## Magic Context
+
+${LONG_TERM_PARTNER_FRAME}
+${PARTNER_FRAME_CLOSER_NO_REDUCE_LIGHT}
+
+${BASE_INTRO_NO_REDUCE_LIGHT(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+    }
     return `## Magic Context
 
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_NO_REDUCE}
 
 ${BASE_INTRO_NO_REDUCE(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+  }
+  if (preset === "light") {
+    return `## Magic Context
+
+${LONG_TERM_PARTNER_FRAME}
+${PARTNER_FRAME_CLOSER_REDUCE_LIGHT}
+
+${BASE_INTRO_LIGHT(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
   }
   return `## Magic Context
 
@@ -21842,7 +21751,7 @@ function buildMagicContextBlock(opts) {
   const includeGuidance = (opts.includeGuidance ?? true) && !existing.includes(MAGIC_CONTEXT_MARKER);
   if (!includeGuidance)
     return null;
-  return buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceCallable ?? true, opts.dreamerEnabled ?? false, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false, false, opts.language, opts.memoryEnabled !== false);
+  return buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceCallable ?? true, opts.dreamerEnabled ?? false, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false, false, opts.language, opts.memoryEnabled !== false, opts.promptSurfacePreset, opts.primaryGuidanceOverride);
 }
 var DATE_PATTERN = /Today's date: .+/;
 function processSystemPromptForCache(args) {
@@ -21870,7 +21779,7 @@ function processSystemPromptForCache(args) {
       sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
     }
   }
-  const currentHash = createHash8("md5").update(frozenPrompt).digest("hex");
+  const currentHash = createHash10("md5").update(promptSurfaceHashMaterial(frozenPrompt, args.promptSurfacePreset)).digest("hex");
   const hashChanged = !isFirstHash && currentHash !== previousHash;
   if (hashChanged) {
     sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
@@ -27539,7 +27448,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.34.1",
+  version: "0.35.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -28995,9 +28904,15 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   const projectDir = process.cwd();
   const seenDreamerProjectIdentities = new Set;
   ensureConfigLocationsMigrated(projectDir);
-  const { config, warnings, loadedFromPaths } = loadPiConfig({
+  const { config, warnings, loadedFromPaths, registrationPromptSurface } = loadPiConfig({
     cwd: projectDir
   });
+  const promptSurfaceRuntime = createPromptSurfaceRuntime({
+    harness: "pi",
+    directory: projectDir,
+    warn: (message) => warn(`config: ${message}`)
+  });
+  const promptSurfaceGuidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const projectIdentity = resolveProjectIdentityForSession(projectDir, config.allow_home_project) ?? "";
   if (projectIdentity)
     seenDreamerProjectIdentities.add(projectIdentity);
@@ -29143,7 +29058,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     dreamerEnabled: isDreamerRunnable(config),
     resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
     todowriteEnabled,
-    compactionOff
+    compactionOff,
+    promptSurface: registrationPromptSurface,
+    promptSurfaceRuntime
   });
   info(compactionOff ? todowriteEnabled ? "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, todowrite; registered /todos (ctx_reduce unavailable in compaction-off mode)" : "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand (ctx_reduce unavailable in compaction-off mode; todowrite disabled)" : todowriteEnabled ? "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, todowrite, ctx_reduce; registered /todos" : "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, ctx_reduce (todowrite disabled)");
   pi.on("session_start", async (event, ctx) => {
@@ -29449,6 +29366,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         return;
       }
       const isCacheBusting = sessionId ? hasSystemPromptRefresh(sessionId) : true;
+      const promptSurfaceModel = ctx.model;
+      const promptSurfaceModelKey = typeof promptSurfaceModel?.provider === "string" && promptSurfaceModel.provider.length > 0 && typeof promptSurfaceModel.id === "string" && promptSurfaceModel.id.length > 0 ? `${promptSurfaceModel.provider}/${promptSurfaceModel.id}` : undefined;
+      const promptSurface = sessionId ? promptSurfaceGuidanceEpochs.resolve(sessionId, effectiveConfig.prompt_surface, promptSurfaceModelKey) : promptSurfaceRuntime.resolveGuidance(effectiveConfig.prompt_surface, promptSurfaceModelKey);
       const block = buildMagicContextBlock({
         db,
         cwd: currentProject.projectDir,
@@ -29461,6 +29381,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         temporalAwarenessEnabled: effectiveConfig.temporal_awareness ?? false,
         cavemanTextCompressionEnabled: effectiveConfig.caveman_text_compression?.enabled === true,
         language: effectiveConfig.language,
+        promptSurfacePreset: promptSurface.preset,
+        primaryGuidanceOverride: promptSurface.primaryOverride,
         userMemoriesEnabled: userMemoryCollectionEnabled(effectiveConfig.dreamer),
         isCacheBusting,
         existingSystemPrompt: event.systemPrompt
@@ -29477,7 +29399,8 @@ ${block}` : event.systemPrompt;
         db,
         sessionId,
         systemPrompt: composedPrompt,
-        isCacheBusting
+        isCacheBusting,
+        promptSurfacePreset: promptSurface.preset
       });
       if (result.hashChanged) {
         signalPiHistoryRefresh(sessionId);
@@ -29691,6 +29614,7 @@ ${block}` : event.systemPrompt;
       const sessionId = typeof sm?.getSessionId === "function" ? sm.getSessionId() : undefined;
       if (typeof sessionId === "string" && sessionId.length > 0) {
         clearPiSystemPromptSession(sessionId);
+        promptSurfaceGuidanceEpochs.clear(sessionId);
         clearContextHandlerSession(sessionId);
       }
     } catch {}
@@ -29702,6 +29626,7 @@ ${block}` : event.systemPrompt;
       const outgoingSessionId = typeof sm?.getSessionId === "function" ? sm.getSessionId() : undefined;
       if (typeof outgoingSessionId === "string" && outgoingSessionId.length > 0) {
         clearPiSystemPromptSession(outgoingSessionId);
+        promptSurfaceGuidanceEpochs.clear(outgoingSessionId);
         clearContextHandlerSession(outgoingSessionId);
       }
     } catch {}