@cortexkit/pi-magic-context 0.34.0 → 0.34.2

package/dist/index.js

@@ -200,6 +200,7 @@ import {
   hasMeaningfulUserText,
   hasMemoryClassifiedAtColumn,
   hasMemoryShareableColumn,
+  hasMuralCueColumns,
   hasPiFallbackMessageTags,
   hasPiFallbackToolOwnerTags,
   incrementHistorianFailure,
@@ -269,6 +270,7 @@ import {
   recordHistorianDrainFailure,
   recordMemoryMapping,
   recordMemoryVerifications,
+  recordMuralCueRejection,
   recordOverflowDetected,
   recordProtectedTailNoEligibleHead,
   recordProtectedTailPublicationFloor,
@@ -361,7 +363,7 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-0k3j1tc3.js";
+} from "./index-fw42dv6t.js";
 import {
   pushNotification
 } from "./index-hw34xmzk.js";
@@ -443,6 +445,16 @@ var CANONICAL_DREAM_TASKS = [
   "promote-primers",
   "refresh-primers"
 ];
+function formatDreamTaskBacklogs(backlogs, tasks = CANONICAL_DREAM_TASKS) {
+  return tasks.filter((task) => backlogs[task] !== undefined).map((task) => {
+    const backlog = backlogs[task];
+    return `- ${task}: ${backlog?.pending ?? 0} pending / ${backlog?.total ?? 0} total`;
+  }).join(`
+`);
+}
+function processedDreamTaskItems(startPending, endPending) {
+  return Math.max(0, startPending - endPending);
+}
 var MEMORY_DOMAIN_TASKS = [
   "map-memories",
   "verify",
@@ -572,6 +584,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.",
@@ -580,7 +601,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(" ");
   }
@@ -3069,7 +3090,474 @@ ${sidekickText}
 </sidekick-augmentation>`;
       pi.sendUserMessage(augmentedPrompt);
     }
-  });
+  });
+}
+
+// ../plugin/src/features/magic-context/smart-notes/types.ts
+var SMART_NOTE_CHECK_POLICY_VERSION = 1;
+var SMART_NOTE_CHECK_FLOOR_MS = 5 * 60 * 1000;
+var SMART_NOTE_CHECK_CEILING_MS = 24 * 60 * 60 * 1000;
+var SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+var SMART_NOTE_CHECK_MAX_STALENESS_MS = 7 * 24 * 60 * 60 * 1000;
+var SMART_NOTE_CHECK_LIVENESS_RECHECK_MS = 24 * 60 * 60 * 1000;
+
+class SmartNoteNetworkError extends Error {
+  isSmartNoteNetworkError = true;
+  terminal;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "SmartNoteNetworkError";
+    this.terminal = options.terminal ?? false;
+  }
+}
+
+class SmartNoteSecurityError extends Error {
+  isSmartNoteSecurityError = true;
+  constructor(message) {
+    super(message);
+    this.name = "SmartNoteSecurityError";
+  }
+}
+function isSmartNoteNetworkError(error) {
+  return error instanceof SmartNoteNetworkError || error instanceof Error && (error.name === "SmartNoteNetworkError" || error.message.includes("SmartNoteNetworkError") || error.message.includes("SMART_NOTE_NETWORK"));
+}
+function isTerminalSmartNoteNetworkError(error) {
+  return error instanceof SmartNoteNetworkError && error.terminal;
+}
+function parseSmartNoteManifest(json) {
+  if (!json)
+    return { capabilities: [] };
+  try {
+    const parsed = JSON.parse(json);
+    const capabilities = Array.isArray(parsed.capabilities) ? parsed.capabilities.filter((c) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(c))) : [];
+    return {
+      capabilities,
+      readFiles: stringArray(parsed.readFiles),
+      hosts: stringArray(parsed.hosts),
+      urls: stringArray(parsed.urls),
+      signals: stringArray(parsed.signals),
+      summary: typeof parsed.summary === "string" ? parsed.summary : undefined
+    };
+  } catch {
+    return { capabilities: [] };
+  }
+}
+function stringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const arr = value.filter((item) => typeof item === "string");
+  return arr.length > 0 ? arr : undefined;
+}
+
+// ../plugin/src/features/magic-context/smart-notes/storage.ts
+function toSmartNote(note) {
+  return {
+    ...note,
+    checkStatus: note.checkStatus ?? "uncompiled",
+    checkFailureCount: note.checkFailureCount ?? 0,
+    checkNetworkFailureCount: note.checkNetworkFailureCount ?? 0,
+    policyVersion: note.policyVersion ?? 0
+  };
+}
+function commitSmartNoteState(db, args) {
+  db.exec("BEGIN IMMEDIATE");
+  let leaseLost = false;
+  let committed = false;
+  try {
+    if (args.leaseHeld && !args.leaseHeld()) {
+      leaseLost = true;
+    } else if (claimExpectedState(db, args.expected)) {
+      args.write();
+      committed = true;
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+  if (leaseLost) {
+    throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
+  }
+  if (!committed) {
+    log(`[debug] smart note #${args.expected.noteId}: discarded stale ${args.phase} result`);
+  }
+  return committed;
+}
+function claimExpectedState(db, expected) {
+  if (expected.kind === "compiled-check") {
+    return db.prepare(`UPDATE notes SET id = id
+                     WHERE id = ? AND type = 'smart' AND status = 'pending'
+                       AND check_status = 'compiled' AND compiled_check = ?
+                       AND check_hash IS ? AND check_compiled_at IS ?`).run(expected.noteId, expected.compiledCheck, expected.checkHash, expected.checkCompiledAt).changes > 0;
+  }
+  const statusClause = expected.checkStatus ? " AND check_status = ?" : "";
+  const params = [
+    expected.noteId,
+    expected.content,
+    expected.surfaceCondition,
+    expected.updatedAt
+  ];
+  if (expected.checkStatus)
+    params.push(expected.checkStatus);
+  return db.prepare(`UPDATE notes SET id = id
+                 WHERE id = ? AND type = 'smart' AND status = 'pending'
+                   AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
+}
+function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function getSmartNotesNeedingCompilation(db, projectPath, now, limit) {
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function getStaleCompiledSmartNotes(db, projectPath, now, limit) {
+  const staleBefore = now - SMART_NOTE_CHECK_MAX_STALENESS_MS;
+  const livenessBefore = now - SMART_NOTE_CHECK_LIVENESS_RECHECK_MS;
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function storeCompiledSmartNoteCheck(db, args) {
+  db.prepare(`UPDATE notes
+         SET compiled_check = ?,
+             manifest_json = ?,
+             check_hash = ?,
+             check_cron = ?,
+             check_version = 1,
+             check_status = 'compiled',
+             check_failure_count = 0,
+             check_network_failure_count = 0,
+             check_quarantined_until = NULL,
+             check_next_due_at = ?,
+             check_compiled_at = ?,
+             check_false_since_at = COALESCE(check_false_since_at, ?),
+             check_last_liveness_at = NULL,
+             policy_version = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(args.compiledCheck, JSON.stringify(args.manifest), args.checkHash, args.checkCron, args.nextDueAt, args.now, args.now, SMART_NOTE_CHECK_POLICY_VERSION, args.now, args.noteId);
+}
+function markCompiledCheckFalse(db, noteId, nextDueAt, now) {
+  db.prepare(`UPDATE notes
+         SET last_checked_at = ?,
+             updated_at = ?,
+             check_next_due_at = ?,
+             check_failure_count = 0,
+             check_network_failure_count = 0,
+             check_false_since_at = COALESCE(check_false_since_at, ?)
+         WHERE id = ? AND type = 'smart'`).run(now, now, nextDueAt, now, noteId);
+}
+function markCompiledCheckLogicFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
+  const status = failureCount >= maxFailures ? "failing" : "compiled";
+  db.prepare(`UPDATE notes
+         SET check_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+}
+function markCompiledCheckNetworkFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_network_failure_count") + 1;
+  const quarantinedUntil = now + backoffMs(failureCount);
+  const status = failureCount >= maxFailures ? "failing" : "compiled";
+  db.prepare(`UPDATE notes
+         SET check_network_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             check_quarantined_until = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, quarantinedUntil, quarantinedUntil, now, noteId);
+}
+function markSmartNoteLivenessChecked(db, noteId, now) {
+  db.prepare(`UPDATE notes
+         SET check_last_liveness_at = ?, updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(now, now, noteId);
+}
+function markSmartNoteCheckStatus(db, noteId, status, now) {
+  db.prepare(`UPDATE notes SET check_status = ?, updated_at = ? WHERE id = ? AND type = 'smart'`).run(status, now, noteId);
+}
+function markSmartNoteCompilationFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
+  const status = failureCount >= maxFailures ? "fallback" : "uncompiled";
+  db.prepare(`UPDATE notes
+         SET check_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+}
+function readFailureCount(db, noteId, column) {
+  if (column !== "check_failure_count" && column !== "check_network_failure_count")
+    return 0;
+  const row = db.prepare(`SELECT ${column} AS count FROM notes WHERE id = ?`).get(noteId);
+  return row?.count ?? 0;
+}
+function backoffMs(failureCount) {
+  const minutes = Math.min(24 * 60, 5 * 2 ** Math.max(0, failureCount - 1));
+  return minutes * 60 * 1000;
+}
+
+// ../plugin/src/features/magic-context/dreamer/storage-task-schedule.ts
+function toRow(r) {
+  return {
+    projectPath: r.project_path,
+    task: r.task,
+    lastRunAt: r.last_run_at,
+    nextDueAt: r.next_due_at,
+    schedule: r.schedule ?? null,
+    lastStatus: r.last_status ?? null,
+    lastError: r.last_error,
+    retryCount: r.retry_count ?? 0,
+    lastCheckedCommit: r.last_checked_commit ?? null,
+    lastBroadRunAt: r.last_broad_run_at ?? null,
+    retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
+  };
+}
+var SELECT_COLUMNS = "project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms";
+function getTaskScheduleState(db, projectPath, task) {
+  const row = db.prepare(`SELECT ${SELECT_COLUMNS} FROM task_schedule_state WHERE project_path = ? AND task = ?`).get(projectPath, task);
+  return row ? toRow(row) : null;
+}
+function getMostRecentTaskRunAt(db, projectPath) {
+  const row = db.prepare("SELECT MAX(last_run_at) AS max_at FROM task_schedule_state WHERE project_path = ?").get(projectPath);
+  const value = row?.max_at ?? null;
+  return typeof value === "number" && value > 0 ? value : null;
+}
+function pruneNonCanonicalTaskRows(db, projectPath, canonicalTasks) {
+  if (canonicalTasks.length === 0)
+    return 0;
+  const placeholders = canonicalTasks.map(() => "?").join(", ");
+  const result = db.prepare(`DELETE FROM task_schedule_state WHERE project_path = ? AND task NOT IN (${placeholders})`).run(projectPath, ...canonicalTasks);
+  return Number(result.changes ?? 0);
+}
+function deleteTaskScheduleRowsForProject(db, projectPath) {
+  const result = db.prepare("DELETE FROM task_schedule_state WHERE project_path = ?").run(projectPath);
+  return Number(result.changes ?? 0);
+}
+function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, schedule) {
+  db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
+}
+function writeTaskScheduleState(db, row) {
+  const broadCycleUpdate = row.lastBroadRunAt === undefined ? "last_broad_run_at = task_schedule_state.last_broad_run_at" : "last_broad_run_at = excluded.last_broad_run_at";
+  db.prepare(`INSERT INTO task_schedule_state
+           (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(project_path, task) DO UPDATE SET
+           last_run_at          = excluded.last_run_at,
+           next_due_at          = excluded.next_due_at,
+           schedule             = excluded.schedule,
+           last_status          = excluded.last_status,
+           last_error           = excluded.last_error,
+           retry_count          = excluded.retry_count,
+           last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
+           ${broadCycleUpdate},
+           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
+}
+function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
+  const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
+  return row != null;
+}
+function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
+  db.prepare("INSERT INTO retrospective_processed_windows (project_path, window_key, processed_at) VALUES (?, ?, ?) ON CONFLICT(project_path, window_key) DO NOTHING").run(projectPath, windowKey, Date.now());
+}
+
+// ../plugin/src/features/magic-context/dreamer/task-gates.ts
+function countActiveMemories(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
+  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);
+    }
+  }
 }
 
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
@@ -3971,7 +4459,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" };
@@ -3979,8 +4467,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;
@@ -3996,6 +4485,7 @@ function validateCue(cue, importance) {
 // ../plugin/src/features/magic-context/mural/compress-cues.ts
 var COMPRESS_CUES_CHUNK_SIZE = 40;
 var CHUNK_TIMEOUT_FLOOR_MS = 240000;
+var CUE_REJECTION_LATCH_THRESHOLD = 3;
 var CONSECUTIVE_TIMEOUT_LIMIT = 2;
 function toPromptMemory(candidate) {
   const memory = candidate.memory;
@@ -4006,6 +4496,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));
@@ -4059,6 +4581,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);
@@ -4173,10 +4696,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);
@@ -5154,6 +5686,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}`);
@@ -5414,64 +5947,6 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import * as https from "node:https";
 import { isIP } from "node:net";
 import { domainToASCII } from "node:url";
-
-// ../plugin/src/features/magic-context/smart-notes/types.ts
-var SMART_NOTE_CHECK_POLICY_VERSION = 1;
-var SMART_NOTE_CHECK_FLOOR_MS = 5 * 60 * 1000;
-var SMART_NOTE_CHECK_CEILING_MS = 24 * 60 * 60 * 1000;
-var SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
-var SMART_NOTE_CHECK_MAX_STALENESS_MS = 7 * 24 * 60 * 60 * 1000;
-var SMART_NOTE_CHECK_LIVENESS_RECHECK_MS = 24 * 60 * 60 * 1000;
-
-class SmartNoteNetworkError extends Error {
-  isSmartNoteNetworkError = true;
-  terminal;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "SmartNoteNetworkError";
-    this.terminal = options.terminal ?? false;
-  }
-}
-
-class SmartNoteSecurityError extends Error {
-  isSmartNoteSecurityError = true;
-  constructor(message) {
-    super(message);
-    this.name = "SmartNoteSecurityError";
-  }
-}
-function isSmartNoteNetworkError(error) {
-  return error instanceof SmartNoteNetworkError || error instanceof Error && (error.name === "SmartNoteNetworkError" || error.message.includes("SmartNoteNetworkError") || error.message.includes("SMART_NOTE_NETWORK"));
-}
-function isTerminalSmartNoteNetworkError(error) {
-  return error instanceof SmartNoteNetworkError && error.terminal;
-}
-function parseSmartNoteManifest(json) {
-  if (!json)
-    return { capabilities: [] };
-  try {
-    const parsed = JSON.parse(json);
-    const capabilities = Array.isArray(parsed.capabilities) ? parsed.capabilities.filter((c) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(c))) : [];
-    return {
-      capabilities,
-      readFiles: stringArray(parsed.readFiles),
-      hosts: stringArray(parsed.hosts),
-      urls: stringArray(parsed.urls),
-      signals: stringArray(parsed.signals),
-      summary: typeof parsed.summary === "string" ? parsed.summary : undefined
-    };
-  } catch {
-    return { capabilities: [] };
-  }
-}
-function stringArray(value) {
-  if (!Array.isArray(value))
-    return;
-  const arr = value.filter((item) => typeof item === "string");
-  return arr.length > 0 ? arr : undefined;
-}
-
-// ../plugin/src/features/magic-context/smart-notes/ssrf-guard.ts
 var DNS_TIMEOUT_MS = 3000;
 var DEFAULT_HTTP_TIMEOUT_MS = 5000;
 var DEFAULT_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
@@ -6403,205 +6878,58 @@ function literalCalls(code, method) {
   const values = [];
   for (const match of code.matchAll(regex)) {
     values.push(match[2].replace(/\\([\\"'])/g, "$1"));
-  }
-  return values;
-}
-function normalizeCron(cron) {
-  if (cron.length > MAX_CRON_CHARS)
-    throw new Error("check_cron exceeds 256 characters");
-  const normalized = cron.trim() || "0 * * * *";
-  const parsed = parseCron(normalized);
-  if (!parsed.ok)
-    throw new Error(`invalid check_cron: ${parsed.error}`);
-  const next = nextOccurrence(parsed.cron, new Date, undefined, SMART_NOTE_CHECK_CEILING_MS);
-  if (!next)
-    throw new Error("check_cron has no occurrence within the scheduling ceiling");
-  return normalized;
-}
-function unique(items) {
-  return [...new Set(items)];
-}
-function uniqueStrings(items, normalize = (value) => value) {
-  if (!Array.isArray(items))
-    return;
-  const values = unique(items.slice(0, MAX_MANIFEST_ENTRIES).filter((item) => typeof item === "string" && item.length > 0).map(normalize));
-  return values.length > 0 ? values : undefined;
-}
-function boundedError(error) {
-  return error.slice(0, MAX_COMPILER_ERROR_CHARS);
-}
-
-// ../plugin/src/features/magic-context/smart-notes/schedule.ts
-function nextSmartNoteCheckDueAt(cron, options = {}) {
-  const now = options.now ?? Date.now();
-  const floorMs = options.floorMs ?? SMART_NOTE_CHECK_FLOOR_MS;
-  const ceilingMs = options.ceilingMs ?? SMART_NOTE_CHECK_CEILING_MS;
-  const rawNext = cron?.trim() ? nextDueAtMs(cron, now, undefined, ceilingMs) : null;
-  const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
-  const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
-  const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
-  const bounded = Math.min(ceilingMs, Math.max(floorMs, jittered));
-  return now + bounded;
-}
-function deterministicJitterMs(intervalMs, noteId, hash) {
-  const max = Math.min(60000, Math.floor(intervalMs * 0.1));
-  if (max <= 0)
-    return 0;
-  const seed = `${noteId ?? 0}:${hash ?? ""}`;
-  let h = 2166136261;
-  for (let i = 0;i < seed.length; i++) {
-    h ^= seed.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  const unsigned = h >>> 0;
-  return unsigned % (max * 2 + 1) - max;
-}
-
-// ../plugin/src/features/magic-context/smart-notes/storage.ts
-function toSmartNote(note) {
-  return {
-    ...note,
-    checkStatus: note.checkStatus ?? "uncompiled",
-    checkFailureCount: note.checkFailureCount ?? 0,
-    checkNetworkFailureCount: note.checkNetworkFailureCount ?? 0,
-    policyVersion: note.policyVersion ?? 0
-  };
-}
-function commitSmartNoteState(db, args) {
-  db.exec("BEGIN IMMEDIATE");
-  let leaseLost = false;
-  let committed = false;
-  try {
-    if (args.leaseHeld && !args.leaseHeld()) {
-      leaseLost = true;
-    } else if (claimExpectedState(db, args.expected)) {
-      args.write();
-      committed = true;
-    }
-    db.exec("COMMIT");
-  } catch (error) {
-    try {
-      db.exec("ROLLBACK");
-    } catch {}
-    throw error;
-  }
-  if (leaseLost) {
-    throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
-  }
-  if (!committed) {
-    log(`[debug] smart note #${args.expected.noteId}: discarded stale ${args.phase} result`);
-  }
-  return committed;
-}
-function claimExpectedState(db, expected) {
-  if (expected.kind === "compiled-check") {
-    return db.prepare(`UPDATE notes SET id = id
-                     WHERE id = ? AND type = 'smart' AND status = 'pending'
-                       AND check_status = 'compiled' AND compiled_check = ?
-                       AND check_hash IS ? AND check_compiled_at IS ?`).run(expected.noteId, expected.compiledCheck, expected.checkHash, expected.checkCompiledAt).changes > 0;
-  }
-  const statusClause = expected.checkStatus ? " AND check_status = ?" : "";
-  const params = [
-    expected.noteId,
-    expected.content,
-    expected.surfaceCondition,
-    expected.updatedAt
-  ];
-  if (expected.checkStatus)
-    params.push(expected.checkStatus);
-  return db.prepare(`UPDATE notes SET id = id
-                 WHERE id = ? AND type = 'smart' AND status = 'pending'
-                   AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
-}
-function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function getSmartNotesNeedingCompilation(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function getStaleCompiledSmartNotes(db, projectPath, now, limit) {
-  const staleBefore = now - SMART_NOTE_CHECK_MAX_STALENESS_MS;
-  const livenessBefore = now - SMART_NOTE_CHECK_LIVENESS_RECHECK_MS;
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function storeCompiledSmartNoteCheck(db, args) {
-  db.prepare(`UPDATE notes
-         SET compiled_check = ?,
-             manifest_json = ?,
-             check_hash = ?,
-             check_cron = ?,
-             check_version = 1,
-             check_status = 'compiled',
-             check_failure_count = 0,
-             check_network_failure_count = 0,
-             check_quarantined_until = NULL,
-             check_next_due_at = ?,
-             check_compiled_at = ?,
-             check_false_since_at = COALESCE(check_false_since_at, ?),
-             check_last_liveness_at = NULL,
-             policy_version = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(args.compiledCheck, JSON.stringify(args.manifest), args.checkHash, args.checkCron, args.nextDueAt, args.now, args.now, SMART_NOTE_CHECK_POLICY_VERSION, args.now, args.noteId);
-}
-function markCompiledCheckFalse(db, noteId, nextDueAt, now) {
-  db.prepare(`UPDATE notes
-         SET last_checked_at = ?,
-             updated_at = ?,
-             check_next_due_at = ?,
-             check_failure_count = 0,
-             check_network_failure_count = 0,
-             check_false_since_at = COALESCE(check_false_since_at, ?)
-         WHERE id = ? AND type = 'smart'`).run(now, now, nextDueAt, now, noteId);
-}
-function markCompiledCheckLogicFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
-  const status = failureCount >= maxFailures ? "failing" : "compiled";
-  db.prepare(`UPDATE notes
-         SET check_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+  }
+  return values;
 }
-function markCompiledCheckNetworkFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_network_failure_count") + 1;
-  const quarantinedUntil = now + backoffMs(failureCount);
-  const status = failureCount >= maxFailures ? "failing" : "compiled";
-  db.prepare(`UPDATE notes
-         SET check_network_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             check_quarantined_until = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, quarantinedUntil, quarantinedUntil, now, noteId);
+function normalizeCron(cron) {
+  if (cron.length > MAX_CRON_CHARS)
+    throw new Error("check_cron exceeds 256 characters");
+  const normalized = cron.trim() || "0 * * * *";
+  const parsed = parseCron(normalized);
+  if (!parsed.ok)
+    throw new Error(`invalid check_cron: ${parsed.error}`);
+  const next = nextOccurrence(parsed.cron, new Date, undefined, SMART_NOTE_CHECK_CEILING_MS);
+  if (!next)
+    throw new Error("check_cron has no occurrence within the scheduling ceiling");
+  return normalized;
 }
-function markSmartNoteLivenessChecked(db, noteId, now) {
-  db.prepare(`UPDATE notes
-         SET check_last_liveness_at = ?, updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(now, now, noteId);
+function unique(items) {
+  return [...new Set(items)];
 }
-function markSmartNoteCheckStatus(db, noteId, status, now) {
-  db.prepare(`UPDATE notes SET check_status = ?, updated_at = ? WHERE id = ? AND type = 'smart'`).run(status, now, noteId);
+function uniqueStrings(items, normalize = (value) => value) {
+  if (!Array.isArray(items))
+    return;
+  const values = unique(items.slice(0, MAX_MANIFEST_ENTRIES).filter((item) => typeof item === "string" && item.length > 0).map(normalize));
+  return values.length > 0 ? values : undefined;
 }
-function markSmartNoteCompilationFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
-  const status = failureCount >= maxFailures ? "fallback" : "uncompiled";
-  db.prepare(`UPDATE notes
-         SET check_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+function boundedError(error) {
+  return error.slice(0, MAX_COMPILER_ERROR_CHARS);
 }
-function readFailureCount(db, noteId, column) {
-  if (column !== "check_failure_count" && column !== "check_network_failure_count")
-    return 0;
-  const row = db.prepare(`SELECT ${column} AS count FROM notes WHERE id = ?`).get(noteId);
-  return row?.count ?? 0;
+
+// ../plugin/src/features/magic-context/smart-notes/schedule.ts
+function nextSmartNoteCheckDueAt(cron, options = {}) {
+  const now = options.now ?? Date.now();
+  const floorMs = options.floorMs ?? SMART_NOTE_CHECK_FLOOR_MS;
+  const ceilingMs = options.ceilingMs ?? SMART_NOTE_CHECK_CEILING_MS;
+  const rawNext = cron?.trim() ? nextDueAtMs(cron, now, undefined, ceilingMs) : null;
+  const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
+  const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
+  const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
+  const bounded = Math.min(ceilingMs, Math.max(floorMs, jittered));
+  return now + bounded;
 }
-function backoffMs(failureCount) {
-  const minutes = Math.min(24 * 60, 5 * 2 ** Math.max(0, failureCount - 1));
-  return minutes * 60 * 1000;
+function deterministicJitterMs(intervalMs, noteId, hash) {
+  const max = Math.min(60000, Math.floor(intervalMs * 0.1));
+  if (max <= 0)
+    return 0;
+  const seed = `${noteId ?? 0}:${hash ?? ""}`;
+  let h = 2166136261;
+  for (let i = 0;i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  const unsigned = h >>> 0;
+  return unsigned % (max * 2 + 1) - max;
 }
 
 // ../plugin/src/features/magic-context/smart-notes/runner.ts
@@ -7337,6 +7665,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}`);
@@ -7938,6 +8267,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;
@@ -8523,69 +8853,6 @@ function insertDreamRun(db, run) {
   getInsertDreamRunStatement(db).run(run.projectPath, run.startedAt, run.finishedAt, run.holderId, JSON.stringify(run.tasks), run.tasksSucceeded, run.tasksFailed, run.smartNotesSurfaced, run.smartNotesPending, run.memoryChanges ? JSON.stringify(run.memoryChanges) : null, run.parentSessionId ?? null);
 }
 
-// ../plugin/src/features/magic-context/dreamer/storage-task-schedule.ts
-function toRow(r) {
-  return {
-    projectPath: r.project_path,
-    task: r.task,
-    lastRunAt: r.last_run_at,
-    nextDueAt: r.next_due_at,
-    schedule: r.schedule ?? null,
-    lastStatus: r.last_status ?? null,
-    lastError: r.last_error,
-    retryCount: r.retry_count ?? 0,
-    lastCheckedCommit: r.last_checked_commit ?? null,
-    lastBroadRunAt: r.last_broad_run_at ?? null,
-    retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
-  };
-}
-var SELECT_COLUMNS = "project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms";
-function getTaskScheduleState(db, projectPath, task) {
-  const row = db.prepare(`SELECT ${SELECT_COLUMNS} FROM task_schedule_state WHERE project_path = ? AND task = ?`).get(projectPath, task);
-  return row ? toRow(row) : null;
-}
-function getMostRecentTaskRunAt(db, projectPath) {
-  const row = db.prepare("SELECT MAX(last_run_at) AS max_at FROM task_schedule_state WHERE project_path = ?").get(projectPath);
-  const value = row?.max_at ?? null;
-  return typeof value === "number" && value > 0 ? value : null;
-}
-function pruneNonCanonicalTaskRows(db, projectPath, canonicalTasks) {
-  if (canonicalTasks.length === 0)
-    return 0;
-  const placeholders = canonicalTasks.map(() => "?").join(", ");
-  const result = db.prepare(`DELETE FROM task_schedule_state WHERE project_path = ? AND task NOT IN (${placeholders})`).run(projectPath, ...canonicalTasks);
-  return Number(result.changes ?? 0);
-}
-function deleteTaskScheduleRowsForProject(db, projectPath) {
-  const result = db.prepare("DELETE FROM task_schedule_state WHERE project_path = ?").run(projectPath);
-  return Number(result.changes ?? 0);
-}
-function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, schedule) {
-  db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
-}
-function writeTaskScheduleState(db, row) {
-  db.prepare(`INSERT INTO task_schedule_state
-           (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(project_path, task) DO UPDATE SET
-           last_run_at          = excluded.last_run_at,
-           next_due_at          = excluded.next_due_at,
-           schedule             = excluded.schedule,
-           last_status          = excluded.last_status,
-           last_error           = excluded.last_error,
-           retry_count          = excluded.retry_count,
-           last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
-           last_broad_run_at    = COALESCE(excluded.last_broad_run_at, task_schedule_state.last_broad_run_at),
-           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
-}
-function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
-  return row != null;
-}
-function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  db.prepare("INSERT INTO retrospective_processed_windows (project_path, window_key, processed_at) VALUES (?, ?, ?) ON CONFLICT(project_path, window_key) DO NOTHING").run(projectPath, windowKey, Date.now());
-}
-
 // ../plugin/src/features/magic-context/dreamer/verify.ts
 import { createHash as createHash5 } from "node:crypto";
 
@@ -8594,6 +8861,30 @@ import path5 from "node:path";
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
+function ensureBroadCycleStart(args) {
+  const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+  if (current?.lastBroadRunAt != null && current.lastBroadRunAt > 0) {
+    return current.lastBroadRunAt;
+  }
+  if (!current)
+    return args.runStartedAt;
+  if (!args.holderId || !args.leaseKey) {
+    throw new Error("verify-broad cycle opening requires the task lease");
+  }
+  return runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const latest = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (!latest)
+      return args.runStartedAt;
+    if (latest.lastBroadRunAt != null && latest.lastBroadRunAt > 0) {
+      return latest.lastBroadRunAt;
+    }
+    writeTaskScheduleState(args.db, {
+      ...latest,
+      lastBroadRunAt: args.runStartedAt
+    });
+    return args.runStartedAt;
+  });
+}
 async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject(args.db, args.projectIdentity);
@@ -8605,6 +8896,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,
@@ -8615,16 +8929,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,
@@ -8743,7 +9047,25 @@ function parseVerifyManifest(text) {
 
 // ../plugin/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,
@@ -8758,14 +9080,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));
@@ -8785,8 +9113,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 {
@@ -9076,6 +9407,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") {
@@ -9104,7 +9449,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,
@@ -9138,8 +9495,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" };
         }
@@ -9158,12 +9515,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 };
         }
@@ -9200,11 +9558,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 };
         }
@@ -9226,19 +9585,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;
@@ -9288,11 +9660,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 };
         }
@@ -9328,7 +9701,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}`);
@@ -9382,6 +9756,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);
     }
   };
 }
@@ -9757,66 +10133,6 @@ async function runAgenticTask(config, ctx, helpers) {
   }
 }
 
-// ../plugin/src/features/magic-context/dreamer/task-gates.ts
-function countActiveMemories(db, projectPath) {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
-  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);
-    }
-  }
-}
-
 // ../plugin/src/features/magic-context/dreamer/task-scheduler.ts
 var MAX_TASK_RETRIES = 3;
 function ensureSeeded(db, projectIdentity, config, now) {
@@ -9964,10 +10280,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 {
@@ -9976,7 +10292,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) {
@@ -9990,6 +10314,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 }));
@@ -10011,8 +10338,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);
@@ -10024,9 +10353,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) {
@@ -10341,10 +10675,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,
@@ -11014,13 +11349,18 @@ Unknown task "${requested}".`,
         });
         return;
       }
+      const backlogTasks = task ? [task] : CANONICAL_DREAM_TASKS;
+      const backlogBefore = getDreamTaskBacklogs(deps.db, project.projectIdentity, backlogTasks);
       sendCtxStatusMessage(pi, {
         title: "/ctx-dream",
         text: [
           "## /ctx-dream",
           "",
           task ? `Running dream task "${task}" for ${project.projectIdentity}…` : `Starting dream run for ${project.projectIdentity}…`,
-          `Project directory: ${project.projectDir}`
+          `Project directory: ${project.projectDir}`,
+          "",
+          "Backlog before starting:",
+          formatDreamTaskBacklogs(backlogBefore, backlogTasks)
         ].join(`
 `),
         level: "info"
@@ -11035,10 +11375,16 @@ Unknown task "${requested}".`,
           lines.push(`Ran: ${result.ran.join(", ")}`);
         if (result.failed.length > 0)
           lines.push(`Failed: ${result.failed.join(", ")}`);
+        if ((result.failureDetails?.length ?? 0) > 0) {
+          lines.push("Failure details:", ...(result.failureDetails ?? []).map((detail) => `- ${detail}`));
+        }
         if (result.skippedNoWork.length > 0)
           lines.push(`Skipped (no work): ${result.skippedNoWork.join(", ")}`);
         if (result.deferredBusy.length > 0)
           lines.push(`Busy: ${result.deferredBusy.join(", ")} — another dream task holds this domain's lease; retry in a minute`);
+        if (Object.keys(result.backlogAfter ?? {}).length > 0) {
+          lines.push("", "Backlog at run end:", formatDreamTaskBacklogs(result.backlogAfter));
+        }
         if (lines.length === 0)
           lines.push("No enabled dream tasks to run.");
         sendCtxStatusMessage(pi, {
@@ -27175,7 +27521,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,
@@ -27230,6 +27576,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`);
     }
@@ -27252,6 +27603,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) {
@@ -27326,7 +27683,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.34.0",
+  version: "0.34.2",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -27834,7 +28191,9 @@ No active Pi session is available.`,
           model: ctx.model,
           detectedContextLimit
         });
-        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit);
+        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit, {
+          backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
+        });
         const details = buildStatusDetails(currentDeps, sessionId);
         sendCtxStatusMessage(pi, { title: "/ctx-status", text: statusText, level: "info" }, details);
       } catch (error) {
@@ -27876,6 +28235,7 @@ function buildStatusDetails(deps, sessionId) {
     dreamer: {
       enabled: deps.dreamer?.runnable === true,
       scheduleSummary: deps.dreamer?.scheduleSummary ?? null,
+      backlog: getDreamTaskBacklogs(deps.db, deps.projectIdentity, CANONICAL_DREAM_TASKS),
       lastRunAt: getMostRecentTaskRunAt(deps.db, deps.projectIdentity)
     },
     historian: readHistorianState(deps.db, sessionId, meta)
@@ -28838,7 +29198,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       injectDocs: cfg.dreamer?.inject_docs !== false,
       injectionBudgetTokens: cfg.memory.injection_budget_tokens,
       temporalAwareness: cfg.temporal_awareness === true,
-      muralEnabled: cfg.experimental?.mural?.enabled === true
+      muralEnabled: cfg.mural.enabled === true
     },
     scheduler: {
       executeThresholdPercentage: cfg.execute_threshold_percentage,