mixdog 0.9.174 → 1.0.0

package/src/runtime/media/adapters/xai-media.mjs

@@ -6,6 +6,7 @@
  * poll route answers 202 while pending, 200 with a signed URL when done.
  */
 import { resolveXaiAuth } from '../auth.mjs';
+import { boundedSignal, timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media, downloadPublicMedia } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
@@ -18,11 +19,6 @@ const IMAGE_TIMEOUT_MS = 180_000;
 // loop from ever reaching its deadline check.
 const POLL_REQUEST_TIMEOUT_MS = 60_000;
 
-function boundedSignal(signal, deadline, capMs) {
-  const remaining = Math.max(1, deadline - Date.now());
-  return AbortSignal.any([signal, AbortSignal.timeout(Math.min(capMs, remaining))].filter(Boolean));
-}
-
 async function readError(res) {
   const text = await res.text().catch(() => '');
   return text.slice(0, 400);
@@ -66,7 +62,7 @@ export async function generateImage({ lane, model, prompt, options = {}, referen
     method: 'POST',
     headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
     body: JSON.stringify(body),
-    signal: AbortSignal.any([signal, AbortSignal.timeout(IMAGE_TIMEOUT_MS)].filter(Boolean)),
+    signal: timeoutSignal(signal, IMAGE_TIMEOUT_MS),
   });
   if (!res.ok) throw upstreamError('xAI image', res.status, await readError(res));
   const data = await res.json();
@@ -97,7 +93,7 @@ export async function generateVideo({ lane, model, prompt, options = {}, referen
     method: 'POST',
     headers,
     body: JSON.stringify(body),
-    signal: AbortSignal.any([signal, AbortSignal.timeout(START_TIMEOUT_MS)].filter(Boolean)),
+    signal: timeoutSignal(signal, START_TIMEOUT_MS),
   });
   if (!started.ok) throw upstreamError('xAI video', started.status, await readError(started));
   const startData = await started.json();

package/src/runtime/media/bounded-signal.mjs

@@ -0,0 +1,13 @@
+/** The caller's signal (when any) combined with a timeout of `ms`. */
+export function timeoutSignal(signal, ms) {
+  return AbortSignal.any([signal, AbortSignal.timeout(ms)].filter(Boolean));
+}
+
+/**
+ * Abort signal for one request inside a polling job: the caller's signal, plus
+ * a timeout of `capMs` clamped so the request never outlives the job deadline.
+ */
+export function boundedSignal(signal, deadline, capMs) {
+  const remaining = Math.max(1, deadline - Date.now());
+  return timeoutSignal(signal, Math.min(capMs, remaining));
+}

package/src/runtime/media/store.mjs

@@ -269,8 +269,9 @@ function rememberDuration(entry, durationSeconds) {
   mutateIndex((assets) => {
     const row = assets.find((item) => item.id === entry.id);
     if (!row || row.durationSeconds === durationSeconds) return null;
-    row.durationSeconds = durationSeconds;
-    return assets;
+    // Copy the row: the cached array is only replaced after the write succeeds.
+    // Copy the row: the cached array is only replaced after the write succeeds.
+    return assets.map((item) => (item === row ? { ...row, durationSeconds } : item));
   });
   entry.durationSeconds = durationSeconds;
 }
@@ -468,7 +469,12 @@ export function deleteMediaAssets({ ids, kind = null, before, missing = false, a
     }
     return true;
   };
-  if (dryRun) return { ids: readIndex().filter(matches).map((entry) => entry.id) };
+  if (dryRun)
+    return {
+      ids: readIndex()
+        .filter(matches)
+        .map((entry) => entry.id),
+    };
   let removed = [];
   mutateIndex((assets) => {
     const doomed = assets.filter(matches);

package/src/runtime/memory/data/runtime-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "generated_at": "2026-09-21T10:56:02.274Z",
+  "generated_at": "2026-09-29T21:03:55.028Z",
   "release_tag": "runtime-v0.4.1",
   "pg": {
     "major": 16,
@@ -12,28 +12,28 @@
   "assets": {
     "darwin-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.1/mixdog-runtime-darwin-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "22169fca882e631fcfd6c76e18df7fb67847065b9910bae53e218caeb3a5c713",
-      "size": 23430087
+      "sha256": "fc32456c841b3b48444c11c5e7c7175fd25119b90058bb98f38a43fc9c73e0e1",
+      "size": 23429982
     },
     "darwin-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.1/mixdog-runtime-darwin-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "51fdafa57972de495d09001f5f0b6fca174bbe26d3ffbc719371310dc667a09e",
-      "size": 23713034
+      "sha256": "15e36fc986772cb048ee96ed0f8292217b6d8b3ae13b6ed6083c31459a10233e",
+      "size": 23713039
     },
     "linux-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.1/mixdog-runtime-linux-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "64707d41d823093bcd35cdf4fafa473bf118a228d3be516673fe2f5ba45d9e3c",
-      "size": 22914202
+      "sha256": "942c0ae30e6c0ba4f3a54fc43eb33918cd0e87f758784e8d21679d50a76a7a52",
+      "size": 22913680
     },
     "linux-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.1/mixdog-runtime-linux-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "3e3b7c37b0fc6260e518890b4b1c2303c1485eb911a5af4d1ff11f85a1a50b8f",
-      "size": 23308864
+      "sha256": "2a8bf2a2e64e91c5964d783b6aee3d064eee7df14b94a2f05bf8eb519d11b310",
+      "size": 23309220
     },
     "win32-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.1/mixdog-runtime-win32-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "32f0890a52bb28cefa2f8d716c0a1aa889f329bd79be96fff466205343be7686",
-      "size": 22885595
+      "sha256": "4f66bf83fcd9ba6e9cf4d843437ea2c605f7952cc0b499896b99e1ef9eefac4c",
+      "size": 22885626
     }
   }
 }

package/src/runtime/memory/index.mjs

@@ -24,9 +24,7 @@ import { readPluginVersion, readMemoryCodeFingerprint } from './lib/memory-finge
 const PLUGIN_VERSION = readPluginVersion(PLUGIN_ROOT);
 const BOOT_MEMORY_CODE_FINGERPRINT = readMemoryCodeFingerprint(PLUGIN_ROOT);
 
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
 import { TOOL_DEFS } from './tool-defs.mjs';
 
@@ -336,16 +334,10 @@ async function getCycleLastRun() {
     return {
       cycle1: Number(obj.cycle1) || 0,
       cycle2: Number(obj.cycle2) || 0,
-      // Phase B §2.4 auto-restart book-keeping — last time an overdue cycle1
-      // triggered an unscheduled run, rate-limited separately from the
-      // normal cycle timestamp so a long chain of failures cannot tight-loop.
-      cycle1_autoRestart: Number(obj.cycle1_autoRestart) || 0,
-      // #13/#14: heartbeat (every attempt, success or skip) and the auto-
-      // restart attempt timestamp (committed BEFORE the call) are tracked
-      // separately from the success timestamps above so a long string of
-      // failed/skipped runs cannot disguise itself as a healthy keeper.
+      // Heartbeat (every attempt, success or skip) is tracked separately from
+      // the success timestamps above so a long string of failed/skipped runs
+      // cannot disguise itself as a healthy keeper.
       cycle1_heartbeat: Number(obj.cycle1_heartbeat) || 0,
-      cycle1_autoRestart_attempt: Number(obj.cycle1_autoRestart_attempt) || 0,
       // Last cycle2 failure message; cleared to '' on success.
       cycle2_last_error: typeof obj.cycle2_last_error === 'string' ? obj.cycle2_last_error : '',
     };
@@ -353,9 +345,7 @@ async function getCycleLastRun() {
     return {
       cycle1: 0,
       cycle2: 0,
-      cycle1_autoRestart: 0,
       cycle1_heartbeat: 0,
-      cycle1_autoRestart_attempt: 0,
       cycle2_last_error: '',
     };
   }
@@ -528,13 +518,6 @@ const _actionHandlers = createMemoryActionHandlers({
 });
 const { handleMemoryAction, handleToolCall } = _actionHandlers;
 
-const mcp = new Server(
-  { name: 'mixdog-memory', version: PLUGIN_VERSION },
-  { capabilities: { tools: {} }, instructions: MEMORY_INSTRUCTIONS_TEXT }
-);
-mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_DEFS }));
-mcp.setRequestHandler(CallToolRequestSchema, (req) => handleToolCall(req.params.name, req.params.arguments ?? {}));
-
 // The facade owns the http.Server + listen/stop lifecycle; the router builds the request
 // handler and buildSessionCoreMemoryPayload from injected live state.
 const _httpRouter = createHttpRouter({
@@ -567,6 +550,8 @@ const _httpRouter = createHttpRouter({
   refreshCoreMemoryFile: refreshCoreMemorySnapshot,
 });
 const buildSessionCoreMemoryPayload = _httpRouter.buildSessionCoreMemoryPayload;
+// Standalone stdio MCP server: the same tool surface the /mcp route serves.
+const mcp = _httpRouter.createHttpMcpServer();
 const httpServer = http.createServer(_httpRouter.requestHandler);
 const _httpListener = createLoopbackListener({
   server: httpServer,
@@ -618,7 +603,7 @@ export async function appendEntry(data = {}) {
   const sourceRef = String(data.sourceRef ?? `manual:${Date.now()}-${process.pid}`);
   const sessionId = data.sessionId ?? null;
   const tsMs = parseTsToMs(data.ts ?? Date.now());
-  const projectId = resolveProjectScope(typeof data.cwd === 'string' && data.cwd ? data.cwd : null);
+  const projectId = resolveProjectScope(data.cwd);
   const result = await db.query(
     `
     INSERT INTO entries(ts, role, content, source_ref, session_id, project_id)

package/src/runtime/memory/lib/core-memory-file.mjs

@@ -137,7 +137,7 @@ export async function refreshCoreMemoryFile(db, dataDir) {
 export function readSessionCoreMemoryPayload(dataDir, cwd) {
   const file = readCoreMemoryFile(dataDir);
   if (!file) return null;
-  const projectId = resolveProjectScope(typeof cwd === 'string' && cwd ? cwd : null);
+  const projectId = resolveProjectScope(cwd);
   const inScope = (entry) => entry.projectId === null || entry.projectId === projectId;
   const curated = file.curated.filter(inScope).sort((a, b) => {
     if (a.projectId === null && b.projectId !== null) return -1;

package/src/runtime/memory/lib/cycle-scheduler/backlog-probe.mjs

@@ -1,4 +1,5 @@
-const CYCLE1_OMITTED_COOLDOWN_MS = 60 * 60 * 1000;
+import { CYCLE1_OMITTED_COOLDOWN_MS } from '../cycle1/cycle1-plan.mjs';
+
 const BACKLOG_WARN_PENDING = 500;
 
 async function countRows(db, sql, params) {

package/src/runtime/memory/lib/cycle1/cycle1-plan.mjs

@@ -2,7 +2,7 @@
 // The bounds one cycle1 run works within, resolved once from the flat config,
 // the nested cycle1 wrap shape and the caller's options.
 import { CYCLE1_INPUT_TOKEN_BUDGET } from '../memory-chunk-quality.mjs';
-import { resolveMaintenancePreset } from '../../../shared/llm/index.mjs';
+import { resolveMaintenancePreset } from '../../../agent/orchestrator/maintenance-preset.mjs';
 
 const CYCLE1_MIN_BATCH = 3;
 const CYCLE1_SESSION_CAP = 10;

package/src/runtime/memory/lib/embedding-idle-lease.mjs

@@ -0,0 +1,18 @@
+// Time-bounded "keep warm" lease for the embed worker. While embedding/cycle
+// backlog is being worked, the parent renews the lease so the idle-dispose
+// timer re-arms instead of unloading a model that is about to be needed again.
+// The lease expires on its own, so a stopped backlog never pins the model.
+export const EMBED_KEEP_WARM_MS = 6 * 60_000;
+
+export function createIdleLease(now = Date.now) {
+  let until = 0;
+  return {
+    hold(ms = EMBED_KEEP_WARM_MS) {
+      const ttl = Number(ms);
+      if (Number.isFinite(ttl) && ttl > 0) until = Math.max(until, now() + ttl);
+    },
+    active() {
+      return now() < until;
+    },
+  };
+}

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -9,6 +9,7 @@ import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writeProfilePoint } from './model-profile.mjs';
 import { createCompactVectorCache } from './compact-vector-cache.mjs';
+import { EMBED_KEEP_WARM_MS } from './embedding-idle-lease.mjs';
 import {
   getConfiguredEmbeddingModelId,
   getDefaultEmbeddingDtype,
@@ -204,6 +205,18 @@ function sendToWorker(action, extra = {}, timeoutMs = embeddingWorkerTimeout(act
   });
 }
 
+// Backlog is being worked: ask a live worker to skip idle-dispose. Never spawns
+// a worker, and the lease expires on its own once the backlog stops.
+export function holdEmbeddingWarm(ms = EMBED_KEEP_WARM_MS) {
+  if (!worker) return false;
+  try {
+    worker.postMessage({ type: 'keep-warm', ms });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function configureEmbedding(config = {}) {
   const dtype = normalizeEmbeddingDtype(MODEL_ID, config.dtype ?? process.env.MIXDOG_EMBED_DTYPE);
   if (dtype === _configuredDtype) return _configurePromise;

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -9,6 +9,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 import { compressEmbeddingModelCache } from './embedding-model-cache-compression.mjs';
+import { createIdleLease } from './embedding-idle-lease.mjs';
 import {
   getConfiguredEmbeddingModelId,
   getDefaultEmbeddingDevice,
@@ -108,6 +109,7 @@ let extractorPromise = null;
 let configuredDtype = normalizeEmbeddingDtype(MODEL_ID, workerData?.dtype ?? DEFAULT_DTYPE);
 let _device = 'cpu';
 let _idleTimer = null;
+const _idleLease = createIdleLease();
 let _embedInFlight = false;
 let _reclaiming = false;
 const _msgQueue = [];
@@ -234,8 +236,13 @@ function resetIdleTimer() {
   if (_idleTimer) clearTimeout(_idleTimer);
   if (IDLE_TIMEOUT_MS <= 0) return;
   _idleTimer = setTimeout(() => {
-    if (!_embedInFlight) void disposeLoadedExtractor('idle timeout');
     _idleTimer = null;
+    // Backlog is being worked: keep the model resident and look again later.
+    if (_idleLease.active()) {
+      resetIdleTimer();
+      return;
+    }
+    if (!_embedInFlight) void disposeLoadedExtractor('idle timeout');
   }, IDLE_TIMEOUT_MS);
   _idleTimer.unref?.();
 }
@@ -568,6 +575,10 @@ async function drainQueue() {
 }
 
 parentPort.on('message', async (msg) => {
+  if (msg?.type === 'keep-warm') {
+    _idleLease.hold(msg.ms);
+    return;
+  }
   // All guarded actions (embed/embed-batch/warmup/configure/dispose) wait
   // behind any in-flight guarded action. Without queueing configure/dispose
   // here, a new embed arriving mid-dispose would bypass the queue and race

package/src/runtime/memory/lib/http-router/ingest-routes.mjs

@@ -36,7 +36,7 @@ export function createIngestHandler({ getDb, log, ingestTranscriptFile, getTrans
       sendJson(res, { error: 'empty after clean' }, 400);
       return;
     }
-    const entryProjectId = resolveProjectScope(typeof body.cwd === 'string' && body.cwd ? body.cwd : null);
+    const entryProjectId = resolveProjectScope(body.cwd);
     try {
       const result = await db.query(INSERT_ENTRY, [tsMs, role, cleaned, sourceRef, sessionId, entryProjectId]);
       const insertedId = result.rows[0]?.id ?? null;

package/src/runtime/memory/lib/http-router/session-routes.mjs

@@ -34,7 +34,7 @@ const SCOPED_CORE_ROWS = `SELECT id, summary FROM core_entries WHERE project_id
 export function createSessionRoutes({ getDb, log }) {
   async function buildSessionCoreMemoryPayload(cwd) {
     const db = getDb();
-    const projectId = resolveProjectScope(typeof cwd === 'string' && cwd ? cwd : null);
+    const projectId = resolveProjectScope(cwd);
     const commonRows = (await db.query(ACTIVE_CORE_ROWS)).rows;
     const scopedRows = projectId !== null ? (await db.query(SCOPED_CORE_ROWS, [projectId])).rows : [];
     return {

package/src/runtime/memory/lib/ingest/transcript-discovery.mjs

@@ -7,7 +7,7 @@ import path from 'node:path';
 const ACTIVE_WINDOW_MS = 30 * 60_000;
 
 export function isSkippedWatchPath(relOrBase) {
-  return relOrBase.includes('tmp') || relOrBase.includes('cache') || relOrBase.includes('plugins');
+  return relOrBase.split(/[\\/]+/).some((seg) => seg === 'tmp' || seg === 'cache' || seg === 'plugins');
 }
 
 export function isTranscriptJsonlName(name) {

package/src/runtime/memory/lib/memory-action-handlers/manage-actions.mjs

@@ -116,7 +116,7 @@ export function createManageActions({ getDb, log }) {
     }
     const nowMs = Date.now();
     const sourceRef = `manual:${nowMs}-${process.pid}`;
-    const manageProjectId = resolveProjectScope(typeof args.cwd === 'string' && args.cwd ? args.cwd : null);
+    const manageProjectId = resolveProjectScope(args.cwd);
     try {
       const newId = await insertManualRootEntry(db, {
         element,

package/src/runtime/memory/lib/memory-cycle1.mjs

@@ -86,7 +86,28 @@ export function packCycle1Windows(
   return windows;
 }
 
-function mergeCycle1Results(a, b) {
+function sumNumericFields(a, b) {
+  const out = {};
+  for (const key of new Set([...Object.keys(a || {}), ...Object.keys(b || {})])) {
+    out[key] = Number(a?.[key] || 0) + Number(b?.[key] || 0);
+  }
+  return out;
+}
+
+function mergeEmbeddingDirty(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return {
+    ...b,
+    deferred: Boolean(a.deferred && b.deferred),
+    attempted: Number(a.attempted || 0) + Number(b.attempted || 0),
+    succeeded: Number(a.succeeded || 0) + Number(b.succeeded || 0),
+    failed: Number(a.failed || 0) + Number(b.failed || 0),
+    failed_ids: [...(a.failed_ids || []), ...(b.failed_ids || [])],
+  };
+}
+
+export function mergeCycle1Results(a, b) {
   if (!a) return b;
   if (!b) return a;
   const sum = (key) => Number(a?.[key] || 0) + Number(b?.[key] || 0);
@@ -102,6 +123,8 @@ function mergeCycle1Results(a, b) {
     skipped: sum('skipped'),
     sessions: sum('sessions'),
     skippedInFlight: false,
+    embedding_dirty: mergeEmbeddingDirty(a.embedding_dirty, b.embedding_dirty),
+    timing: sumNumericFields(a.timing, b.timing),
     pendingRows: b.pendingRows ?? a.pendingRows,
     failed_row_ids: uniqueNumbers([...(a.failed_row_ids || []), ...(b.failed_row_ids || [])]),
     omitted_row_ids: uniqueNumbers([...(a.omitted_row_ids || []), ...(b.omitted_row_ids || [])]),

package/src/runtime/memory/lib/memory-cycle2-quarantine.mjs

@@ -0,0 +1,99 @@
+// Failure containment for cycle2 review batches. A batch (its row-id set) that
+// keeps failing is cooled down with exponential backoff, then dead-lettered:
+// its rows are excluded from selection (so nothing re-enqueues them) until a
+// timed re-arm. A run of consecutive failures across batches pauses review as a
+// whole, so a systematically broken model/prompt cannot burn one LLM call per
+// scheduler tick. State is in-process; a restart re-arms everything.
+import { createHash } from 'node:crypto';
+
+const DEFAULTS = { maxAttempts: 3, backoffMs: 30_000, rearmMs: 3_600_000 };
+const RAW_LOG_LIMIT = 2000;
+
+const states = new WeakMap();
+
+function stateFor(db) {
+  let state = states.get(db);
+  if (!state) {
+    state = { batches: new Map(), streak: 0, streakSignature: '', pausedUntil: 0 };
+    states.set(db, state);
+  }
+  return state;
+}
+
+function positive(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+export function resolveQuarantinePolicy(config = {}) {
+  return {
+    maxAttempts: Math.floor(positive(config.failure_max_attempts, DEFAULTS.maxAttempts)),
+    backoffMs: positive(config.failure_backoff_ms, DEFAULTS.backoffMs),
+    rearmMs: positive(config.dead_letter_rearm_ms, DEFAULTS.rearmMs),
+  };
+}
+
+function batchKey(ids) {
+  return createHash('sha1')
+    .update([...ids].map(Number).sort((a, b) => a - b).join(','))
+    .digest('hex')
+    .slice(0, 16);
+}
+
+/** Row ids currently cooling down or dead-lettered; expired entries re-arm. */
+export function quarantinedIds(db, now = Date.now()) {
+  const { batches } = stateFor(db);
+  const ids = [];
+  for (const [key, entry] of batches) {
+    if (entry.until <= now) {
+      // Cooldown elapsed: the batch may retry, keeping its failure count.
+      // A dead-lettered batch that re-arms starts over.
+      if (entry.dead) batches.delete(key);
+      continue;
+    }
+    ids.push(...entry.ids);
+  }
+  return ids;
+}
+
+export function reviewPausedUntil(db) {
+  return stateFor(db).pausedUntil;
+}
+
+export function recordReviewSuccess(db, ids) {
+  const state = stateFor(db);
+  state.batches.delete(batchKey(ids));
+  state.streak = 0;
+  state.streakSignature = '';
+  state.pausedUntil = 0;
+}
+
+/**
+ * Record a failed batch. Returns { fails, dead, firstFailure, key, raw } where
+ * raw is the truncated invalid model output to log once (first failure only).
+ */
+export function recordReviewFailure(db, ids, error, config = {}, now = Date.now()) {
+  const policy = resolveQuarantinePolicy(config);
+  const state = stateFor(db);
+  const key = batchKey(ids);
+  const prior = state.batches.get(key);
+  const fails = (prior?.fails ?? 0) + 1;
+  const dead = fails >= policy.maxAttempts;
+  const wait = dead ? policy.rearmMs : Math.min(policy.rearmMs, policy.backoffMs * 2 ** (fails - 1));
+  state.batches.set(key, { ids: [...ids].map(Number), fails, dead, until: now + wait });
+  const signature = String(error?.message ?? error);
+  state.streak = signature === state.streakSignature ? state.streak + 1 : 1;
+  state.streakSignature = signature;
+  if (state.streak >= policy.maxAttempts) {
+    const level = state.streak - policy.maxAttempts;
+    state.pausedUntil = now + Math.min(policy.rearmMs, policy.backoffMs * 2 ** level);
+  }
+  const rawVerdict = error?.rawVerdict;
+  return {
+    key,
+    fails,
+    dead,
+    firstFailure: fails === 1,
+    raw: rawVerdict === undefined ? null : String(rawVerdict).slice(0, RAW_LOG_LIMIT),
+  };
+}

package/src/runtime/memory/lib/memory-cycle2-review.mjs

@@ -1,5 +1,5 @@
 import { callAgentDispatch } from './agent-ipc.mjs';
-import { resolveMaintenancePreset } from '../../shared/llm/index.mjs';
+import { resolveMaintenancePreset } from '../../agent/orchestrator/maintenance-preset.mjs';
 import { createSemaphore, throwIfAborted } from './memory-cycle2-shared.mjs';
 
 // Reuse the history lineage search: nearest semantic and lexical predecessors
@@ -217,7 +217,13 @@ export async function reviewHistory(db, rows, config = {}, options = {}) {
           prompt
         );
         throwIfAborted(signal);
-        return parseHistoryReview(raw, packet);
+        try {
+          return parseHistoryReview(raw, packet);
+        } catch (error) {
+          // Keep the model output so the failing batch can be logged once.
+          error.rawVerdict = raw;
+          throw error;
+        }
       })
     )
   );

package/src/runtime/memory/lib/memory-cycle2.mjs

@@ -1,6 +1,13 @@
 // Cycle 2 maintains searchable history. It never writes standing memory or
 // changes the legacy active/archived classification.
 import { flushEmbeddingDirty } from './memory-embed.mjs';
+import { holdEmbeddingWarm } from './embedding-provider.mjs';
+import {
+  quarantinedIds,
+  recordReviewFailure,
+  recordReviewSuccess,
+  reviewPausedUntil,
+} from './memory-cycle2-quarantine.mjs';
 import { reviewHistory } from './memory-cycle2-review.mjs';
 import { applyHistoryReview } from './memory-cycle2-mutations.mjs';
 import { __mixdogMemoryLog, throwIfAborted, isStoreFault } from './memory-cycle2-shared.mjs';
@@ -19,20 +26,51 @@ const emptyResult = () => ({ processed: 0, kept: 0, merged: 0, linked: 0, held:
 async function maintainHistory(db, config, options, result) {
   const { signal } = options;
   throwIfAborted(signal);
-  const rows = (
-    await db.query(
-      `
+  const now = (options.now ?? Date.now)();
+  // While review is paused or a failing batch is cooling down / dead-lettered,
+  // its rows stay out of selection, so nothing re-enqueues them.
+  // Only automatic (scheduler/coalesced) runs are contained; an explicit
+  // user-requested run always reviews and surfaces its own failure.
+  const automatic = options.coalescedRetry === true;
+  const excluded = !automatic ? [] : reviewPausedUntil(db) > now ? null : quarantinedIds(db, now);
+  const rows = excluded
+    ? (
+        await db.query(
+          `
     SELECT id, ts, element, summary, project_id
     FROM entries
     WHERE is_root = 1 AND cycle2_reviewed_at IS NULL AND duplicate_of IS NULL
+      ${excluded.length ? 'AND NOT (id = ANY($2::bigint[]))' : ''}
     ORDER BY ts DESC, id DESC
     LIMIT $1
   `,
-      [Math.max(1, Math.floor(Number(config.batch_size) || 50))]
-    )
-  ).rows;
+          [Math.max(1, Math.floor(Number(config.batch_size) || 50)), ...(excluded.length ? [excluded] : [])]
+        )
+      ).rows
+    : [];
   if (rows.length) {
-    const review = await reviewHistory(db, rows, config, options);
+    // Backlog is being worked: keep the embed model resident between batches.
+    holdEmbeddingWarm();
+    const ids = rows.map((row) => Number(row.id));
+    let review;
+    try {
+      review = await reviewHistory(db, rows, config, options);
+    } catch (error) {
+      if (!automatic || signal?.aborted || isStoreFault(error)) throw error;
+      const failure = recordReviewFailure(db, ids, error, config, now);
+      if (failure.firstFailure && failure.raw !== null) {
+        __mixdogMemoryLog(`[cycle2] invalid review output for batch ${failure.key}: ${failure.raw}\n`);
+      }
+      if (failure.dead) {
+        __mixdogMemoryLog(
+          `[cycle2] batch ${failure.key} (${ids.length} rows) dead-lettered after ${failure.fails} failures: ${error.message}\n`
+        );
+      }
+      // Already backed off/dead-lettered here; a coalesced retry would only re-run it.
+      error.cycle2Quarantined = true;
+      throw error;
+    }
+    recordReviewSuccess(db, ids);
     result.deferred += review.deferredIds.length;
     // Validate every packet before applying any verdict. Bad model output
     // leaves the queue intact and is a failed run, not a successful no-op.
@@ -121,8 +159,10 @@ export async function runCycle2(db, config = {}, options = {}) {
     } catch (error) {
       throwIfAborted(signal);
       // Do not write retry metadata after an ambiguous store failure.
-      if (retry && !isStoreFault(error)) await markCycleRequest(db, 'cycle2', 'retry-error', signature);
-      if (retry && attempt < maxRetries) scheduleRetry();
+      if (retry && !isStoreFault(error) && !error.cycle2Quarantined) {
+        await markCycleRequest(db, 'cycle2', 'retry-error', signature);
+      }
+      if (retry && attempt < maxRetries && !error.cycle2Quarantined) scheduleRetry();
       __mixdogMemoryLog(`[cycle2] history maintenance failed: ${error.message}\n`);
       return { ok: false, ...result, error: error.message, storeFault: isStoreFault(error) };
     } finally {

package/src/runtime/memory/lib/memory-embed.mjs

@@ -1,6 +1,6 @@
 import { __mixdogMemoryLog } from './memory-log.mjs';
 
-import { embedTexts, getEmbeddingModelId } from './embedding-provider.mjs';
+import { embedTexts, getEmbeddingModelId, holdEmbeddingWarm } from './embedding-provider.mjs';
 import { embeddingToSql } from './memory.mjs';
 import { createHash } from 'node:crypto';
 import { pruneEmbeddingCache, resolveEmbeddingCacheMaxRows } from './embedding-cache-retention.mjs';
@@ -160,7 +160,7 @@ export async function cachedEmbedTextBatch(db, texts, options = {}) {
     )
   ).rows;
   throwIfAborted(signal);
-  // Issue 6: pgvector/halfvec returns a text string like "[0.1,0.2,...]".
+  // pgvector/halfvec returns a text string like "[0.1,0.2,...]".
   // Array.from on a string yields individual characters — parse to numeric array.
   const hitMap = new Map(
     hits.map((r) => [
@@ -284,6 +284,7 @@ export async function flushEmbeddingDirty(db, options = {}) {
 
       cursor = ids[ids.length - 1];
       totalAttempted += ids.length;
+      holdEmbeddingWarm();
       let batchDone = false;
       let abortFailure = null;
       try {

package/src/runtime/memory/lib/memory-extraction.mjs

@@ -1,5 +1,4 @@
 // Single source of truth: lib/text-utils.cjs (also required by hooks/session-start.cjs).
 import { createRequire } from 'node:module';
 const _require = createRequire(import.meta.url);
-const { cleanMemoryText: _cleanMemoryText } = _require('../../../lib/text-utils.cjs');
-export const cleanMemoryText = _cleanMemoryText;
+export const { cleanMemoryText } = _require('../../../lib/text-utils.cjs');

package/src/runtime/memory/lib/memory-fingerprint.mjs

@@ -28,7 +28,7 @@ function collectMemoryFingerprintFiles(pluginRoot) {
       const rel = `${relDir}/${ent.name}`.replace(/\\/g, '/');
       if (ent.isDirectory()) {
         walk(rel);
-      } else if (ent.isFile() && rel.endsWith('.mjs')) {
+      } else if (ent.isFile() && rel.endsWith('.mjs') && !rel.endsWith('.test.mjs')) {
         out.push(rel);
       }
     }