@cortexkit/opencode-magic-context 0.34.0 → 0.34.1

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,
@@ -206,6 +208,7 @@ import {
   hasLengthCappedOutput,
   hasMemoryClassifiedAtColumn,
   hasMemoryShareableColumn,
+  hasMuralCueColumns,
   hasRunnableCompartmentWindow,
   injectM0M1,
   injectTemporalMarkers,
@@ -369,7 +372,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-s0mdn690.js";
+} from "./index-x8spt5wy.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -9165,9 +9168,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 +9179,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 +9208,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 +9437,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))
@@ -10448,7 +10477,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 +11815,7 @@ function createLiveSessionState() {
     deferredMaterializationSessions: new Set,
     sessionDirectoryBySession: new Map,
     recompProgressBySession: new Map,
+    dreamerProgressByProject: new Map,
     internalChildSessions: new Set
   };
 }
@@ -13044,6 +13074,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);
@@ -13852,6 +13883,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 +16037,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 +16639,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 +16909,191 @@ 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 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);
+      return { pending: total, 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 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";
 
@@ -17074,6 +17293,7 @@ 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;
     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}`);
@@ -17365,6 +17585,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 +17627,19 @@ function createDreamTaskExecutor(deps) {
               name: config.task,
               durationMs: Date.now() - startedAt,
               resultChars: 0,
-              ...error ? { error } : {}
+              ...error ? { error } : {},
+              backlog: (() => {
+                const end = 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 +17673,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 +17693,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 +17736,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,10 +17763,11 @@ function createDreamTaskExecutor(deps) {
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
-          moduleRoute
+          moduleRoute,
+          onProgress: (processed) => reportProgress(processed)
         });
         if (!result.complete) {
-          const error = `${config.task} incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
             memoryChanges: computeMemoryDelta(memoryBefore)
           });
@@ -17577,11 +17826,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 +17867,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 +17922,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 +18299,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 +18446,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 +18458,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 +18480,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 +18504,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 +18519,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 +19099,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 +20559,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 +20614,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 +20641,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 +20882,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 +20935,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 +21083,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)}` : "";
@@ -31411,7 +31663,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         historyBudgetTokens,
         temporalAwareness: deps.experimentalTemporalAwareness,
         hardSignals: m0HardSignals,
-        muralEnabled: deps.experimentalMuralEnabled
+        muralEnabled: deps.muralEnabled
       }
     });
     passOutcome.markFinalized();
@@ -33152,6 +33404,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 +33445,7 @@ function createMagicContextHook(deps) {
       deferredMaterializationSessions,
       sessionDirectoryBySession,
       recompProgressBySession,
+      dreamerProgressByProject,
       internalChildSessions
     },
     directory: deps.directory,
@@ -33602,7 +33856,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 +33950,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 +33984,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 +34032,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 +34654,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 +34756,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 +34999,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 +35024,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-k72ejkkh.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 +35040,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-k72ejkkh.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 +37292,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 {