mixdog 1.0.4 → 1.0.6

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

@@ -2,7 +2,7 @@
 //
 // The write/maintenance action cluster and the `memory`/`search_memories`/
 // `recall` tool dispatch. Actions are grouped by responsibility under
-// memory-action-handlers/: cycle-driven (cycle1/cycle2/flush/rebuild/
+// memory-action-handlers/: cycle-driven (cycle1/flush/rebuild/
 // backfill), maintenance (status/prune/purge), `manage` (generated-history
 // roots) and `core` (user-curated entries). Live DB handle, config reader,
 // cycle scheduler primitives, cycle-LLM adapters, query handlers, and the
@@ -10,7 +10,7 @@
 // `db`, the scheduler, and lifecycle state.
 
 import { createToolCallHandler } from './tool-call-handler.mjs';
-import { throwIfAborted } from './memory-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
 import { createCycleActions } from './memory-action-handlers/cycle-actions.mjs';
 import { createMaintenanceActions } from './memory-action-handlers/maintenance-actions.mjs';
 import { createManageActions } from './memory-action-handlers/manage-actions.mjs';
@@ -28,8 +28,6 @@ export function createMemoryActionHandlers(deps) {
   const actions = {
     status: maintenance.status,
     cycle1: cycle.cycle1,
-    cycle2: cycle.cycle2,
-    sleep: cycle.cycle2,
     // Direct semantic-search surface for callers that want raw ranked rows
     // without going through the Lead-side recall synthesizer: the
     // handleSearch executor is exposed through the public `memory` tool

package/src/runtime/memory/lib/memory-cycle-requests.mjs

@@ -1,6 +1,6 @@
 import { __mixdogMemoryLog } from './memory-log.mjs';
 
-const VALID_CYCLES = new Set(['cycle1', 'cycle2']);
+const VALID_CYCLES = new Set(['cycle1']);
 const KEY_PREFIX = 'cycle_request.';
 const _retryTimersByDb = new WeakMap();
 

package/src/runtime/memory/lib/{memory-cycle2-shared.mjs → memory-cycle-shared.mjs}

@@ -1,6 +1,4 @@
-// Shared low-level helpers for the cycle2 cluster: logging, cancellation,
-// concurrency and store faults.
-// No cycle2 business logic; safe to import from any cycle2 sub-module.
+// Shared memory helpers: logging, cancellation, concurrency and store faults.
 
 import { __mixdogMemoryLog } from './memory-log.mjs';
 export { __mixdogMemoryLog };
@@ -9,8 +7,13 @@ export function throwIfAborted(signal) {
   if (signal?.aborted) throw signal.reason ?? new Error('aborted');
 }
 
-// Tiny inline semaphore — bounds cycle fan-out (cycle1 windows, cycle2 review
-// packets). One implementation so the two concurrency caps cannot drift.
+export function parseInterval(value) {
+  const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(String(value).trim());
+  if (!match) throw new Error(`[memory-cycle] invalid interval config: ${value}`);
+  return Number(match[1]) * { ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[match[2]];
+}
+
+// Bounds concurrent summarization windows.
 export function createSemaphore(limit) {
   const cap = Math.max(1, Number(limit) || 1);
   let active = 0;
@@ -31,12 +34,11 @@ export function createSemaphore(limit) {
   };
 }
 
-// Two error classes travel through the cycle2 apply paths and must never be
-// confused:
+// Store failures must not be confused with rejected or cancelled work:
 //   * STORE FAULT — the database itself failed the write (transaction rolled
-//     back, or its COMMIT outcome is unknown). Nothing about the verdict was
-//     wrong, and the store's state is no longer known, so the run stops.
-//   * verdict rejection — a guard refused the mutation (stale snapshot, status
+//     back, or its COMMIT outcome is unknown). The store's state is no longer
+//     known, so the run stops.
+//   * rejection — a guard refused the mutation (stale snapshot, status
 //     moved, content changed). The store is healthy;
 //     these return normally and are counted as ordinary rejections/errors.
 // Only writers raise store faults, via markStoreFault; callers branch on
@@ -49,12 +51,8 @@ export function createSemaphore(limit) {
 // reclassified because of how its text happens to read, and a store fault keeps
 // the original message verbatim so logs stay honest.
 //
-// Boundaries this signal actually crosses: none that serialize. The writer
-// (applyHistoryReview) throws and the cycle2 apply loop catches it in the
-// same process, same module registry, same
-// tick. runCycle2 converts it at its own boundary into a plain
-// { ok: false, error: <string>, storeFault: <boolean> } result, so the explicit
-// boolean — not a re-parsed Error — is what any IPC/worker hop carries onward.
+// Embedding writers use this classification to retain ambiguous commit and
+// rollback failures without disguising them as an empty successful flush.
 export const MEMORY_STORE_FAULT_CODE = 'MEMORY_STORE_FAULT';
 
 export class MemoryStoreFault extends Error {

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

@@ -1,9 +1,10 @@
-// Search-history maintenance: summarization and relationship/index maintenance.
+// Search-history maintenance: summarization and embedding maintenance.
 export {
   syncRootEmbedding,
   flushEmbeddingDirty,
+  flushSearchEmbeddings,
   flushRawEmbeddings,
   inferChunkProjectId,
 } from './memory-embed.mjs';
 export { runCycle1 } from './memory-cycle1.mjs';
-export { runCycle2, parseInterval } from './memory-cycle2.mjs';
+export { parseInterval } from './memory-cycle-shared.mjs';

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

@@ -2,7 +2,7 @@
 // the advisory lock and request coalescing; _runCycle1Impl orchestrates one
 // run out of the cycle1/ modules (plan, rows, window, result).
 import { __mixdogMemoryLog } from './memory-log.mjs';
-import { createSemaphore, throwIfAborted } from './memory-cycle2-shared.mjs';
+import { createSemaphore, throwIfAborted } from './memory-cycle-shared.mjs';
 
 import { CYCLE1_INPUT_TOKEN_BUDGET, cycle1SourceBudget, partitionCycle1Rows } from './memory-chunk-quality.mjs';
 import { callAgentDispatch } from './agent-ipc.mjs';

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

@@ -4,7 +4,7 @@ import { embedTexts, getEmbeddingModelId, holdEmbeddingWarm } from './embedding-
 import { embeddingToSql } from './memory.mjs';
 import { createHash } from 'node:crypto';
 import { pruneEmbeddingCache, resolveEmbeddingCacheMaxRows } from './embedding-cache-retention.mjs';
-import { throwIfAborted, markStoreFault } from './memory-cycle2-shared.mjs';
+import { throwIfAborted, markStoreFault } from './memory-cycle-shared.mjs';
 
 // Restart-survivable embedding dedup cache (DDL created on first flush).
 // Keyed per-db handle so a second DB instance in the same process re-runs the
@@ -635,6 +635,19 @@ async function syncBatchEmbeddings(db, ids, options = {}) {
   return writtenIds;
 }
 
+// Explicit maintenance must propagate partial failures and caller cancellation,
+// including callers sharing a flush that was started without their signal.
+export async function flushSearchEmbeddings(db, options = {}) {
+  const result = await flushEmbeddingDirty(db, options);
+  throwIfAborted(options.signal);
+  if (result?.timedOut || result?.failed?.length) {
+    throw new Error(
+      `embedding maintenance incomplete: failed=${result.failed?.length || 0} timedOut=${Boolean(result.timedOut)}`
+    );
+  }
+  return result;
+}
+
 // Embeds one root; true when its fresh vector was written.
 export async function syncRootEmbedding(db, rootId, options = {}) {
   const writtenIds = await syncBatchEmbeddings(db, [rootId], options);

package/src/runtime/memory/lib/memory-ops-policy.mjs

@@ -3,7 +3,8 @@ import { __mixdogMemoryLog } from './memory-log.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { mixdogHome } from '../../shared/plugin-paths.mjs';
-import { throwIfAborted } from './memory-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
+import { flushSearchEmbeddings } from './memory-embed.mjs';
 import { isSkippedWatchPath, isTranscriptJsonlName } from './ingest/transcript-discovery.mjs';
 
 function normalizeBackfillWindow(value) {
@@ -80,7 +81,7 @@ export async function runFullBackfill(
     ingestTranscriptFile,
     cwdFromTranscriptPath,
     runCycle1,
-    runCycle2,
+    flushEmbeddings = flushSearchEmbeddings,
     now = Date.now(),
     projectsRoot = null,
     workspaceCwd = null,
@@ -91,8 +92,8 @@ export async function runFullBackfill(
   if (typeof ingestTranscriptFile !== 'function') {
     throw new Error('runFullBackfill: ingestTranscriptFile required');
   }
-  if (typeof runCycle1 !== 'function' || typeof runCycle2 !== 'function') {
-    throw new Error('runFullBackfill: runCycle1/runCycle2 required');
+  if (typeof runCycle1 !== 'function') {
+    throw new Error('runFullBackfill: runCycle1 required');
   }
 
   const normalizedWindow = normalizeBackfillWindow(window);
@@ -158,16 +159,13 @@ export async function runFullBackfill(
     prevUnclassified = nextUnclassified;
   }
 
-  let reviewed = 0;
   try {
     throwIfAborted(signal);
-    const c2 = await runCycle2(db, config?.cycle2 || {}, { signal });
-    reviewed = Number(c2?.processed ?? 0);
-    if (c2?.ok === false) throw new Error(c2.error || 'cycle2 failed');
+    await flushEmbeddings(db, { signal });
   } catch (err) {
     throwIfAborted(signal);
-    errors.push({ stage: 'cycle2', error: err.message });
-    __mixdogMemoryLog(`[backfill] cycle2 error: ${err.message}\n`);
+    errors.push({ stage: 'embedding', error: err.message });
+    __mixdogMemoryLog(`[backfill] embedding error: ${err.message}\n`);
   }
 
   const unclassified = await countUnclassified(db);
@@ -179,7 +177,6 @@ export async function runFullBackfill(
     files: selected.length,
     ingested,
     cycle1_iters: cycle1Iters,
-    reviewed,
     unclassified,
   };
 }

package/src/runtime/memory/lib/memory-schema/entries.mjs

@@ -27,7 +27,6 @@ export async function ensureEntriesSchema(db, dimCount) {
       score         REAL,
       last_seen_at  BIGINT,
       reviewed_at   BIGINT,
-      cycle2_reviewed_at BIGINT,
       error_count   INTEGER NOT NULL DEFAULT 0,
       embedding     halfvec(${dimCount}),
       summary_hash  TEXT,

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

@@ -265,18 +265,14 @@ export async function ensureCurrentSchemaExtensions(db, dims, embeddingIdentity
     );
   }
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS chunk_quality jsonb`);
-  // Separate maintenance progress from legacy importance/status verdicts.
-  // Existing content and classification values remain untouched.
-  await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS cycle2_reviewed_at bigint`);
+  // Existing retired review metadata is left untouched, but no longer created.
+  // Preserve the search relationships used by recall.
   await db.exec(
     `ALTER TABLE entries ADD COLUMN IF NOT EXISTS duplicate_of bigint REFERENCES entries(id) ON DELETE SET NULL`
   );
   await db.exec(
     `CREATE INDEX IF NOT EXISTS idx_entries_duplicate_of ON entries(duplicate_of) WHERE duplicate_of IS NOT NULL`
   );
-  await db.exec(
-    `CREATE INDEX IF NOT EXISTS idx_entries_cycle2_unreviewed ON entries(ts DESC, id DESC) WHERE is_root = 1 AND cycle2_reviewed_at IS NULL`
-  );
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS time_source text`);
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS concept_id bigint`);
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS supersedes_id bigint`);

package/src/runtime/memory/lib/pg/adapter.mjs

@@ -50,7 +50,7 @@ function installPoolErrorHandler(pool, label, { onConnectionLoss } = {}) {
   const logRecoveryFailure = (recoverErr) =>
     __mixdogMemoryLog(`[pg-adapter] ${label} client-error recovery failed: ${recoverErr?.message || recoverErr}\n`);
   // pg-pool deliberately removes its idle error listener while a Client is
-  // checked out. Long-running advisory-lock owners (cycle1/2) can therefore
+  // checked out. Long-running advisory-lock owners (cycle1) can therefore
   // receive a socket-end `error` between queries with no listener at all,
   // which Node treats as an uncaught exception. Give every physical Client a
   // permanent last-resort listener; pg-pool's own idle listener still owns

package/src/runtime/memory/lib/query-handlers.mjs

@@ -26,7 +26,7 @@ import { readRawRowsInWindow } from './query-raw-window.mjs';
 import { recallSessionRows } from './query-session-recall.mjs';
 import { recallCoreRows } from './query-core-recall.mjs';
 import { browseEntries } from './query-window-browse.mjs';
-import { throwIfAborted } from './memory-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
 
 /** Cold-recall log throttle: one line per 10s window per memory runtime. */
 function createColdRecallNote(log) {

package/src/runtime/memory/lib/query-hybrid-search.mjs

@@ -11,7 +11,7 @@ import {
 import { searchRelevantHybrid } from './memory-recall-store.mjs';
 import { retrieveEntries } from './memory-retrievers.mjs';
 import { compareRecallByScore, compareRecallNewestFirst } from './recall-order.mjs';
-import { throwIfAborted } from './memory-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
 import { expandRecallEventContext } from './recall-event-context.mjs';
 import { insertTraceEvents } from './trace-store.mjs';
 import {

package/src/runtime/memory/lib/query-maintenance-handlers.mjs

@@ -150,11 +150,6 @@ export function createQueryMaintenanceHandlers({ getDb }) {
         await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'archived'`)
       ).rows[0].c;
       const unchunked_leaves = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL`)).rows[0].c;
-      const cycle2_pending_roots = (
-        await tx.query(
-          `SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND cycle2_reviewed_at IS NULL AND duplicate_of IS NULL`
-        )
-      ).rows[0].c;
       const core_entries = (await tx.query(`SELECT COUNT(*) c FROM core_entries`)).rows[0].c;
       const core_embed_null = (await tx.query(`SELECT COUNT(*) c FROM core_entries WHERE embedding IS NULL`)).rows[0].c;
       const byStatus = (await tx.query(`SELECT status, COUNT(*) c FROM entries WHERE is_root = 1 GROUP BY status`))
@@ -168,7 +163,6 @@ export function createQueryMaintenanceHandlers({ getDb }) {
         active_roots,
         archived_roots,
         unchunked_leaves,
-        cycle2_pending_roots,
         core_entries,
         core_embed_null,
         byStatus,

package/src/runtime/memory/lib/recall-format.mjs

@@ -307,7 +307,7 @@ function rowMembers(r, { includeRootSource, sourceWindow }) {
 
 // Chunks present: each member is its own line. The root row is a grouping
 // artifact for retrieval — the caller wants the chunk content (cycle1 raw),
-// not the cycle2-compressed summary.
+// not the stored summary.
 function memberUnits(r, members, render, preserveSource) {
   return members.map((m, memberIndex) => {
     const source = String(m.content ?? '');