mixdog 1.0.4 → 1.0.5

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

@@ -1,24 +1,21 @@
 /**
  * memory-action-handlers/cycle-backfill-action.mjs — the backfill action: one
  * driver run over a transcript window, with the whole-action mutex and the
- * per-iteration cancel checkpoints the driver's cycle1/cycle2 callbacks need.
+ * per-iteration cancel checkpoints the driver's cycle1 callback needs.
  */
-import { runCycle2 } from '../memory-cycle.mjs';
 import { runFullBackfill } from '../memory-ops-policy.mjs';
-import { throwIfAborted } from '../memory-cycle2-shared.mjs';
+import { throwIfAborted } from '../memory-cycle-shared.mjs';
 
 export function createBackfillAction({
   getDb,
   dataDir,
   awaitCycle1Run,
-  finalizeCycle2Run,
-  withCycle2Llm,
   ingestTranscriptFile,
   cwdFromTranscriptPath,
 }) {
   // Whole-action backfill mutex (transport-agnostic). memory-cycle1's
   // _runCycle1InFlight only protects cycle1; ingest workers
-  // (memory-ops-policy.mjs) and cycle2 can still overlap if a second backfill
+  // (memory-ops-policy.mjs) can still overlap if a second backfill
   // kicks in (timeout-retry, parallel callers, /api/tool vs /mcp vs
   // /admin/backfill). Track the in-flight promise here and reject overlaps
   // with 409.
@@ -35,10 +32,6 @@ export function createBackfillAction({
     const window = args.window != null ? String(args.window) : '7d';
     const scope = args.scope != null ? String(args.scope) : 'all';
     const limit = args.limit != null ? Math.max(1, Number(args.limit)) : null;
-    // Capture the cycle2 envelope so it routes through finalizeCycle2Run
-    // (which records cycle2_last_error and clears scheduler delay only on
-    // ok:true) rather than stamping cycle2 unconditionally afterward.
-    let capturedCycle2;
     const promise = runFullBackfill(db, {
       signal,
       window,
@@ -48,21 +41,15 @@ export function createBackfillAction({
       dataDir,
       ingestTranscriptFile,
       cwdFromTranscriptPath,
-      // Re-check the IPC cancel signal at every cycle1/cycle2 iteration the
+      // Re-check the IPC cancel signal at every cycle1 iteration the
       // backfill driver dispatches. handleMemoryAction only checks once
       // before dispatch; without per-iteration checkpoints a long-running
-      // backfill keeps spinning through ingest + cycle1 + cycle2 batches
+      // backfill keeps spinning through ingest + cycle1 batches
       // after the proxy has already responded "cancelled" to the caller.
       runCycle1: (_dbArg, cycle1Config = {}, options = {}, _dir) => {
         throwIfAborted(signal);
         return awaitCycle1Run(cycle1Config, { ...options, signal });
       },
-      runCycle2: async (dbArg, c2Config, c2Options) => {
-        throwIfAborted(signal);
-        const r2 = await runCycle2(dbArg, c2Config, withCycle2Llm({ ...c2Options, signal }));
-        capturedCycle2 = r2;
-        return r2;
-      },
     });
     backfillInFlight = promise;
     let result;
@@ -72,11 +59,8 @@ export function createBackfillAction({
       if (backfillInFlight === promise) backfillInFlight = null;
     }
     throwIfAborted(signal);
-    if (capturedCycle2) {
-      await finalizeCycle2Run(capturedCycle2);
-    }
     return {
-      text: `backfill: window=${result.window} scope=${result.scope} files=${result.files} ingested=${result.ingested} cycle1_iters=${result.cycle1_iters} reviewed=${result.reviewed} unclassified=${result.unclassified}${result.error ? ` error=${result.error}` : ''}`,
+      text: `backfill: window=${result.window} scope=${result.scope} files=${result.files} ingested=${result.ingested} cycle1_iters=${result.cycle1_iters} unclassified=${result.unclassified}${result.error ? ` error=${result.error}` : ''}`,
       isError: result.ok === false,
     };
   };

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

@@ -1,12 +1,12 @@
 /**
  * memory-action-handlers/cycle-rebuild-action.mjs — the destructive rebuild:
  * drain whatever cycle1 is still running, truncate every classification
- * column in one transaction, then re-run cycle1 and cycle2 over the reset
+ * column in one transaction, then re-run cycle1 over the reset
  * rows. The confirm phrase is the only guard the caller gets.
  */
-import { runCycle2 } from '../memory-cycle.mjs';
+import { flushSearchEmbeddings } from '../memory-cycle.mjs';
 import { getInFlightCycle1 } from '../memory-cycle1.mjs';
-import { throwIfAborted } from '../memory-cycle2-shared.mjs';
+import { throwIfAborted } from '../memory-cycle-shared.mjs';
 
 // Every root-classification column, cleared before demotion. Cleanup must run
 // BEFORE demotion: demoting normal roots (chunk_root = id) first and then
@@ -18,7 +18,7 @@ const REBUILD_RESET_ROOTS = `
         SET element = NULL, category = NULL, summary = NULL,
             status = 'pending', score = NULL, last_seen_at = NULL,
             embedding = NULL, summary_hash = NULL,
-            reviewed_at = NULL, cycle2_reviewed_at = NULL, duplicate_of = NULL,
+            reviewed_at = NULL, duplicate_of = NULL,
             error_count = 0
         WHERE is_root = 1
       `;
@@ -28,7 +28,7 @@ const REBUILD_RESET_LEAVES = `
             element = NULL, category = NULL, summary = NULL,
             score = NULL, last_seen_at = NULL,
             embedding = NULL, summary_hash = NULL,
-            reviewed_at = NULL, cycle2_reviewed_at = NULL, duplicate_of = NULL,
+            reviewed_at = NULL, duplicate_of = NULL,
             error_count = 0
         WHERE is_root = 0
       `;
@@ -52,18 +52,12 @@ async function drainCycle1(db, getSchedulerCycle1InFlight) {
   }
 }
 
-export function createRebuildAction({
-  getDb,
-  startCycle1Run,
-  finalizeCycle2Run,
-  getSchedulerCycle1InFlight,
-  withCycle2Llm,
-}) {
+export function createRebuildAction({ getDb, startCycle1Run, getSchedulerCycle1InFlight }) {
   return async function rebuild(args, config, signal) {
     const db = getDb();
     if (args.confirm !== 'REBUILD MEMORY') {
       return {
-        text: 'rebuild requires confirm: "REBUILD MEMORY" (truncates classification columns and re-runs cycles)',
+        text: 'rebuild requires confirm: "REBUILD MEMORY" (truncates classification columns and re-runs summarization)',
         isError: true,
       };
     }
@@ -84,11 +78,10 @@ export function createRebuildAction({
     // and guarantees the newly demoted rows are read.
     const r1 = await startCycle1Run(config?.cycle1 || {}, { signal });
     throwIfAborted(signal);
-    const r2 = await runCycle2(db, config?.cycle2 || {}, withCycle2Llm({ signal }));
-    await finalizeCycle2Run(r2);
+    const embeddings = await flushSearchEmbeddings(db, { signal });
+    throwIfAborted(signal);
     return {
-      text: `rebuild: cycle1 chunks=${r1.chunks} processed=${r1.processed}, cycle2 ${JSON.stringify(r2)}`,
-      isError: r2.ok === false,
+      text: `rebuild: cycle1 chunks=${r1.chunks} processed=${r1.processed}, embeddings=${embeddings.succeeded}`,
     };
   };
 }

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

@@ -29,15 +29,13 @@ export function createMaintenanceActions({ getDb, entryStats, getCycleLastRun })
     const { dims, dimsErr } = await embeddingDims(db);
     const bootstrapComplete = await isBootstrapComplete(db);
     const lines = [
-      `entries: total=${stats.total} roots=${stats.roots} cycle1_raw=${stats.unchunked_leaves} (unchunked leaves) cycle2_pending=${stats.cycle2_pending_roots} (awaiting cycle2 review)`,
+      `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}`,
       `embedding_index: ready dims=${dims}${dimsErr ? ` (meta_read_error: ${dimsErr})` : ''}`,
       `bootstrap: ${bootstrapComplete ? 'complete' : 'incomplete'}`,
       `last_cycle1: ${agoText(last.cycle1)}`,
-      `last_cycle2: ${agoText(last.cycle2)}`,
-      ...(last.cycle2_last_error ? [`last_cycle2_error: ${last.cycle2_last_error}`] : []),
     ];
     return { text: lines.join('\n') };
   }

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

@@ -154,14 +154,12 @@ export function createManageActions({ getDb, log }) {
       await db.transaction(async (tx) => {
         // Editing either side invalidates the duplicate equivalence, not
         // the original chunks or their lineage.
-        await tx.query(`UPDATE entries SET duplicate_of = NULL, cycle2_reviewed_at = NULL WHERE duplicate_of = $1`, [
-          id,
-        ]);
+        await tx.query(`UPDATE entries SET duplicate_of = NULL WHERE duplicate_of = $1`, [id]);
         await tx.query(
           `
               UPDATE entries
               SET element = $1, summary = $2, category = $3, score = $4,
-                  last_seen_at = $5, content = $6, cycle2_reviewed_at = NULL, duplicate_of = NULL
+                  last_seen_at = $5, content = $6, duplicate_of = NULL
               WHERE id = $7
             `,
           [finalElement, finalSummary, finalCategory, score, nowMs, composedContent, id]

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 ?? '');