mixdog 1.0.8 → 1.0.10

package/src/runtime/local-provider/hardware.mjs

@@ -1,10 +1,37 @@
 import { execFile } from 'node:child_process';
+import { cpus, totalmem } from 'node:os';
 import { promisify } from 'node:util';
 
 const execFileAsync = promisify(execFile);
 const GPU_FIELDS = 'index,uuid,name,memory.total,memory.free';
 const CACHE_MS = 5_000;
 
+/** The manifest runtime this host runs: CUDA on Windows x64, Metal on Apple
+ *  Silicon; '' where no llama.cpp build is pinned. */
+export function localProviderPlatformKey(platform = process.platform, arch = process.arch) {
+  if (platform === 'win32' && arch === 'x64') return 'win32-x64-nvidia';
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64-metal';
+  return '';
+}
+
+/** Apple Silicon has one GPU on unified memory. Metal caps what it wires for
+ *  the GPU: the `iogpu.wired_limit_mb` override when set, else two thirds of
+ *  RAM — exactly what llama.cpp's Metal backend reports on a 16 GB M4; larger
+ *  Macs may allow more, which this leaves unused. Metal reports that whole
+ *  working set as free, so free equals total here as it does in llama.cpp. */
+export function appleSiliconGpu({ name, totalBytes, wiredLimitMb }) {
+  const memoryBytes = wiredLimitMb > 0 ? wiredLimitMb * 1024 ** 2 : Math.floor((totalBytes * 2) / 3);
+  return { index: 0, uuid: 'MTL0', vendor: 'Apple', name, memoryBytes, freeMemoryBytes: memoryBytes };
+}
+
+async function queryAppleSilicon() {
+  const limit = await execFileAsync('/usr/sbin/sysctl', ['-n', 'iogpu.wired_limit_mb'], {
+    encoding: 'utf8',
+    timeout: 5_000,
+  }).catch(() => ({ stdout: '0' })); // macOS before 14 has no such key
+  return { name: cpus()[0]?.model || 'Apple Silicon', totalBytes: totalmem(), wiredLimitMb: Number(limit.stdout) || 0 };
+}
+
 export function parseNvidiaGpus(output) {
   return String(output || '')
     .split(/\r?\n/)
@@ -40,12 +67,14 @@ export function createHardwareProbe({
         maxBuffer: 64 * 1024,
       })
     ).stdout,
+  appleQueryFn = queryAppleSilicon,
   platform = process.platform,
   arch = process.arch,
   now = Date.now,
   cacheMs = CACHE_MS,
 } = {}) {
-  const platformSupported = platform === 'win32' && arch === 'x64';
+  const platformSupported = Boolean(localProviderPlatformKey(platform, arch));
+  const apple = platform === 'darwin';
   let value = {
     platform,
     arch,
@@ -70,12 +99,14 @@ export function createHardwareProbe({
       return value;
     };
     pending = Promise.resolve()
-      .then(queryFn)
+      .then(apple ? appleQueryFn : queryFn)
       .then(
         (output) => {
-          const gpus = parseNvidiaGpus(output).sort(
-            (a, b) => b.memoryBytes - a.memoryBytes || b.freeMemoryBytes - a.freeMemoryBytes || a.index - b.index
-          );
+          const gpus = apple
+            ? [appleSiliconGpu(output)]
+            : parseNvidiaGpus(output).sort(
+                (a, b) => b.memoryBytes - a.memoryBytes || b.freeMemoryBytes - a.freeMemoryBytes || a.index - b.index
+              );
           return settle({
             gpu: gpus[0] || null,
             gpus,

package/src/runtime/local-provider/resumable-installations.mjs

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { LOCAL_PROVIDER_MANIFEST, exactLocalProviderFile, localProviderRuntimeRoot } from './catalog.mjs';
+import { exactLocalProviderFile, localProviderRuntimePlatformEntry, localProviderRuntimeRoot } from './catalog.mjs';
 import { partialAssetBytes } from './asset-storage.mjs';
 
 // Partial files are durable evidence after a process restart. They do not
@@ -27,7 +27,7 @@ export function resumableLocalInstallations(catalog, live, dataDir) {
     entries.push(pausedEntry('model', model.id, receivedBytes, model.sizeBytes));
   }
   if (!catalog.runtime.installed && !entries.some((entry) => entry.phase === 'runtime')) {
-    const assets = LOCAL_PROVIDER_MANIFEST.runtime.platforms['win32-x64-nvidia'].assets;
+    const assets = localProviderRuntimePlatformEntry()?.assets || [];
     const receivedBytes = assets.reduce((sum, asset) => {
       const path = join(localProviderRuntimeRoot(dataDir), '.downloads', asset.name);
       return sum + (exactLocalProviderFile(path, asset.size) ? asset.size : partialAssetBytes(path, asset.size));

package/src/runtime/local-provider/server.mjs

@@ -83,7 +83,7 @@ export async function ensureLocalProviderServer(modelId, { dataDir = resolvePlug
         const hardware = await detectLocalProviderHardware({ refresh: true });
         startupSignal?.throwIfAborted();
         const gpu = selectLocalProviderGpu(hardware, entry);
-        return { gpu, env: { CUDA_VISIBLE_DEVICES: gpu.uuid } };
+        return { gpu, env: gpu.vendor === 'NVIDIA' ? { CUDA_VISIBLE_DEVICES: gpu.uuid } : {} };
       },
       onReady: async ({ baseURL, apiKey, loadTimeMs }, startupSignal) => {
         let props = {};

package/src/runtime/memory/index.mjs

@@ -59,7 +59,6 @@ import {
   resolveCoalesceMaxRetries,
   scheduleCoalescedCycleRetry,
 } from './lib/memory-cycle-requests.mjs';
-import { backfillCoreEmbeddings } from './lib/core-memory-store.mjs';
 import { drainEmbeddingReindex } from './lib/embedding-reindex.mjs';
 import { refreshCoreMemoryFile } from './lib/core-memory-file.mjs';
 import { resolveProjectId, resolveProjectScope } from './lib/project-id-resolver.mjs';
@@ -420,14 +419,13 @@ function _startEmbeddingReindex() {
   _embeddingReindexController = controller;
   const promise = drainEmbeddingReindex({
     flushEntries: ({ signal }) => flushEmbeddingDirty(db, { signal }),
-    backfillCore: ({ signal }) => backfillCoreEmbeddings(DATA_DIR, { signal }),
     signal: controller.signal,
   })
     .then((summary) => {
-      if (summary.attempted > 0 || summary.coreFilled > 0) {
+      if (summary.attempted > 0) {
         __mixdogMemoryLog(
           `[memory-service] embedding reindex passes=${summary.passes} attempted=${summary.attempted} ` +
-            `ok=${summary.succeeded} failed=${summary.failed} core=${summary.coreFilled}\n`
+            `ok=${summary.succeeded} failed=${summary.failed}\n`
         );
       }
     })

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

@@ -30,15 +30,10 @@ function normalizeSummary(value) {
     .trim();
 }
 
+// The prompt carries the user's text only; the memory tool addresses entries
+// through its own list results, not through injected ids.
 export function formatCuratedCoreMemoryLine(row) {
-  const summary = normalizeSummary(row?.summary);
-  if (!summary) return '';
-  const id = Number(row?.id);
-  const scope = row?.project_id ?? row?.projectId ?? 'common';
-  const version = row?.index_revision ?? row?.indexRevision;
-  return Number.isInteger(id) && id > 0 && version
-    ? `[project=${scope} id=${id} index_revision=${version}] ${summary}`
-    : summary;
+  return normalizeSummary(row?.summary);
 }
 
 function normalizeCuratedEntry(row) {

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

@@ -1,15 +1,14 @@
-import { __mixdogMemoryLog } from './memory-log.mjs';
 
 // User-curated core memory store — native PG-backed via core_entries table.
 // Per-project entries distinguished by project_id column (NULL = COMMON).
 // Explicit add/edit/delete operations affect only the requested entry.
 // Generated conversation history never enters this store automatically.
 
-import { getDatabase, embeddingToSql } from './memory.mjs';
+// Entries are injected verbatim and recalled by term match, so no write here
+// embeds: saving never waits on the embedding model.
+import { getDatabase } from './memory.mjs';
 import { VALID_CATEGORY } from './memory-categories.mjs';
-import { cachedEmbedTextBatch } from './memory-embed.mjs';
 import { checkedConnect } from './pg/adapter.mjs';
-import { throwIfAborted } from './memory-cycle-shared.mjs';
 import { findCoreKeyRows } from './core-memory-uniqueness.mjs';
 
 const CORE_ELEMENT_DERIVE_LENGTH = 40;
@@ -75,46 +74,6 @@ function _getDb(dataDir) {
   return db;
 }
 
-async function _embedFor(db, element, summary) {
-  const text = `${element}\n${summary || ''}`.trim();
-  if (!text) return null;
-  const [vec] = await cachedEmbedTextBatch(db, [text]);
-  return Array.isArray(vec) ? vec : null;
-}
-
-// Lazy repair of NULL embeddings on existing rows. Runs once per boot or
-// whenever a NULL slips back in via direct SQL. SELECT WHERE embedding IS NULL
-// returns 0 rows on a fully-populated table, so this is a fast no-op.
-async function _backfillNullEmbeddings(db, options = {}) {
-  const signal = options?.signal;
-  throwIfAborted(signal);
-  // Only refill live cores; legacy archived entries stay inactive.
-  const r = await db.query(
-    `SELECT id, element, summary FROM core_entries WHERE embedding IS NULL AND (status IS NULL OR status = 'active')`
-  );
-  if (r.rows.length === 0) return 0;
-  let filled = 0;
-  for (const row of r.rows) {
-    throwIfAborted(signal);
-    const vec = await _embedFor(db, row.element, row.summary);
-    throwIfAborted(signal);
-    if (!vec) continue;
-    await db.query(`UPDATE core_entries SET embedding = $1::halfvec WHERE id = $2 AND embedding IS NULL`, [
-      embeddingToSql(vec),
-      row.id,
-    ]);
-    filled++;
-  }
-  if (filled > 0) {
-    __mixdogMemoryLog(`[core-memory] backfilled ${filled} NULL embedding(s) on core_entries\n`);
-  }
-  return filled;
-}
-
-export async function backfillCoreEmbeddings(dataDir, options = {}) {
-  const db = _getDb(dataDir);
-  return await _backfillNullEmbeddings(db, options);
-}
 
 // NOTE: boot-time core id compaction was REMOVED. Resequencing core_entries.id
 // to 1..N rewrote primary keys that are handed out as stable `core:N`
@@ -177,8 +136,6 @@ async function _addCoreImpl(dataDir, input, projectId) {
   if (errors.length) throw new Error(errors.join('; '));
   const db = _getDb(dataDir);
   const now = Date.now();
-  await _backfillNullEmbeddings(db);
-  const embedding = await _embedFor(db, el, sm);
 
   const client = await checkedConnect(db._pool, 'memory');
   try {
@@ -194,20 +151,20 @@ async function _addCoreImpl(dataDir, input, projectId) {
         );
       }
       const revived = await client.query(
-        `UPDATE core_entries SET summary = $1, category = $2, embedding = $3::halfvec,
-           status = 'active', archived_at = NULL, updated_at = $4
-         WHERE id = $5
+        `UPDATE core_entries SET summary = $1, category = $2,
+           status = 'active', archived_at = NULL, updated_at = $3
+         WHERE id = $4
          RETURNING id, element, summary, category, project_id, created_at, updated_at`,
-        [sm, cat, embedding ? embeddingToSql(embedding) : null, now, collisions[0].id]
+        [sm, cat, now, collisions[0].id]
       );
       await client.query('COMMIT');
       return { ...revived.rows[0], revived_from_archived: true };
     }
     const r = await client.query(
-      `INSERT INTO core_entries(element, summary, category, project_id, embedding, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5::halfvec, $6, $7)
+      `INSERT INTO core_entries(element, summary, category, project_id, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
        RETURNING id, element, summary, category, project_id, created_at, updated_at`,
-      [el, sm, cat, projectId, embedding ? embeddingToSql(embedding) : null, now, now]
+      [el, sm, cat, projectId, now, now]
     );
     await client.query('COMMIT');
     return r.rows[0];
@@ -276,8 +233,6 @@ async function _editCoreImpl(dataDir, id, patch) {
     return { ...cur, element: newElement, summary: newSummary, category: newCategory, updated_at: now };
   }
 
-  await _backfillNullEmbeddings(db);
-  const embedding = await _embedFor(db, newElement, newSummary);
   const client = await checkedConnect(db._pool, 'memory');
   try {
     await client.query('BEGIN');
@@ -289,8 +244,7 @@ async function _editCoreImpl(dataDir, id, patch) {
     for (const poolKey of new Set(poolKeys)) {
       await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [poolKey]);
     }
-    // Revalidate under the lock. `cur` (and the embedding derived from it) was
-    // read before any locking, so without this check two concurrent edits both
+    // Revalidate under the lock. `cur` was read before any locking, so without this check two concurrent edits both
     // computed a patch from the same snapshot and the slower one silently
     // overwrote the newer content.
     const fresh = (await client.query(`SELECT * FROM core_entries WHERE id = $1 FOR UPDATE`, [numId])).rows[0];
@@ -313,10 +267,9 @@ async function _editCoreImpl(dataDir, id, patch) {
     }
     await client.query(
       `UPDATE core_entries
-       SET element = $1, summary = $2, category = $3, project_id = $4,
-           embedding = $5::halfvec, updated_at = $6
-       WHERE id = $7`,
-      [newElement, newSummary, newCategory, newProjectId, embedding ? embeddingToSql(embedding) : null, now, numId]
+       SET element = $1, summary = $2, category = $3, project_id = $4, updated_at = $5
+       WHERE id = $6`,
+      [newElement, newSummary, newCategory, newProjectId, now, numId]
     );
     await client.query('COMMIT');
     return {

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

@@ -1,4 +1,4 @@
-import { CYCLE1_OMITTED_COOLDOWN_MS } from '../cycle1/cycle1-plan.mjs';
+import { cycle1RowDueSql, cycle1UnchunkedSql } from '../cycle1/cycle1-rows.mjs';
 
 const BACKLOG_WARN_PENDING = 500;
 
@@ -27,17 +27,13 @@ export function createBacklogProbe({ getDb, ledger, log, flushRawEmbeddings }) {
   async function probe(now) {
     const db = getDb();
     try {
-      const unchunked = await countRows(
-        db,
-        `SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL AND NULLIF(btrim(session_id), '') IS NOT NULL`
-      );
+      const unchunked = await countRows(db, `SELECT COUNT(*) c FROM entries WHERE ${cycle1UnchunkedSql()}`);
       const unchunkedEligible = await countRows(
         db,
         `SELECT COUNT(*) c FROM entries
-         WHERE chunk_root IS NULL
-           AND NULLIF(btrim(session_id), '') IS NOT NULL
-           AND (reviewed_at IS NULL OR reviewed_at < $1)`,
-        [now - CYCLE1_OMITTED_COOLDOWN_MS]
+         WHERE ${cycle1UnchunkedSql()}
+           AND ${cycle1RowDueSql('$1')}`,
+        [now]
       );
       ledger.setBacklog({ unchunked, unchunked_eligible: unchunkedEligible, at: now });
       if (unchunked > BACKLOG_WARN_PENDING) {

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

@@ -9,6 +9,13 @@ const CYCLE1_SESSION_CAP = 10;
 export const CYCLE1_PACKET_MAX_ROWS = 50;
 export const CYCLE1_MAX_PACKETS = 4;
 export const CYCLE1_OMITTED_COOLDOWN_MS = 60 * 60 * 1000;
+// A row the classifier leaves raw again waits twice as long each time, up to
+// this. Most such rows are one- or two-row leftovers too short for any summary
+// to come out shorter than they are, so the same prompt yields the same miss:
+// at a flat hourly retry they filled every packet slot of every run (runtime
+// log 2026-10-04..05: 1768 of 1832 classifier calls committed nothing; one
+// two-character row had been sent 278 times).
+export const CYCLE1_OMITTED_COOLDOWN_MAX_MS = 30 * 24 * 60 * 60 * 1000;
 // A session is chunked only after it has been quiet this long, so one task's
 // request, work, result and correction reach the classifier together instead
 // of being split at every scheduler tick.

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

@@ -4,7 +4,31 @@
 // terminal / omitted sentinel updates.
 import { __mixdogMemoryLog } from '../memory-log.mjs';
 import { throwIfAborted } from '../memory-cycle-shared.mjs';
-import { CYCLE1_OMITTED_COOLDOWN_MS } from './cycle1-plan.mjs';
+import { CYCLE1_OMITTED_COOLDOWN_MAX_MS, CYCLE1_OMITTED_COOLDOWN_MS } from './cycle1-plan.mjs';
+
+const CYCLE1_OMITTED_MAX_DOUBLINGS = Math.ceil(Math.log2(CYCLE1_OMITTED_COOLDOWN_MAX_MS / CYCLE1_OMITTED_COOLDOWN_MS));
+
+/** SQL for "this unchunked row may be sent now": never reviewed, or its
+ *  cooldown has passed. The cooldown starts at CYCLE1_OMITTED_COOLDOWN_MS and
+ *  doubles with each further miss counted in error_count, up to the maximum.
+ *  `nowParam` is the placeholder holding the current time in ms. */
+export function cycle1RowDueSql(nowParam, alias = '') {
+  const column = alias ? `${alias}.` : '';
+  const doublings = `LEAST(GREATEST(COALESCE(${column}error_count, 0) - 1, 0), ${CYCLE1_OMITTED_MAX_DOUBLINGS})`;
+  const cooldown = `LEAST(${CYCLE1_OMITTED_COOLDOWN_MAX_MS}::bigint, ${CYCLE1_OMITTED_COOLDOWN_MS}::bigint * (1::bigint << ${doublings}))`;
+  return `(${column}reviewed_at IS NULL OR ${column}reviewed_at < ${nowParam}::bigint - ${cooldown})`;
+}
+
+/** SQL for "an unchunked row that belongs to a session". `session_id IS NOT
+ *  NULL` is implied by the trimmed check; stating it is what lets the planner
+ *  use the partial index on pending rows. Without it every count scanned the
+ *  whole table, and the backlog probe alone runs two a minute (EXPLAIN ANALYZE
+ *  on a 162K-row store: parallel seq scan, 100-170 ms and 21K blocks read,
+ *  against 32 ms through the index). */
+export function cycle1UnchunkedSql(alias = '') {
+  const column = alias ? `${alias}.` : '';
+  return `${column}chunk_root IS NULL AND ${column}session_id IS NOT NULL AND NULLIF(btrim(${column}session_id), '') IS NOT NULL`;
+}
 
 export function isStructurallyUnchunkableInput(row) {
   return !String(row?.content ?? '').trim();
@@ -41,19 +65,23 @@ export async function markTerminalRows(db, rowIds, label = 'terminal') {
   }
 }
 
-export async function markOmittedRows(db, rowIds) {
+/** Defers the rows a window left raw. Only a miss the classifier produced
+ *  counts toward the lengthening cooldown (cycle1RowDueSql); `transientRowIds`
+ *  never got an answer — a provider error, a commit that lost a race — and
+ *  come back at the base cooldown however long the outage lasts. */
+export async function markOmittedRows(db, rowIds, { transientRowIds = [] } = {}) {
   const ids = positiveEntryIds(rowIds);
   if (ids.length === 0) return { attempted: 0, deferred: 0, marked: 0, failed: 0 };
   try {
     const result = await db.query(
       `UPDATE entries
        SET reviewed_at = $2,
-           error_count = COALESCE(error_count, 0) + 1
+           error_count = COALESCE(error_count, 0) + CASE WHEN id = ANY($3::bigint[]) THEN 0 ELSE 1 END
        WHERE id = ANY($1::bigint[])
          AND chunk_root IS NULL
          AND is_root = 0
        RETURNING id`,
-      [ids, Date.now()]
+      [ids, Date.now(), positiveEntryIds(transientRowIds)]
     );
     const rows = Array.isArray(result?.rows) ? result.rows : [];
     // A model failure is not permission to retire source data. Keep every
@@ -81,12 +109,12 @@ export function selectRootId(members) {
   return rootId;
 }
 
-async function countSessionUnchunkedRows(db, { reviewedBefore = null } = {}) {
-  const where = ['chunk_root IS NULL', `NULLIF(btrim(session_id), '') IS NOT NULL`];
+async function countSessionUnchunkedRows(db, { dueAt = null } = {}) {
+  const where = [cycle1UnchunkedSql()];
   const params = [];
-  if (reviewedBefore != null) {
-    params.push(reviewedBefore);
-    where.push('(reviewed_at IS NULL OR reviewed_at < $1)');
+  if (dueAt != null) {
+    params.push(dueAt);
+    where.push(cycle1RowDueSql('$1'));
   }
   try {
     const result = await db.query(
@@ -102,7 +130,7 @@ async function countSessionUnchunkedRows(db, { reviewedBefore = null } = {}) {
 }
 
 export function countPendingRows(db) {
-  return countSessionUnchunkedRows(db, { reviewedBefore: Date.now() - CYCLE1_OMITTED_COOLDOWN_MS });
+  return countSessionUnchunkedRows(db, { dueAt: Date.now() });
 }
 
 export function countRawUnchunkedRows(db) {
@@ -115,7 +143,7 @@ export function countRawUnchunkedRows(db) {
  *  classifier prompt. Rows come back newest-first. */
 export async function fetchCycle1Rows(db, plan, now = Date.now()) {
   const sessionFilterSql = plan.onlySessionId ? 'AND session_id = $4' : '';
-  const queryParams = [plan.sessionCap, now - CYCLE1_OMITTED_COOLDOWN_MS, plan.rowsPerSession];
+  const queryParams = [plan.sessionCap, now, plan.rowsPerSession];
   if (plan.onlySessionId) queryParams.push(plan.onlySessionId);
   queryParams.push(plan.backfillCap);
   const backfillParam = `$${queryParams.length}`;
@@ -136,9 +164,8 @@ export async function fetchCycle1Rows(db, plan, now = Date.now()) {
     `WITH eligible_sessions AS (
        SELECT session_id, MAX(ts) AS latest_ts, MAX(id) AS latest_id, MIN(ts) AS oldest_ts
        FROM entries
-       WHERE chunk_root IS NULL
-         AND NULLIF(btrim(session_id), '') IS NOT NULL
-         AND (reviewed_at IS NULL OR reviewed_at < $2)
+       WHERE ${cycle1UnchunkedSql()}
+         AND ${cycle1RowDueSql('$2')}
          ${sessionFilterSql}
        GROUP BY session_id
      ), due_sessions AS (
@@ -162,8 +189,8 @@ export async function fetchCycle1Rows(db, plan, now = Date.now()) {
               ROW_NUMBER() OVER (PARTITION BY e.session_id ORDER BY e.ts DESC, e.id DESC) AS rn
        FROM entries e
        JOIN selected_sessions s ON s.session_id = e.session_id
-       WHERE e.chunk_root IS NULL
-         AND (e.reviewed_at IS NULL OR e.reviewed_at < $2)
+       WHERE ${cycle1UnchunkedSql('e')}
+         AND ${cycle1RowDueSql('$2', 'e')}
      )
      SELECT id, ts, role, content, session_id, source_ref, project_id
      FROM ranked

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

@@ -66,6 +66,11 @@ async function commitGeneratedChunks(db, generated, signal) {
   const invalidChunks = generated.invalidChunks;
   const invalidRowIds = new Set(invalidChunks.flatMap((chunk) => chunk.member_ids || []));
   const failedRowIds = generated.rawRowIds.filter((id) => invalidRowIds.has(id));
+  // Rows that never got an answer from the classifier, as opposed to rows it
+  // answered badly or left out: these do not lengthen their retry cooldown.
+  const transientRowIds = invalidChunks
+    .filter((chunk) => chunk.reason === 'llm_error')
+    .flatMap((chunk) => chunk.member_ids || []);
   const commitStartedAt = Date.now();
   for (const chunk of generated.chunks) {
     // A chunk commit is one DB transaction; do not split it with an abort
@@ -97,7 +102,10 @@ async function commitGeneratedChunks(db, generated, signal) {
     } catch (err) {
       __mixdogMemoryLog(`[cycle1] chunk commit failed (root=${rootId}): ${err.message}\n`);
       skippedChunks += 1;
-      for (const mid of memberIds) failedRowIds.push(mid);
+      for (const mid of memberIds) {
+        failedRowIds.push(mid);
+        transientRowIds.push(mid);
+      }
     }
   }
   return {
@@ -107,6 +115,7 @@ async function commitGeneratedChunks(db, generated, signal) {
     skippedChunks,
     invalidChunks,
     failedRowIds,
+    transientRowIds,
     commitStartedAt,
   };
 }
@@ -160,7 +169,7 @@ export async function processCycle1Window({ db, rows: originalRows, windowIdx, p
 
   const rawRowIds = rows.map((r) => Number(r.id)).filter((id) => !commit.committedRowIds.has(id));
   const llmOmittedRowIds = rawRowIds.filter((id) => !commit.failedRowIds.includes(id));
-  const omittedMark = await markOmittedRows(db, rawRowIds);
+  const omittedMark = await markOmittedRows(db, rawRowIds, { transientRowIds: commit.transientRowIds });
   const omittedRowIds = llmOmittedRowIds.concat(prefilteredRowIds);
 
   __mixdogMemoryLog(

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

@@ -10,6 +10,7 @@ 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 { workerExecArgv } from '../../shared/worker-exec-argv.mjs';
 import {
   getConfiguredEmbeddingModelId,
   getDefaultEmbeddingDtype,
@@ -47,11 +48,7 @@ const queryEmbeddingCache = createCompactVectorCache({
 const WORKER_PATH = join(fileURLToPath(import.meta.url), '..', 'embedding-worker.mjs');
 
 export function embeddingWorkerExecArgv(execArgv = process.execArgv) {
-  return (Array.isArray(execArgv) ? execArgv : []).filter((arg) => {
-    const value = String(arg);
-    if (value.startsWith('--input-type')) return false;
-    return !/^--(?:max-old-space-size|max-semi-space-size|initial-old-space-size)(?:=|$)/.test(value);
-  });
+  return workerExecArgv(execArgv);
 }
 
 function embeddingCacheKey(text, inputType, dtype = _configuredDtype) {

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

@@ -20,7 +20,6 @@ function waitForNextPass(ms, signal) {
 
 export async function drainEmbeddingReindex({
   flushEntries,
-  backfillCore = async () => 0,
   signal,
   pauseMs = DEFAULT_PASS_PAUSE_MS,
   wait = waitForNextPass,
@@ -45,8 +44,5 @@ export async function drainEmbeddingReindex({
     await wait(pauseMs, signal);
   }
 
-  throwIfAborted(signal);
-  const coreFilled = Number((await backfillCore({ signal })) ?? 0);
-  throwIfAborted(signal);
-  return { passes, attempted, succeeded, failed, coreFilled };
+  return { passes, attempted, succeeded, failed };
 }

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

@@ -61,7 +61,6 @@ export function createLifecycleRoutes({
         archived_roots: stats.archived_roots,
         unchunked_leaves: stats.unchunked_leaves,
         core_entries: stats.core_entries,
-        core_embed_null: stats.core_embed_null,
         cycle_running: cycleScheduler.getCycleRunning(),
         cycle_health: cycleScheduler.getCycleHealth(),
         cycle_backlog: cycleScheduler.getCycleBacklogSnapshot(),

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

@@ -32,7 +32,7 @@ export function createMaintenanceActions({ getDb, entryStats, getCycleLastRun })
       `entries: total=${stats.total} roots=${stats.roots} cycle1_raw=${stats.unchunked_leaves} (unchunked leaves)`,
       `status: ${stats.byStatus.map((r) => `${r.status ?? '?'}:${r.c}`).join(', ') || 'empty'}`,
       `categories: ${stats.byCategory.map((r) => `${r.category ?? 'NULL'}:${r.c}`).join(', ') || 'empty'}`,
-      `core_memory: user=${stats.core_entries} embed_null=${stats.core_embed_null}`,
+      `core_memory: user=${stats.core_entries}`,
       `embedding_index: ready dims=${dims}${dimsErr ? ` (meta_read_error: ${dimsErr})` : ''}`,
       `bootstrap: ${bootstrapComplete ? 'complete' : 'incomplete'}`,
       `last_cycle1: ${agoText(last.cycle1)}`,

package/src/runtime/memory/lib/memory-schema/core-and-meta.mjs

@@ -1,14 +1,14 @@
 /**
- * core-and-meta.mjs — core_entries, the meta key/value table, the cycle
- * state view and the bootstrap stamps that record which embedding model and
- * dimension the schema was built for.
+ * core-and-meta.mjs — core_entries, the meta key/value table and the
+ * bootstrap stamps that record which embedding model and dimension the schema
+ * was built for.
  */
 import { ensureCoreKeyIndex } from '../core-memory-uniqueness.mjs';
 
 const UPSERT_META = `INSERT INTO meta(key, value) VALUES ($1, $2::jsonb)
      ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`;
 
-export async function ensureCoreEntriesSchema(db, dimCount) {
+export async function ensureCoreEntriesSchema(db) {
   await db.exec(`
     CREATE TABLE IF NOT EXISTS core_entries (
       id          BIGSERIAL PRIMARY KEY,
@@ -16,16 +16,12 @@ export async function ensureCoreEntriesSchema(db, dimCount) {
       summary     TEXT NOT NULL,
       category    TEXT NOT NULL,
       project_id  TEXT,
-      embedding   halfvec(${dimCount}),
       created_at  BIGINT NOT NULL,
       updated_at  BIGINT NOT NULL
     )
   `);
   await db.exec(`CREATE INDEX IF NOT EXISTS core_entries_project_idx ON core_entries(project_id)`);
   await ensureCoreKeyIndex(db);
-  await db.exec(
-    `CREATE INDEX IF NOT EXISTS core_entries_embedding_hnsw ON core_entries USING hnsw (embedding halfvec_cosine_ops) WHERE embedding IS NOT NULL`
-  );
 }
 
 export async function ensureMetaSchema(db) {
@@ -35,20 +31,6 @@ export async function ensureMetaSchema(db) {
       value  JSONB NOT NULL
     )
   `);
-
-  // Operational view — used by /health and dashboards. One round-trip,
-  // covers the metrics that previously needed 6+ COUNT queries.
-  await db.exec(`
-    CREATE OR REPLACE VIEW v_cycle_state AS
-    SELECT
-      COUNT(*) FILTER (WHERE is_root = 1) AS roots,
-      COUNT(*) FILTER (WHERE is_root = 1 AND status = 'pending')  AS pending,
-      COUNT(*) FILTER (WHERE is_root = 1 AND status = 'active')   AS active,
-      COUNT(*) FILTER (WHERE is_root = 1 AND status = 'archived') AS archived,
-      COUNT(*) FILTER (WHERE chunk_root IS NULL)                  AS unclassified,
-      COUNT(*) AS total
-    FROM entries
-  `);
 }
 
 export async function stampBootstrapMeta(db, dimCount, embeddingIdentity) {