@cortexkit/opencode-magic-context 0.34.0 → 0.34.2

package/dist/index.js

@@ -2,11 +2,13 @@ import {
   CANONICAL_DREAM_TASKS,
   buildDreamTaskRuntimeConfigs,
   compareTaskOrder,
+  formatDreamTaskBacklogs,
   isCanonicalDreamTask,
   leaseKeyFor,
   leaseKindFor,
+  processedDreamTaskItems,
   userMemoryCollectionEnabled
-} from "./index-56yjaeb2.js";
+} from "./index-2y0ybv5x.js";
 import {
   AGE_RECLAIM_MIN_TOKENS,
   AdmissionClass,
@@ -136,6 +138,7 @@ import {
   getDroppedTagsBySession,
   getEmbeddingCoverageStatus,
   getEmergencyInputSample,
+  getEmergencyRecoveryArmedAt,
   getHistorianFailureState,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
@@ -206,6 +209,7 @@ import {
   hasLengthCappedOutput,
   hasMemoryClassifiedAtColumn,
   hasMemoryShareableColumn,
+  hasMuralCueColumns,
   hasRunnableCompartmentWindow,
   injectM0M1,
   injectTemporalMarkers,
@@ -276,6 +280,7 @@ import {
   recordHighPressureNoEligibleHead,
   recordMemoryMapping,
   recordMemoryVerifications,
+  recordMuralCueRejection,
   recordOverflowDetected,
   recordSessionProjectIdentity,
   recordToolDefinition,
@@ -369,7 +374,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-s0mdn690.js";
+} from "./index-z70pxrq1.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -9165,9 +9170,10 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   const exp = experimental;
   const hasUM = "user_memories" in exp;
   const hasPKF = "pin_key_files" in exp;
+  const hasMural = "mural" in exp;
   const TOP_LEVEL_GRADUATED = ["temporal_awareness", "caveman_text_compression"];
   const MEMORY_GRADUATED = ["auto_search", "git_commit_indexing"];
-  const hasGraduated = TOP_LEVEL_GRADUATED.some((k) => (k in exp)) || MEMORY_GRADUATED.some((k) => (k in exp));
+  const hasGraduated = TOP_LEVEL_GRADUATED.some((k) => (k in exp)) || MEMORY_GRADUATED.some((k) => (k in exp)) || hasMural;
   if (!hasUM && !hasPKF && !hasGraduated) {
     return rawConfig;
   }
@@ -9175,6 +9181,15 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   const dreamer = typeof patched.dreamer === "object" && patched.dreamer !== null ? { ...patched.dreamer } : {};
   const memory = typeof patched.memory === "object" && patched.memory !== null ? { ...patched.memory } : {};
   const newExperimental = { ...exp };
+  const coerceToObject = (value) => {
+    if (typeof value === "boolean") {
+      return { enabled: value };
+    }
+    if (typeof value === "object" && value !== null) {
+      return { ...value };
+    }
+    return;
+  };
   const relocate = (key, dest, destLabel) => {
     if (!(key in exp))
       return;
@@ -9195,15 +9210,20 @@ function migrateLegacyExperimental(rawConfig, warnings) {
     relocate(key, patched, "");
   for (const key of MEMORY_GRADUATED)
     relocate(key, memory, "memory.");
-  const coerceToObject = (value) => {
-    if (typeof value === "boolean") {
-      return { enabled: value };
-    }
-    if (typeof value === "object" && value !== null) {
-      return { ...value };
+  if (hasMural) {
+    const oldMural = coerceToObject(exp.mural);
+    const existingMural = patched.mural;
+    if (existingMural === undefined) {
+      patched.mural = oldMural ?? exp.mural;
+      warnings.push('Deprecated "experimental.mural"; use top-level "mural" instead (migrated in memory; run `doctor` to persist).');
+    } else if (oldMural !== undefined && typeof existingMural === "object" && existingMural !== null && !Array.isArray(existingMural)) {
+      patched.mural = {
+        ...oldMural,
+        ...existingMural
+      };
     }
-    return;
-  };
+    delete newExperimental.mural;
+  }
   if (hasUM) {
     const oldUM = coerceToObject(exp.user_memories);
     if (oldUM !== undefined) {
@@ -9419,6 +9439,17 @@ function stripUnsafeProjectConfigFields(projectRaw) {
       warnings.push(`Ignoring historian.${removed.join("/")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
     }
   }
+  const mural = projectRaw.mural;
+  if (isPlainObject(mural) && "model" in mural) {
+    delete mural.model;
+    warnings.push("Ignoring mural.model from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).");
+  }
+  const experimental = projectRaw.experimental;
+  const legacyMural = isPlainObject(experimental) ? experimental.mural : undefined;
+  if (isPlainObject(legacyMural) && "model" in legacyMural) {
+    delete legacyMural.model;
+    warnings.push("Ignoring experimental.mural.model from project config (security: the mural cue-compressor model is a user-level setting; use user-level mural.model).");
+  }
   for (const agentKey of HIDDEN_AGENT_KEYS) {
     const block = projectRaw[agentKey];
     if (!isPlainObject(block))
@@ -10440,6 +10471,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.",
@@ -10448,7 +10488,7 @@ function formatFailClosedBlockingMessage(reason) {
   }
   if (reason.kind === "schema_fence") {
     return [
-      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (database schema v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
+      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
       `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
     ].join(" ");
   }
@@ -11786,6 +11826,7 @@ function createLiveSessionState() {
     deferredMaterializationSessions: new Set,
     sessionDirectoryBySession: new Map,
     recompProgressBySession: new Map,
+    dreamerProgressByProject: new Map,
     internalChildSessions: new Set
   };
 }
@@ -12817,6 +12858,7 @@ function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, sche
   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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -12828,7 +12870,7 @@ function writeTaskScheduleState(db, row) {
            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),
+           ${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) {
@@ -12956,7 +12998,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" };
@@ -12964,8 +13006,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;
@@ -12981,6 +13024,7 @@ function validateCue(cue, importance) {
 // 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;
@@ -12991,6 +13035,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));
@@ -13044,6 +13120,7 @@ async function runCompressCues(args) {
       result.skipped += outcome.skipped;
       result.remaining -= outcome.compressed;
       result.chunks += 1;
+      args.onProgress?.(result.compressed + result.skipped);
       if (outcome.failure?.class === "timeout") {
         consecutiveTimeouts += 1;
         timeoutStreakElapsedMs.push(outcome.failure.elapsedMs);
@@ -13158,10 +13235,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);
@@ -13852,6 +13938,7 @@ async function runClassify(args) {
       result.changed += counts.changed;
       result.remaining -= counts.classified;
       result.chunks += 1;
+      args.onProgress?.(result.classified);
     }
     result.complete = result.remaining === 0;
     log(`[dreamer] classify: stage=${stage} classified=${result.classified} changed=${result.changed} chunks=${result.chunks} remaining=${result.remaining} complete=${result.complete}`);
@@ -16005,6 +16092,7 @@ async function mapMemories(args) {
       result.independent += counts.independent;
       result.remaining -= counts.mapped + counts.independent;
       result.batches += 1;
+      args.onProgress?.(result.mapped + result.independent);
     }
     result.complete = result.remaining === 0;
     log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
@@ -16606,6 +16694,7 @@ async function refreshPrimers(args) {
         result.refreshed += 1;
       else
         result.skipped += 1;
+      args.onProgress?.(result.refreshed + result.skipped);
     }
     log(`[dreamer] refresh-primers: refreshed=${result.refreshed} skipped=${result.skipped}`);
     return result;
@@ -16875,6 +16964,206 @@ 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);
 }
 
+// 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);
+  return row?.cnt ?? 0;
+}
+function countUnmappedActiveMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories m
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND NOT EXISTS (
+                    SELECT 1 FROM memory_verifications v WHERE v.memory_id = m.id
+                )`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countCompartmentsSince(db, projectPath, since) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM compartments c
+               JOIN session_projects sp ON sp.session_id = c.session_id
+              WHERE sp.project_path = ? AND c.created_at > ?`).get(projectPath, since);
+  return row?.cnt ?? 0;
+}
+function countProjectSessionsSince(db, projectPath, since) {
+  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ? AND updated_at > ?").get(projectPath, since);
+  return row?.cnt ?? 0;
+}
+function countMappedMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
+               FROM memories m
+               JOIN memory_verifications v ON v.memory_id = m.id
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND v.file_path <> ''`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUnverifiedMappedMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
+               FROM memories m
+               JOIN memory_verifications v ON v.memory_id = m.id
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND v.file_path <> ''
+                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);
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories
+              WHERE project_path = ?
+                AND status IN ('active','permanent')
+                AND (mural_cue IS NULL OR mural_cue_hash IS NULL OR updated_at > mural_cue_at)`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countStalePrimers(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM primers
+              WHERE project_path = ?
+                AND status = 'active'
+                AND (answer IS NULL OR TRIM(answer) = '' OR answer_refreshed_at IS NULL
+                     OR last_observed_at > answer_refreshed_at)`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUnclassifiedActiveMemories(db, projectPath) {
+  if (!hasMemoryClassifiedAtColumn(db))
+    return countActiveMemories(db, projectPath);
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories
+              WHERE project_path = ?
+                AND status IN ('active','permanent')
+                AND classified_at IS NULL`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countPendingSmartNotes(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM notes WHERE project_path = ? AND type = 'smart' AND status = 'pending'").get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUserMemoryCandidates(db) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM user_memory_candidates").get();
+  return row?.cnt ?? 0;
+}
+function countActivePrimers(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM primers WHERE project_path = ? AND status = 'active'").get(projectPath);
+  return row?.cnt ?? 0;
+}
+function getDreamTaskBacklog(db, projectPath, task, options = {}) {
+  switch (task) {
+    case "map-memories": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countUnmappedActiveMemories(db, projectPath), total };
+    }
+    case "verify": {
+      return {
+        pending: countUnverifiedMappedMemories(db, projectPath),
+        total: countMappedMemories(db, projectPath)
+      };
+    }
+    case "verify-broad": {
+      const total = countMappedMemories(db, projectPath);
+      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);
+      return { pending: total, total };
+    }
+    case "compress-cues": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countCueCandidates(db, projectPath), total };
+    }
+    case "classify-memories": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countUnclassifiedActiveMemories(db, projectPath), total };
+    }
+    case "retrospective": {
+      const pending = countProjectSessionsSince(db, projectPath, options.retrospectiveWatermarkMs ?? null);
+      return { pending, total: pending };
+    }
+    case "maintain-docs": {
+      const total = countCompartmentsSince(db, projectPath, 0);
+      const pending = countCompartmentsSince(db, projectPath, options.lastRunAt ?? 0);
+      return { pending, total };
+    }
+    case "evaluate-smart-notes": {
+      const pending = countPendingSmartNotes(db, projectPath);
+      return { pending, total: pending };
+    }
+    case "review-user-memories": {
+      const pending = countUserMemoryCandidates(db);
+      return { pending, total: pending };
+    }
+    case "promote-primers": {
+      const pending = countPrimerCandidatesForProject(db, projectPath);
+      return { pending, total: pending };
+    }
+    case "refresh-primers": {
+      const total = countActivePrimers(db, projectPath);
+      return { pending: countStalePrimers(db, projectPath), total };
+    }
+    default: {
+      const _exhaustive = task;
+      return _exhaustive;
+    }
+  }
+}
+function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, options = {}) {
+  const result = {};
+  for (const task of tasks)
+    result[task] = getDreamTaskBacklog(db, projectPath, task, options);
+  return result;
+}
+function evaluateTaskGate(task, ctx) {
+  const { db, projectIdentity: project, lastRunAt } = ctx;
+  switch (task) {
+    case "map-memories":
+      return countUnmappedActiveMemories(db, project) > 0;
+    case "verify":
+      return countActiveMemories(db, project) > 0;
+    case "verify-broad":
+      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countActiveMemories(db, project) > 0;
+    case "curate":
+      return countActiveMemories(db, project) > 0;
+    case "compress-cues":
+      return countActiveMemories(db, project) > 0;
+    case "classify-memories":
+      return countActiveMemories(db, project) > 0;
+    case "retrospective":
+      return countProjectSessionsSince(db, project, ctx.retrospectiveWatermarkMs ?? null) > 0;
+    case "maintain-docs":
+      return countCompartmentsSince(db, project, lastRunAt ?? 0) > 0;
+    case "evaluate-smart-notes":
+      return getSmartNotesNeedingCompilation(db, project, Date.now(), 1).length > 0 || getStaleCompiledSmartNotes(db, project, Date.now(), 1).length > 0 || getPendingSmartNotes(db, project).some((note) => note.checkStatus === "fallback");
+    case "review-user-memories":
+      return getUserMemoryCandidates(db).length >= ctx.promotionThreshold;
+    case "promote-primers":
+      return countPrimerCandidatesForProject(db, project) >= (ctx.promotionThreshold ?? 2);
+    case "refresh-primers":
+      return getActivePrimers(db, project).some((primer) => !primer.answer.trim() || primer.answerRefreshedAt == null || (primer.lastObservedAt ?? 0) > primer.answerRefreshedAt);
+    default: {
+      const _exhaustive = task;
+      return Boolean(_exhaustive);
+    }
+  }
+}
+
 // src/features/magic-context/dreamer/verify.ts
 import { createHash as createHash5 } from "node:crypto";
 
@@ -16883,6 +17172,30 @@ import path4 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);
@@ -16894,6 +17207,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,
@@ -16904,16 +17240,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,
@@ -17032,7 +17358,25 @@ function parseVerifyManifest(text) {
 
 // src/features/magic-context/dreamer/verify.ts
 var VERIFY_BATCH_SIZE = 50;
+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,
@@ -17047,14 +17391,20 @@ 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));
@@ -17074,8 +17424,11 @@ async function runVerify(args) {
       result.archived += counts.archived;
       result.remaining -= counts.verified + counts.updated + counts.archived;
       result.batches += 1;
+      args.onProgress?.(result.verified + result.updated + result.archived);
     }
     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 {
@@ -17365,6 +17718,20 @@ function createDreamTaskExecutor(deps) {
     const { db, projectIdentity, holderId, leaseKey } = ctx;
     const startedAt = Date.now();
     const deadline = startedAt + config.timeoutMinutes * 60 * 1000;
+    const backlogAtStart = getDreamTaskBacklog(db, projectIdentity, config.task);
+    const reportProgress = (processed) => {
+      deps.onProgress?.({
+        task: config.task,
+        processed: Math.max(0, processed),
+        total: backlogAtStart.pending,
+        startedAt
+      });
+    };
+    reportProgress(0);
+    const incompleteMessage = (remaining) => {
+      const processed = processedDreamTaskItems(backlogAtStart.pending, remaining);
+      return `${config.task} incomplete: ${remaining} remain (was ${backlogAtStart.pending} at run start; processed ${processed} this run)`;
+    };
     const parent = await resolveParentSessionId();
     let moduleRoute;
     if (config.task === "map-memories" || config.task === "compress-cues" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
@@ -17393,7 +17760,19 @@ function createDreamTaskExecutor(deps) {
               name: config.task,
               durationMs: Date.now() - startedAt,
               resultChars: 0,
-              ...error ? { error } : {}
+              ...error ? { error } : {},
+              backlog: (() => {
+                const end = extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task);
+                const processed = processedDreamTaskItems(backlogAtStart.pending, end.pending);
+                const value = {
+                  pendingAtStart: backlogAtStart.pending,
+                  totalAtStart: backlogAtStart.total,
+                  pendingAtEnd: end.pending,
+                  totalAtEnd: end.total,
+                  processed
+                };
+                return value;
+              })()
             }
           ],
           tasksSucceeded: status === "completed" ? 1 : 0,
@@ -17427,8 +17806,8 @@ function createDreamTaskExecutor(deps) {
     }
     try {
       if (config.task === "compress-cues") {
-        if (deps.experimentalMural?.enabled !== true) {
-          log("[dreamer] compress-cues: skipped (experimental.mural is not enabled)");
+        if (deps.mural?.enabled !== true) {
+          log("[dreamer] compress-cues: skipped (mural is not enabled)");
           recordRun("completed", null);
           return { status: "completed" };
         }
@@ -17447,12 +17826,13 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
-          model: config.model ?? deps.experimentalMural.model ?? deps.dreamerModel,
-          fallbackModels: config.fallbackModels
+          model: config.model ?? deps.mural.model ?? deps.dreamerModel,
+          fallbackModels: config.fallbackModels,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] compress-cues: compressed=${result.compressed} skipped=${result.skipped} chunks=${result.chunks} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `compress-cues incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -17489,11 +17869,12 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model,
           fallbackModels: config.fallbackModels,
-          moduleRoute
+          moduleRoute,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `map-memories incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -17515,19 +17896,32 @@ function createDreamTaskExecutor(deps) {
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
-          moduleRoute
+          moduleRoute,
+          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) {
-          const error = `${config.task} incomplete: ${result.remaining} selected memories remain`;
+          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;
@@ -17577,11 +17971,12 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model,
           fallbackModels: config.fallbackModels,
-          ...moduleArgs
+          ...moduleArgs,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] classify-memories: stage=${result.stage} classified=${result.classified} changed=${result.changed} chunks=${result.chunks} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `classify-memories incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -17617,7 +18012,8 @@ function createDreamTaskExecutor(deps) {
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
-          rawProviderFactory: deps.primerRawProviderFactory
+          rawProviderFactory: deps.primerRawProviderFactory,
+          onProgress: (processed) => reportProgress(processed)
         });
         recordRun("completed", null);
         log(`[dreamer] refresh-primers: refreshed=${result.refreshed} skipped=${result.skipped}`);
@@ -17671,6 +18067,8 @@ function createDreamTaskExecutor(deps) {
       recordRun("failed", brief);
       log(`[dreamer] task ${config.task} failed (transient=${transient}): ${brief}`);
       return { status: "failed", transient, error: brief };
+    } finally {
+      deps.onProgress?.(null, config.task);
     }
   };
 }
@@ -18046,66 +18444,6 @@ async function runAgenticTask(config, ctx, helpers) {
   }
 }
 
-// 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);
-  return row?.cnt ?? 0;
-}
-function countUnmappedActiveMemories(db, projectPath) {
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM memories m
-              WHERE m.project_path = ?
-                AND m.status IN ('active','permanent')
-                AND NOT EXISTS (
-                    SELECT 1 FROM memory_verifications v WHERE v.memory_id = m.id
-                )`).get(projectPath);
-  return row?.cnt ?? 0;
-}
-function countCompartmentsSince(db, projectPath, since) {
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM compartments c
-               JOIN session_projects sp ON sp.session_id = c.session_id
-              WHERE sp.project_path = ? AND c.created_at > ?`).get(projectPath, since);
-  return row?.cnt ?? 0;
-}
-function countProjectSessionsSince(db, projectPath, since) {
-  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ? AND updated_at > ?").get(projectPath, since);
-  return row?.cnt ?? 0;
-}
-function evaluateTaskGate(task, ctx) {
-  const { db, projectIdentity: project, lastRunAt } = ctx;
-  switch (task) {
-    case "map-memories":
-      return countUnmappedActiveMemories(db, project) > 0;
-    case "verify":
-      return countActiveMemories(db, project) > 0;
-    case "verify-broad":
-      return countActiveMemories(db, project) > 0;
-    case "curate":
-      return countActiveMemories(db, project) > 0;
-    case "compress-cues":
-      return countActiveMemories(db, project) > 0;
-    case "classify-memories":
-      return countActiveMemories(db, project) > 0;
-    case "retrospective":
-      return countProjectSessionsSince(db, project, ctx.retrospectiveWatermarkMs ?? null) > 0;
-    case "maintain-docs":
-      return countCompartmentsSince(db, project, lastRunAt ?? 0) > 0;
-    case "evaluate-smart-notes":
-      return getSmartNotesNeedingCompilation(db, project, Date.now(), 1).length > 0 || getStaleCompiledSmartNotes(db, project, Date.now(), 1).length > 0 || getPendingSmartNotes(db, project).some((note) => note.checkStatus === "fallback");
-    case "review-user-memories":
-      return getUserMemoryCandidates(db).length >= ctx.promotionThreshold;
-    case "promote-primers":
-      return countPrimerCandidatesForProject(db, project) >= (ctx.promotionThreshold ?? 2);
-    case "refresh-primers":
-      return getActivePrimers(db, project).some((primer) => !primer.answer.trim() || primer.answerRefreshedAt == null || (primer.lastObservedAt ?? 0) > primer.answerRefreshedAt);
-    default: {
-      const _exhaustive = task;
-      return Boolean(_exhaustive);
-    }
-  }
-}
-
 // src/features/magic-context/dreamer/task-scheduler.ts
 var MAX_TASK_RETRIES = 3;
 function ensureSeeded(db, projectIdentity, config, now) {
@@ -18253,10 +18591,10 @@ async function runDomainGroup(deps, group, cb) {
         cb?.onRan?.(due.config.task);
       } else if (outcome.transient) {
         recordTransientFailure(db, projectIdentity, due, finishedAt, outcome.error ?? null);
-        cb?.onFailed?.(due.config.task);
+        cb?.onFailed?.(due.config.task, outcome.error);
       } else {
         advanceAfterRun(db, projectIdentity, due, finishedAt, "failed", outcome.error ?? null);
-        cb?.onFailed?.(due.config.task);
+        cb?.onFailed?.(due.config.task, outcome.error);
       }
     }
   } finally {
@@ -18265,7 +18603,15 @@ async function runDomainGroup(deps, group, cb) {
 }
 async function runManualDream(deps) {
   const now = Date.now();
-  const result = { ran: [], skippedNoWork: [], deferredBusy: [], failed: [] };
+  const result = {
+    ran: [],
+    skippedNoWork: [],
+    deferredBusy: [],
+    failed: [],
+    failureDetails: [],
+    backlogBefore: {},
+    backlogAfter: {}
+  };
   let selected;
   let forceGate = false;
   if (deps.task) {
@@ -18279,6 +18625,9 @@ async function runManualDream(deps) {
   }
   if (selected.length === 0)
     return result;
+  const selectedTaskNames = selected.map((config) => config.task);
+  result.backlogBefore = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
+  result.backlogAfter = { ...result.backlogBefore };
   for (const cfg of selected)
     ensureSeeded(deps.db, deps.projectIdentity, cfg, now);
   const dueAll = selected.map((config) => ({ config, scheduledAt: now }));
@@ -18300,8 +18649,10 @@ async function runManualDream(deps) {
     else
       result.skippedNoWork.push(d.config.task);
   }
-  if (gated.length === 0)
+  if (gated.length === 0) {
+    result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
     return result;
+  }
   const groups = new Map;
   for (const d of gated) {
     const kind = leaseKindFor(d.config.task);
@@ -18313,9 +18664,14 @@ async function runManualDream(deps) {
     forceGate,
     leaseWaitMs: MANUAL_RUN_LEASE_WAIT_MS,
     onRan: (t) => result.ran.push(t),
-    onFailed: (t) => result.failed.push(t),
+    onFailed: (task, error) => {
+      result.failed.push(task);
+      if (error)
+        result.failureDetails?.push(`${task}: ${error}`);
+    },
     onBusy: (t) => result.deferredBusy.push(t)
   })));
+  result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
   return result;
 }
 async function runDueTasksForProject(deps) {
@@ -18888,10 +19244,11 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
       ensureProjectRegistered: reg.ensureRegistered,
       language: reg.language,
       dreamerModel: dreamerConfig.model,
-      experimentalMural: reg.experimentalMural,
+      mural: reg.mural,
       memoryInjectionBudgetTokens: reg.memoryInjectionBudgetTokens,
       transformMode: reg.transformMode,
-      moduleClient: reg.moduleClient
+      moduleClient: reg.moduleClient,
+      onProgress: (progress, completedTask) => reg.onDreamerProgress?.(progress, completedTask)
     });
     const ran = await runDueTasksForProject({
       db,
@@ -20347,7 +20704,7 @@ function formatExecuteThreshold(detail, contextLimit) {
   }
   return `${percentage}%${clampNote}`;
 }
-function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit) {
+function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer) {
   const thresholdDetail = resolveExecuteThresholdDetail(executeThresholdPercentageConfig, liveModelKey, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, {
     tokensConfig: executeThresholdTokens,
     contextLimit,
@@ -20402,6 +20759,11 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       `**Protected tags:** ${protectedTags}`,
       `**Subagent session:** ${meta.isSubagent}`
     ];
+    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
+      lines.push("", "### Dreamer", ...dreamer.progress ? [
+        `- Running: ${dreamer.progress.task} — ${dreamer.progress.processed}/${dreamer.progress.total} processed`
+      ] : [], ...formatDreamTaskBacklogs(dreamer.backlog).split("\\n"));
+    }
     if (meta.lastContextPercentage > 0 || meta.lastInputTokens > 0) {
       lines.push("", "### Context Usage", `- Last percentage: ${meta.lastContextPercentage.toFixed(1)}%`, `- Last input tokens: ${meta.lastInputTokens.toLocaleString()}`, `- Resolved context limit: ${displayContextLimit > 0 ? displayContextLimit.toLocaleString() : "unknown"}`, `- Proactive compartment evaluation: ${proactiveCompartmentTrigger}%`, `- Post-drop target for historian: ${(executeThresholdPercentage * POST_DROP_TARGET_RATIO).toFixed(0)}% (${executeThresholdPercentage}% * ${POST_DROP_TARGET_RATIO})`, `- Commit cluster trigger: ${commitClusterTrigger?.enabled !== false ? `enabled (min ${commitClusterTrigger?.min_clusters ?? 3} clusters)` : "disabled"}, tail-size trigger: > 3x compartment budget`);
     }
@@ -20424,6 +20786,12 @@ ${c.content}
         lines.push(`- §${op.tagId}§ → ${op.operation}`);
       }
     }
+    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
+      lines.push("", "### Dreamer Backlog", formatDreamTaskBacklogs(dreamer.backlog));
+    }
+    if (dreamer?.progress) {
+      lines.push("", "### Dreamer Progress", `- ${dreamer.progress.task}: ${dreamer.progress.processed}/${dreamer.progress.total} processed this run`);
+    }
     return lines.join(`
 `);
   } catch (error) {
@@ -20659,16 +21027,32 @@ ${sidekickResult}
   await sendUserPrompt(deps.sidekick.client, sessionId, augmentedPrompt);
   throwSentinel("CTX-AUG");
 }
+function readDreamTaskBacklogsSafely(db, projectPath, tasks) {
+  try {
+    return getDreamTaskBacklogs(db, projectPath, tasks);
+  } catch {
+    return {};
+  }
+}
 function summarizeManualDream(s) {
   const lines = ["## /ctx-dream", ""];
   if (s.ran.length > 0)
     lines.push(`Ran: ${s.ran.join(", ")}`);
   if (s.failed.length > 0)
     lines.push(`Failed: ${s.failed.join(", ")}`);
+  if ((s.failureDetails?.length ?? 0) > 0) {
+    lines.push("Failure details:", ...(s.failureDetails ?? []).map((detail) => `- ${detail}`));
+  }
   if (s.skippedNoWork.length > 0)
     lines.push(`Skipped (no work): ${s.skippedNoWork.join(", ")}`);
   if (s.deferredBusy.length > 0)
     lines.push(`Busy: ${s.deferredBusy.join(", ")} — another dream task holds this domain's lease; retry in a minute`);
+  if (Object.keys(s.backlogBefore ?? {}).length > 0) {
+    lines.push("", "Backlog at run start:", formatDreamTaskBacklogs(s.backlogBefore ?? {}));
+  }
+  if (Object.keys(s.backlogAfter ?? {}).length > 0) {
+    lines.push("", "Backlog at run end:", formatDreamTaskBacklogs(s.backlogAfter ?? {}));
+  }
   if (s.ran.length === 0 && s.failed.length === 0 && s.skippedNoWork.length === 0 && s.deferredBusy.length === 0) {
     lines.push("No enabled dream tasks to run.");
   }
@@ -20696,7 +21080,17 @@ Unknown task "${requested}". Valid tasks: ${CANONICAL_DREAM_TASKS.join(", ")}.`,
     }
     task = requested;
   }
-  await deps.sendNotification(sessionId, task ? `Running dream task "${task}"...` : "Starting dream run...", dreamNotificationParams);
+  const backlogTasks = task ? [task] : CANONICAL_DREAM_TASKS;
+  const backlogBefore = readDreamTaskBacklogsSafely(deps.db, deps.dreamer.projectPath, backlogTasks);
+  await deps.sendNotification(sessionId, [
+    "## /ctx-dream",
+    "",
+    task ? `Running dream task "${task}"...` : "Starting dream run...",
+    "",
+    "Backlog before starting:",
+    formatDreamTaskBacklogs(backlogBefore, backlogTasks)
+  ].join(`
+`), dreamNotificationParams);
   const summary = await deps.dreamer.runManual(task);
   await deps.sendNotification(sessionId, summarizeManualDream(summary), dreamNotificationParams);
   throwSentinel("CTX-DREAM");
@@ -20834,7 +21228,10 @@ Embedding status is unavailable.`;
         }
         const liveModelKey = deps.getLiveModelKey?.(sessionId);
         const liveContextLimit = deps.getContextLimit?.(sessionId);
-        const statusOutput = executeStatus(deps.db, sessionId, deps.protectedTags, deps.executeThresholdPercentage, liveModelKey, deps.historyBudgetPercentage, deps.commitClusterTrigger, deps.executeThresholdTokens, liveContextLimit);
+        const statusOutput = executeStatus(deps.db, sessionId, deps.protectedTags, deps.executeThresholdPercentage, liveModelKey, deps.historyBudgetPercentage, deps.commitClusterTrigger, deps.executeThresholdTokens, liveContextLimit, deps.dreamer ? {
+          backlog: readDreamTaskBacklogsSafely(deps.db, deps.dreamer.projectPath, CANONICAL_DREAM_TASKS),
+          progress: deps.getDreamerProgress?.() ?? null
+        } : undefined);
         const moduleStatus = rustStatus ? `
 
 ${formatRustStatusText(rustStatus)}` : "";
@@ -24858,7 +25255,8 @@ function loadContextUsage(contextUsageMap, db, sessionId) {
     if (persisted) {
       contextUsageMap.set(sessionId, {
         ...persisted,
-        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt
+        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt,
+        hasUsageTokens: false
       });
       return persisted.usage;
     }
@@ -29347,6 +29745,19 @@ function passUsage(usage, limit) {
     context_limit_tokens: limit
   };
 }
+function shouldDisarmRustEmergencyRecovery(input) {
+  if (input.finalWireEstimate?.trusted === true && input.providerProvenLimitTokens > 0 && input.finalWireEstimate.tokens < input.providerProvenLimitTokens * 0.8) {
+    return "trusted-final-wire";
+  }
+  if (!input.materialized || input.usagePercentage >= 80)
+    return null;
+  if (input.recoveryOrigin !== "provider_overflow")
+    return "fresh-usage";
+  if (input.usageEntry?.hasUsageTokens === true && (input.recoveryArmedAt === null || input.usageEntry.updatedAt > input.recoveryArmedAt)) {
+    return "fresh-usage";
+  }
+  return null;
+}
 function directiveTextOf(response) {
   const directives = isRecord3(response.host_directives) ? response.host_directives : undefined;
   const channel2 = isRecord3(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
@@ -29826,6 +30237,7 @@ function createRustModeTransform(deps, options) {
       }
     }
     const reduceAvailability = resolveCtxReduceAvailability(sessionId);
+    resolveTodowriteAvailabilityFromMessages(sessionId, messages);
     const toolPresent = reduceAvailability.frozen && reduceAvailability.callable;
     try {
       if (preflightError)
@@ -30085,6 +30497,7 @@ function createRustModeTransform(deps, options) {
       const pages = buildPagedModuleTransformPayloads(body);
       logStage(sessionId, "wireBuild", wireBuildStartedAt, timings, wireDelta ? `mode=tail_delta input=${encodedInput.length}` : "mode=full");
       let response;
+      let servedFinalWireEstimate;
       for (const [index, page] of pages.entries()) {
         timings.transportBytes += Buffer.byteLength(JSON.stringify(page));
         const transportStartedAt = performance.now();
@@ -30232,6 +30645,15 @@ function createRustModeTransform(deps, options) {
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
           assertNativeBoundary(appliedMessages, sessionId, boundaryId);
         }
+        if (passInputs.emergency_recovery_armed === true) {
+          servedFinalWireEstimate = estimateFinalWireInputTokens({
+            messages: appliedMessages,
+            systemPromptTokens: sessionMeta.systemPromptTokens,
+            providerID: model?.providerID,
+            modelID: model?.modelID,
+            agentName: deps.getNotificationParams?.(sessionId)?.agent
+          });
+        }
         logStage(sessionId, "apply", applyStartedAt, timings);
         const lkgSnapshotStartedAt = performance.now();
         const explicitDecision = typeof response.decision === "string" || typeof response.action === "string" || typeof response.cache_bust === "boolean";
@@ -30320,10 +30742,20 @@ function createRustModeTransform(deps, options) {
           sessionLog(sessionId, "rust compartment mirror-back failed (ignored):", error);
         }
       }
-      if (materializeReason !== "none" && passUsageSnapshot.percentage < 80 && getOverflowState(deps.db, sessionId).needsEmergencyRecovery) {
+      const currentOverflowState = getOverflowState(deps.db, sessionId, modelKey);
+      const disarmEvidence = currentOverflowState.needsEmergencyRecovery ? shouldDisarmRustEmergencyRecovery({
+        materialized: materializeReason !== "none",
+        usagePercentage: passUsageSnapshot.percentage,
+        recoveryOrigin: currentOverflowState.emergencyRecoveryOrigin,
+        recoveryArmedAt: getEmergencyRecoveryArmedAt(sessionId),
+        usageEntry: deps.contextUsageMap.get(sessionId),
+        finalWireEstimate: servedFinalWireEstimate,
+        providerProvenLimitTokens: currentOverflowState.detectedContextLimit
+      }) : null;
+      if (disarmEvidence) {
         try {
           clearEmergencyRecovery(deps.db, sessionId);
-          sessionLog(sessionId, `rust pass disarmed emergency recovery after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
+          sessionLog(sessionId, `rust pass disarmed emergency recovery via ${disarmEvidence} after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
         } catch {}
       }
       wireCaches.set(sessionId, pendingWireCache);
@@ -31411,7 +31843,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         historyBudgetTokens,
         temporalAwareness: deps.experimentalTemporalAwareness,
         hardSignals: m0HardSignals,
-        muralEnabled: deps.experimentalMuralEnabled
+        muralEnabled: deps.muralEnabled
       }
     });
     passOutcome.markFinalized();
@@ -31891,7 +32323,8 @@ function createEventHandler2(deps) {
               inputTokens: totalInputTokens
             },
             updatedAt: now,
-            lastResponseTime: now
+            lastResponseTime: now,
+            hasUsageTokens: true
           });
           updates.lastContextPercentage = percentage;
           updates.lastInputTokens = totalInputTokens;
@@ -33083,11 +33516,13 @@ function createMagicContextHook(deps) {
       const fence = getSchemaFenceRejection();
       recordHookInitFailure({
         type: "storage",
-        reason: migration && blockingProcesses.length > 0 ? {
+        reason: migration && (blockingProcesses.length > 0 || migration.unreadableFile) ? {
           kind: "migration_guard",
           persistedVersion: migration.persistedVersion,
           supportedVersion: migration.supportedVersion,
-          blockingProcesses
+          blockingProcesses,
+          ...migration.unreadableFile ? { unreadableFile: migration.unreadableFile } : {},
+          ...migration.unreadableArm ? { unreadableArm: migration.unreadableArm } : {}
         } : fence ? {
           kind: "schema_fence",
           persistedVersion: fence.persistedVersion,
@@ -33152,6 +33587,7 @@ function createMagicContextHook(deps) {
   const sessionDirectoryBySession = deps.liveSessionState?.sessionDirectoryBySession ?? new Map;
   const internalChildSessions = deps.liveSessionState?.internalChildSessions ?? new Set;
   const recompProgressBySession = deps.liveSessionState?.recompProgressBySession ?? new Map;
+  const dreamerProgressByProject = deps.liveSessionState?.dreamerProgressByProject ?? new Map;
   const channel1StateBySession = new Map;
   const channel2DirectiveTextBySession = new Map;
   const resolveLiveModel = (sessionId) => {
@@ -33192,6 +33628,7 @@ function createMagicContextHook(deps) {
       deferredMaterializationSessions,
       sessionDirectoryBySession,
       recompProgressBySession,
+      dreamerProgressByProject,
       internalChildSessions
     },
     directory: deps.directory,
@@ -33602,7 +34039,7 @@ function createMagicContextHook(deps) {
     compactionOff,
     experimentalUserMemories: userMemoryCollectionEnabled(dreamerConfig),
     experimentalTemporalAwareness: deps.config.temporal_awareness === true,
-    experimentalMuralEnabled: deps.config.experimental?.mural?.enabled === true,
+    muralEnabled: deps.config.mural?.enabled === true,
     historianTwoPass: deps.config.historian?.two_pass === true,
     liveModelBySession,
     sessionDirectoryBySession,
@@ -33696,7 +34133,14 @@ function createMagicContextHook(deps) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreaming),
       language: deps.config.language,
       transformMode: deps.config.transform_mode,
-      moduleClient: rustModeModuleClient
+      moduleClient: rustModeModuleClient,
+      onProgress: (progress, completedTask) => {
+        if (progress) {
+          dreamerProgressByProject.set(projectPath, progress);
+        } else if (dreamerProgressByProject.get(projectPath)?.task === completedTask) {
+          dreamerProgressByProject.delete(projectPath);
+        }
+      }
     });
     runDueTasksForProject({
       db,
@@ -33723,6 +34167,7 @@ function createMagicContextHook(deps) {
       const model = resolveLiveModel(sessionId);
       return model ? `${model.providerID}/${model.modelID}` : undefined;
     },
+    getDreamerProgress: () => dreamerProgressByProject.get(projectPath) ?? null,
     getContextLimit: (sessionId) => {
       const model = resolveLiveModel(sessionId);
       if (!model)
@@ -33770,10 +34215,17 @@ function createMagicContextHook(deps) {
           }),
           userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreamerConfig),
           language: deps.config.language,
-          experimentalMural: deps.config.experimental?.mural,
+          mural: deps.config.mural,
           memoryInjectionBudgetTokens: deps.config.memory?.injection_budget_tokens,
           transformMode: deps.config.transform_mode,
-          moduleClient: rustModeModuleClient
+          moduleClient: rustModeModuleClient,
+          onProgress: (progress, completedTask) => {
+            if (progress) {
+              dreamerProgressByProject.set(projectPath, progress);
+            } else if (dreamerProgressByProject.get(projectPath)?.task === completedTask) {
+              dreamerProgressByProject.delete(projectPath);
+            }
+          }
         }),
         task
       })
@@ -34385,6 +34837,13 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const docsTokens = m0Blocks.docsTokens;
     const profileTokens = m0Blocks.profileTokens;
     let lastDreamerRunAt = null;
+    let dreamerBacklog;
+    const dreamerProgress = projectIdentity ? liveSessionState?.dreamerProgressByProject?.get(projectIdentity) ?? null : null;
+    if (projectIdentity) {
+      try {
+        dreamerBacklog = getDreamTaskBacklogs(db, projectIdentity, CANONICAL_DREAM_TASKS);
+      } catch {}
+    }
     if (projectIdentity) {
       try {
         lastDreamerRunAt = getMostRecentTaskRunAt(db, projectIdentity);
@@ -34480,6 +34939,8 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       lastTransformError: meta?.last_transform_error ? String(meta.last_transform_error) : null,
       lastDreamerRunAt,
       projectIdentity,
+      dreamerBacklog,
+      dreamerProgress,
       compartmentTokens: calibrated.compartmentTokens,
       factTokens: calibrated.factTokens,
       memoryTokens: calibrated.memoryTokens,
@@ -34721,7 +35182,7 @@ function registerRpcHandlers(rpcServer, args) {
   const buildManagedCtx = async (db) => {
     const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-9crp0cvd.js");
     const { resolveFallbackChain: resolveFallbackChain2 } = await import("./resolve-fallbacks-5n5tvge1.js");
-    const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-5nx3qfz8.js");
+    const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-gbp7r23g.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
     return {
       client: args.client,
@@ -34746,7 +35207,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-8e82vmvb.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-6cd3nrt7.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -34762,7 +35223,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-8e82vmvb.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-6cd3nrt7.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -37014,13 +37475,20 @@ var server = async (ctx) => {
         embeddingConfig: pluginConfig.embedding,
         memoryEnabled: pluginConfig.memory?.enabled === true,
         memoryInjectionBudgetTokens: pluginConfig.memory?.injection_budget_tokens,
-        experimentalMural: pluginConfig.experimental?.mural,
+        mural: pluginConfig.mural,
         gitCommitIndexing: pluginConfig.memory.git_commit_indexing?.enabled ? {
           enabled: true,
           since_days: pluginConfig.memory.git_commit_indexing.since_days,
           max_commits: pluginConfig.memory.git_commit_indexing.max_commits
         } : undefined,
         ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+        onDreamerProgress: (progress, completedTask) => {
+          if (progress) {
+            liveSessionState.dreamerProgressByProject.set(timerProjectIdentity, progress);
+          } else if (liveSessionState.dreamerProgressByProject.get(timerProjectIdentity)?.task === completedTask) {
+            liveSessionState.dreamerProgressByProject.delete(timerProjectIdentity);
+          }
+        },
         moduleClient: classifyModuleClient
       };
       try {