mixdog 1.0.8 → 1.0.9

package/src/runtime/computer-bridge/result-canonical.mjs

@@ -0,0 +1,181 @@
+import { computerResultRecovery } from './error-recovery.mjs';
+
+const ACT_STEP_STATUSES = new Set(['succeeded', 'failed', 'skipped', 'pending', 'uncertain']);
+
+function canonicalizeActResult(value, args) {
+  value.completed_actions = value.completed_steps;
+  value.total_actions = value.total_steps;
+  const canonicalStep = (row, index) => {
+    const normalized = { ...row };
+    normalized.type = args.input?.actions?.[index]?.type || normalized.action;
+    if (!ACT_STEP_STATUSES.has(normalized.status)) {
+      normalized.status = normalized.ok === false ? 'failed' : 'succeeded';
+    }
+    delete normalized.action;
+    delete normalized.ok;
+    return normalized;
+  };
+  value.actions = Array.isArray(value.steps) ? value.steps.map(canonicalStep) : value.steps;
+  // A single-window act reports the same transition on the act and its step.
+  const transition = JSON.stringify(value.window_transition);
+  for (const row of Array.isArray(value.actions) ? value.actions : []) {
+    if (transition && JSON.stringify(row?.window_transition) === transition) delete row.window_transition;
+  }
+  delete value.completed_steps;
+  delete value.total_steps;
+  delete value.steps;
+}
+
+// Host diagnostics stay in the host's run record; the model acts on none of them.
+const HOST_DIAGNOSTIC_FIELDS = ['timings_ms', 'capture_attempts'];
+
+function dropHostDiagnostics(value) {
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    for (const item of value) dropHostDiagnostics(item);
+    return;
+  }
+  for (const field of HOST_DIAGNOSTIC_FIELDS) delete value[field];
+  for (const item of Object.values(value)) dropHostDiagnostics(item);
+}
+
+// Elements and OCR text reach the model one line each, the shape browser
+// snapshots use, because a field name costs more than the value it labels:
+// `#mark [ref] Role "name" value="…" state=… source=… disabled focused
+// @x,y,width,height actions`. Flags appear only when they differ from the
+// common case the capture description states (an enabled UIA element), and
+// the geometry a som frame repeats as x/y/width/height, center and
+// screen_bounds collapses into its one bounds box.
+const DERIVED_GEOMETRY_FIELDS = new Set([
+  'x',
+  'y',
+  'width',
+  'height',
+  'center_x',
+  'center_y',
+  'center',
+  'screen_bounds',
+]);
+
+const quotedText = (text) => JSON.stringify(String(text));
+const bareText = (text) => (/^[^\s"]+$/.test(String(text)) ? String(text) : quotedText(text));
+const isUnsetField = (field) =>
+  field === undefined || field === null || field === '' || field === false || (Array.isArray(field) && !field.length);
+
+function boundsText(box) {
+  return box.length === 4 && box.every((edge) => Number.isFinite(edge)) ? `@${box.join(',')}` : null;
+}
+
+function extraFieldTexts(rest) {
+  return Object.entries(rest)
+    .filter(([key, field]) => !DERIVED_GEOMETRY_FIELDS.has(key) && !isUnsetField(field))
+    .map(([key, field]) => `${key}=${typeof field === 'string' ? bareText(field) : JSON.stringify(field)}`);
+}
+
+function elementLine(element) {
+  if (!element || typeof element !== 'object') return element;
+  const { mark, ref, role, name, value, state, source, enabled, has_keyboard_focus, bounds, actions, ...rest } =
+    element;
+  return [
+    isUnsetField(mark) ? null : `#${mark}`,
+    isUnsetField(ref) ? null : `[${ref}]`,
+    bareText(role || 'Unknown'),
+    quotedText(name ?? ''),
+    isUnsetField(value) ? null : `value=${quotedText(value)}`,
+    isUnsetField(state) || state === source ? null : `state=${bareText(state)}`,
+    isUnsetField(source) || source === 'uia' ? null : `source=${bareText(source)}`,
+    enabled === false ? 'disabled' : null,
+    has_keyboard_focus === true ? 'focused' : null,
+    boundsText(Array.isArray(bounds) ? bounds : [rest.x, rest.y, rest.width, rest.height]),
+    Array.isArray(actions) && actions.length ? actions.join(',') : null,
+    ...extraFieldTexts(rest),
+  ]
+    .filter(Boolean)
+    .join(' ');
+}
+
+function ocrTextLine(row) {
+  if (!row || typeof row !== 'object') return row;
+  const { mark, text, line, x, y, width, height, ...rest } = row;
+  return [
+    isUnsetField(mark) ? null : `#${mark}`,
+    quotedText(text ?? ''),
+    boundsText([x, y, width, height]),
+    isUnsetField(line) ? null : `line=${line}`,
+    ...extraFieldTexts(rest),
+  ]
+    .filter(Boolean)
+    .join(' ');
+}
+
+function renderObservationLines(frame) {
+  if (!frame || typeof frame !== 'object') return;
+  if (Array.isArray(frame.elements)) frame.elements = frame.elements.map(elementLine);
+  for (const key of ['lines', 'words']) {
+    if (Array.isArray(frame.ocr?.[key])) frame.ocr[key] = frame.ocr[key].map(ocrTextLine);
+  }
+}
+
+export function canonicalComputerResultText(text, args) {
+  if (args.action === 'clipboard' && args.input?.operation === 'read') return text;
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.action !== 'string') {
+    return text;
+  }
+  value.action = args.action;
+  if (args.action === 'list') value.kind = args.input?.kind;
+  if (args.action === 'capture') value.mode = args.input?.mode || 'state';
+  if (args.action === 'window') value.operation = args.input?.operation;
+  if (args.action === 'clipboard') value.operation = args.input?.operation;
+  if (args.action === 'act') canonicalizeActResult(value, args);
+  if (value.capture_after && value.observation === undefined) {
+    value.observation = value.capture_after;
+    delete value.capture_after;
+  }
+  dropHostDiagnostics(value);
+  renderObservationLines(value);
+  renderObservationLines(value.observation);
+  if (value.ok === false && value.recovery === undefined) {
+    const recovery = computerResultRecovery(value, args);
+    if (recovery) value.recovery = recovery;
+  }
+  return JSON.stringify(value);
+}
+
+// A capture payload reports the frame's real pixel size (`width`/`height`,
+// nested under `observation` for action replies). Carrying it on the image
+// block lets the context estimator bill a screenshot at its true vision cost
+// instead of the flat unknown-image allowance. Provider normalizers rebuild
+// the wire block from `type`/`source` alone, so these fields never reach an
+// API and never shift the cached prefix.
+export function computerImageDimensions(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  for (const frame of [value, value?.observation]) {
+    const width = Number(frame?.width);
+    const height = Number(frame?.height);
+    if (width > 0 && height > 0 && Number.isFinite(width) && Number.isFinite(height)) return { width, height };
+  }
+  return null;
+}
+
+export function canonicalComputerResultIsError(text, args) {
+  if (args.action === 'clipboard' && args.input?.operation === 'read') return false;
+  try {
+    const value = JSON.parse(text);
+    return Boolean(
+      value && typeof value === 'object' && !Array.isArray(value) && value.action === args.action && value.ok === false
+    );
+  } catch {
+    return false;
+  }
+}

package/src/runtime/local-provider/asset-installer.mjs

@@ -143,18 +143,26 @@ export async function downloadVerifiedLocalAsset(
   return destination;
 }
 
-async function extractZip(zipPath, destination, signal) {
-  signal?.throwIfAborted();
+// The Windows builds ship as zips (PowerShell's Expand-Archive); the macOS
+// build is a gzipped tarball, which the system tar unpacks.
+function extractCommand(archive, destination) {
+  if (!archive.endsWith('.zip')) return ['tar', ['-xzf', archive, '-C', destination], process.env];
   const command = [
     "$ErrorActionPreference = 'Stop'",
     'Expand-Archive -LiteralPath $env:MIXDOG_LOCAL_ARCHIVE -DestinationPath $env:MIXDOG_LOCAL_DESTINATION -Force',
   ].join('; ');
-  const child = spawn('powershell', ['-NoProfile', '-NonInteractive', '-Command', command], {
-    env: {
-      ...process.env,
-      MIXDOG_LOCAL_ARCHIVE: zipPath,
-      MIXDOG_LOCAL_DESTINATION: destination,
-    },
+  return [
+    'powershell',
+    ['-NoProfile', '-NonInteractive', '-Command', command],
+    { ...process.env, MIXDOG_LOCAL_ARCHIVE: archive, MIXDOG_LOCAL_DESTINATION: destination },
+  ];
+}
+
+async function extractArchive(archive, destination, signal) {
+  signal?.throwIfAborted();
+  const [command, args, env] = extractCommand(archive, destination);
+  const child = spawn(command, args, {
+    env,
     windowsHide: true,
     signal,
     stdio: ['ignore', 'pipe', 'pipe'],
@@ -184,7 +192,9 @@ async function installRuntimeInternal({ dataDir, onProgress, fetchFn, signal })
   signal?.throwIfAborted();
   const entry = localProviderRuntimePlatformEntry();
   if (!entry || !localProviderCatalogStatus({ dataDir, hardware }).available) {
-    throw new Error('[local-provider] Windows x64 with a compatible NVIDIA RTX GPU is required');
+    throw new Error(
+      '[local-provider] Windows x64 with a compatible NVIDIA RTX GPU, or an Apple Silicon Mac with enough memory, is required'
+    );
   }
   const target = localProviderRuntimeDirectory(dataDir);
   const executable = join(target, entry.executable);
@@ -217,7 +227,7 @@ async function installRuntimeInternal({ dataDir, onProgress, fetchFn, signal })
         totalBytes: entry.downloadBytes,
         percent: Math.min(99, Math.round(((completedBytes + asset.size) / entry.downloadBytes) * 100)),
       });
-      await extractZip(archive, staging, signal);
+      await extractArchive(archive, staging, signal);
       completedBytes += asset.size;
     }
     if (!existsSync(join(staging, entry.executable))) {

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

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 
 import { resolvePluginData } from '../shared/plugin-paths.mjs';
 import { localProviderDiskStatus, partialAssetBytes } from './asset-storage.mjs';
-import { localProviderHardwareStatus } from './hardware.mjs';
+import { localProviderHardwareStatus, localProviderPlatformKey } from './hardware.mjs';
 import { registeredLocalModels } from './registered-models.mjs';
 import { localModelState } from './model-state.mjs';
 import { localContextSettings } from './context-settings.mjs';
@@ -24,12 +24,8 @@ export function localProviderModelRoot(dataDir = resolvePluginData()) {
   return join(dataDir, 'local-provider', 'models');
 }
 
-function localProviderRuntimePlatformKey(platform = process.platform, arch = process.arch) {
-  return platform === 'win32' && arch === 'x64' ? 'win32-x64-nvidia' : '';
-}
-
 export function localProviderRuntimePlatformEntry(options = {}) {
-  const key = localProviderRuntimePlatformKey(options.platform, options.arch);
+  const key = localProviderPlatformKey(options.platform, options.arch);
   const entry = key ? LOCAL_PROVIDER_MANIFEST.runtime?.platforms?.[key] : null;
   return entry ? { key, ...entry } : null;
 }
@@ -109,7 +105,8 @@ export function localProviderCatalogStatus({
   const executable = localProviderRuntimeExecutable(dataDir, { platform, arch });
   const models = localProviderModelEntries(dataDir).map((entry) => publicModel(entry, dataDir, hardware));
   return {
-    available: Boolean(platformEntry && hardware?.gpu?.vendor === 'NVIDIA' && models.some((entry) => entry.compatible)),
+    platformSupported: Boolean(platformEntry),
+    available: Boolean(platformEntry && hardware?.supported && models.some((entry) => entry.compatible)),
     runtime: {
       installed: Boolean(executable && existsSync(executable)),
       version: LOCAL_PROVIDER_MANIFEST.runtime.version,

package/src/runtime/local-provider/data/manifest.json

@@ -23,6 +23,19 @@
             "sha256": "8c79a9b226de4b3cacfd1f83d24f962d0773be79f1e7b75c6af4ded7e32ae1d6"
           }
         ]
+      },
+      "darwin-arm64-metal": {
+        "executable": "llama-b10621/llama-server",
+        "backend": "Metal",
+        "downloadBytes": 10954823,
+        "assets": [
+          {
+            "name": "llama-b10621-bin-macos-arm64.tar.gz",
+            "url": "https://github.com/ggml-org/llama.cpp/releases/download/b10621/llama-b10621-bin-macos-arm64.tar.gz",
+            "size": 10954823,
+            "sha256": "429c8270608600188035e5e92f7d78dffb7900904fe7dd7e6a84f48068cd13cf"
+          }
+        ]
       }
     }
   },
@@ -30,7 +43,7 @@
     {
       "id": "qwen3.8-27b-q4-k-m",
       "name": "Qwen3.8 27B Q4_K_M",
-      "description": "Recommended coding and tool-use model for NVIDIA RTX GPUs with 24 GB VRAM.",
+      "description": "Recommended coding and tool-use model for GPUs with 24 GB of memory.",
       "filename": "Qwen3.8-27B-Q4_K_M.gguf",
       "url": "https://huggingface.co/ggml-org/Qwen3.8-27B-GGUF/resolve/0669b98607d47046c7c2b3f801011d54a08cfccf/Qwen3.8-27B-Q4_K_M.gguf?download=true",
       "revision": "0669b98607d47046c7c2b3f801011d54a08cfccf",

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.