mixdog 1.0.4 → 1.0.6

package/src/runtime/attachments/pdf-extract.mjs

@@ -48,13 +48,17 @@ function pageBodyText(content) {
     if (typeof item?.str !== 'string') continue;
     if (item.str) {
       const placement = runPlacement(item);
+      // A run on another baseline is another line even when the writer marked no line end (a browser's
+      // print does not): "784" over its label read as "784office". A baseline shift under half the
+      // smaller run's size (a superscript, a mixed-size run) stays on the line.
+      const shift = placement && cursor ? Math.abs(placement.line - cursor.line) : 0;
+      const newLine = shift > Math.min(placement?.size || 0, cursor?.size || 0) * 0.5;
+      if (newLine && body && !body.endsWith('\n')) body += '\n';
       // A writer splits one word into several runs for kerning, and a
       // Korean line into a run per token; joining those with a space
       // invents "2026 년". Only a gap the page itself leaves is a space.
       const separated =
-        placement && cursor && placement.line === cursor.line
-          ? placement.start - cursor.end > cursor.size * 0.22
-          : !placement || !cursor;
+        placement && cursor && !newLine ? placement.start - cursor.end > cursor.size * 0.22 : !placement || !cursor;
       const glued = !body || body.endsWith('\n') || body.endsWith(' ') || item.str.startsWith(' ') || !separated;
       body += (glued ? '' : ' ') + item.str;
       cursor = placement;

package/src/runtime/computer-bridge/client.mjs

@@ -411,7 +411,7 @@ function computerToolResult(value, args) {
   }
   return {
     content,
-    ...(canonicalComputerResultIsError(text, args) ? { isError: true } : {}),
+    ...(value.isError === true || canonicalComputerResultIsError(text, args) ? { isError: true } : {}),
   };
 }
 

package/src/runtime/memory/index.mjs

@@ -51,7 +51,7 @@ import {
   shutdownEmbeddingProvider,
   warmupEmbeddingProvider,
 } from './lib/embedding-provider.mjs';
-import { runCycle1, runCycle2, parseInterval, flushEmbeddingDirty, flushRawEmbeddings } from './lib/memory-cycle.mjs';
+import { runCycle1, parseInterval, flushEmbeddingDirty, flushRawEmbeddings } from './lib/memory-cycle.mjs';
 import { callAgentDispatch } from './lib/agent-ipc.mjs';
 import {
   cancelCoalescedCycleRetries,
@@ -73,7 +73,7 @@ import {
 import { writeJsonAtomicSync } from '../shared/atomic-file.mjs';
 import { safeIpcSend } from '../shared/safe-ipc-send.mjs';
 import { resolvePluginData, mixdogHome } from '../shared/plugin-paths.mjs';
-import { scheduledCycle1Signature, scheduledCycle2Signature } from './lib/cycle-signatures.mjs';
+import { scheduledCycle1Signature } from './lib/cycle-signatures.mjs';
 import { createTranscriptIngest } from './lib/transcript-ingest.mjs';
 import { createCycleLlmAdapters } from './lib/cycle-llm-adapters.mjs';
 import { createCycleScheduler } from './lib/cycle-scheduler.mjs';
@@ -333,20 +333,15 @@ async function getCycleLastRun() {
     const obj = JSON.parse(raw);
     return {
       cycle1: Number(obj.cycle1) || 0,
-      cycle2: Number(obj.cycle2) || 0,
       // Heartbeat (every attempt, success or skip) is tracked separately from
       // the success timestamps above so a long string of failed/skipped runs
       // cannot disguise itself as a healthy keeper.
       cycle1_heartbeat: Number(obj.cycle1_heartbeat) || 0,
-      // Last cycle2 failure message; cleared to '' on success.
-      cycle2_last_error: typeof obj.cycle2_last_error === 'string' ? obj.cycle2_last_error : '',
     };
   } catch {
     return {
       cycle1: 0,
-      cycle2: 0,
       cycle1_heartbeat: 0,
-      cycle2_last_error: '',
     };
   }
 }
@@ -373,7 +368,7 @@ async function refreshCoreMemorySnapshot(reason = 'mutation') {
 const CYCLE_STATE_FILE = path.join(DATA_DIR, 'memory-cycle-state.json');
 
 const _cycleLlmAdapters = createCycleLlmAdapters({ callAgentDispatch });
-const { getCycle1CallLlm, getCycle2CallLlm } = _cycleLlmAdapters;
+const { getCycle1CallLlm } = _cycleLlmAdapters;
 
 const _cycleScheduler = createCycleScheduler({
   getDb: () => db,
@@ -388,9 +383,7 @@ const _cycleScheduler = createCycleScheduler({
   readMainConfig,
   memoryCyclesEnabled,
   getCycle1CallLlm,
-  getCycle2CallLlm,
   runCycle1,
-  runCycle2,
   parseInterval,
   flushRawEmbeddings,
   claimAndMarkScheduledCycle,
@@ -398,13 +391,11 @@ const _cycleScheduler = createCycleScheduler({
   scheduleCoalescedCycleRetry,
   cancelCoalescedCycleRetries,
   scheduledCycle1Signature,
-  scheduledCycle2Signature,
   cycleStateFile: CYCLE_STATE_FILE,
 });
-// Cycle1 run primitives + cycle2 finalize used by MCP action handlers below.
+// Cycle1 run primitives used by MCP action handlers below.
 const _startCycle1Run = _cycleScheduler.startCycle1Run;
 const _awaitCycle1Run = _cycleScheduler.awaitCycle1Run;
-const _finalizeCycle2Run = _cycleScheduler.finalizeCycle2Run;
 
 // Transcript watcher lifecycle stays in the facade (owns _transcriptIngest);
 // the cycle tick loop start/stop is delegated to the scheduler.
@@ -509,10 +500,8 @@ const _actionHandlers = createMemoryActionHandlers({
   dumpSessionRootChunks,
   awaitCycle1Run: _awaitCycle1Run,
   startCycle1Run: _startCycle1Run,
-  finalizeCycle2Run: _finalizeCycle2Run,
   refreshCoreMemoryFile: refreshCoreMemorySnapshot,
   getSchedulerCycle1InFlight: () => _cycleScheduler.getCycle1InFlight(),
-  getCycle2CallLlm,
   ingestTranscriptFile,
   cwdFromTranscriptPath,
 });

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

@@ -9,7 +9,7 @@ import { getDatabase, embeddingToSql } 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-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
 import { findCoreKeyRows } from './core-memory-uniqueness.mjs';
 
 const CORE_ELEMENT_DERIVE_LENGTH = 40;

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

@@ -30,9 +30,7 @@ export function createCycleLlmAdapters({ callAgentDispatch }) {
   // unhandled rejection that killed the memory runtime. Keep the factory
   // contract: each getter returns the (memoized) adapter function.
   const cycle1 = buildAdapter('cycle1-agent');
-  const cycle2 = buildAdapter('cycle2-agent');
   return {
     getCycle1CallLlm: () => cycle1,
-    getCycle2CallLlm: () => cycle2,
   };
 }

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

@@ -6,13 +6,6 @@ async function countRows(db, sql, params) {
   return Number((await db.query(sql, params)).rows[0]?.c ?? 0);
 }
 
-export function countPendingCycle2Roots(db) {
-  return countRows(
-    db,
-    `SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND cycle2_reviewed_at IS NULL AND duplicate_of IS NULL`
-  );
-}
-
 // Per-tick backlog counts for the state file / statusline, the backlog
 // warning, and the opportunistic raw-embedding flush while rows are unchunked.
 export function createBacklogProbe({ getDb, ledger, log, flushRawEmbeddings }) {
@@ -46,10 +39,9 @@ export function createBacklogProbe({ getDb, ledger, log, flushRawEmbeddings }) {
            AND (reviewed_at IS NULL OR reviewed_at < $1)`,
         [now - CYCLE1_OMITTED_COOLDOWN_MS]
       );
-      const cycle2Pending = await countPendingCycle2Roots(db);
-      ledger.setBacklog({ unchunked, unchunked_eligible: unchunkedEligible, cycle2_pending: cycle2Pending, at: now });
-      if (unchunked > BACKLOG_WARN_PENDING || cycle2Pending > BACKLOG_WARN_PENDING) {
-        ledger.warn(`backlog unchunked=${unchunked} eligible=${unchunkedEligible} cycle2_pending=${cycle2Pending}`);
+      ledger.setBacklog({ unchunked, unchunked_eligible: unchunkedEligible, at: now });
+      if (unchunked > BACKLOG_WARN_PENDING) {
+        ledger.warn(`backlog unchunked=${unchunked} eligible=${unchunkedEligible}`);
       }
       if (unchunked > 0) flushRawEmbeddingsOnce(db);
     } catch {

package/src/runtime/memory/lib/cycle-scheduler/health-ledger.mjs

@@ -9,10 +9,9 @@ const BACKLOG_WARN_FAILURES = 5;
 export function createCycleHealthLedger({ cycleStateFile, log }) {
   const health = {
     cycle1: { last_success_at: 0, last_error_at: 0, last_error: null, consecutive_failures: 0 },
-    cycle2: { last_success_at: 0, last_error_at: 0, last_error: null, consecutive_failures: 0 },
   };
   let running = null; // { cycle, started_at, pid }
-  let backlog = { unchunked: 0, cycle2_pending: 0, at: 0 };
+  let backlog = { unchunked: 0, at: 0 };
   let lastWarnAt = 0;
 
   function write() {
@@ -74,7 +73,6 @@ export function createCycleHealthLedger({ cycleStateFile, log }) {
   // state file reports 0 until the next run.
   function hydrateSuccess(last) {
     if (last?.cycle1 > 0 && !health.cycle1.last_success_at) health.cycle1.last_success_at = last.cycle1;
-    if (last?.cycle2 > 0 && !health.cycle2.last_success_at) health.cycle2.last_success_at = last.cycle2;
     write();
   }
 

package/src/runtime/memory/lib/cycle-scheduler/scheduled-enqueue.mjs

@@ -5,9 +5,7 @@ export function createScheduledEnqueue({
   getConfig,
   claimAndMarkScheduledCycle,
   scheduledCycle1Signature,
-  scheduledCycle2Signature,
   scheduleScheduledCycle1,
-  scheduleScheduledCycle2,
 }) {
   function periodicCycle1Config() {
     return {
@@ -38,13 +36,5 @@ export function createScheduledEnqueue({
     }
   }
 
-  async function enqueueScheduledCycle2(intervalMs) {
-    const config = getConfig()?.cycle2 || {};
-    const signature = scheduledCycle2Signature(config);
-    if (await claimScheduledSlot('cycle2', intervalMs, signature, config)) {
-      scheduleScheduledCycle2(config, signature);
-    }
-  }
-
-  return { periodicCycle1Config, enqueueScheduledCycle1, enqueueScheduledCycle2 };
+  return { periodicCycle1Config, enqueueScheduledCycle1 };
 }

package/src/runtime/memory/lib/cycle-scheduler/tick-loop.mjs

@@ -30,12 +30,10 @@ export function createCycleTickLoop({
     setConfig(mainConfig);
     const cyclesOn = memoryCyclesEnabled();
     const cycle1Ms = parseInterval(mainConfig?.cycle1?.interval || '10m');
-    const cycle2Ms = parseInterval(mainConfig?.cycle2?.interval || '1h');
     const now = Date.now();
     const last = await getCycleLastRun();
     if (cyclesOn) {
       if (periodicCycleDue(last.cycle1, startedAt, cycle1Ms, now)) await enqueue.enqueueScheduledCycle1(cycle1Ms);
-      if (periodicCycleDue(last.cycle2, startedAt, cycle2Ms, now)) await enqueue.enqueueScheduledCycle2(cycle2Ms);
     }
     await probeBacklog(now);
   }

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

@@ -2,7 +2,7 @@
 //
 // Owns the mutually-referential cycle machinery: the cycle-health ledger and
 // run-state file, the cycle1 outer coalesce layer, the scheduled enqueue /
-// retry paths for cycle1/2, checkCycles(), and the self-rescheduling tick
+// retry paths for cycle1, checkCycles(), and the self-rescheduling tick
 // loop. The phases live under cycle-scheduler/. index.mjs keeps lifecycle
 // ownership by injecting live getters (getDb/getConfig/setConfig) plus the
 // cycle runners and LLM adapters.
@@ -15,15 +15,14 @@
 //   log                -> __mixdogMemoryLog
 //   getCycleLastRun / setCycleLastRun -> meta-backed cycle timestamps
 //   readMainConfig / memoryCyclesEnabled -> config-flag helpers
-//   getCycle{1,2}CallLlm -> in-process LLM adapters
-//   runCycle1 / runCycle2 / parseInterval / flushRawEmbeddings
+//   getCycle1CallLlm -> in-process LLM adapter
+//   runCycle1 / parseInterval / flushRawEmbeddings
 //   claimAndMarkScheduledCycle / resolveCoalesceMaxRetries /
 //     scheduleCoalescedCycleRetry -> coalesced queue primitives
-//   scheduledCycle{1,2}Signature -> queue signatures
+//   scheduledCycle1Signature -> queue signature
 //   cycleStateFile -> path to memory-cycle-state.json
 import { createCycleHealthLedger } from './cycle-scheduler/health-ledger.mjs';
 import { createCycle1Runs } from './cycle-scheduler/cycle1-runs.mjs';
-import { createCycle2Runs } from './cycle-scheduler/cycle2-runs.mjs';
 import { createScheduledEnqueue } from './cycle-scheduler/scheduled-enqueue.mjs';
 import { createBacklogProbe } from './cycle-scheduler/backlog-probe.mjs';
 import { createCycleTickLoop } from './cycle-scheduler/tick-loop.mjs';
@@ -42,9 +41,7 @@ export function createCycleScheduler(deps) {
     readMainConfig,
     memoryCyclesEnabled,
     getCycle1CallLlm,
-    getCycle2CallLlm,
     runCycle1,
-    runCycle2,
     parseInterval,
     flushRawEmbeddings,
     claimAndMarkScheduledCycle,
@@ -52,7 +49,6 @@ export function createCycleScheduler(deps) {
     scheduleCoalescedCycleRetry,
     cancelCoalescedCycleRetries,
     scheduledCycle1Signature,
-    scheduledCycle2Signature,
     cycleStateFile,
   } = deps;
 
@@ -68,15 +64,12 @@ export function createCycleScheduler(deps) {
     setCycleLastRun,
     ...queue,
   });
-  const cycle2 = createCycle2Runs({ ledger, getDb, log, getCycle2CallLlm, runCycle2, setCycleLastRun, ...queue });
   const enqueue = createScheduledEnqueue({
     getDb,
     getConfig,
     claimAndMarkScheduledCycle,
     scheduledCycle1Signature,
-    scheduledCycle2Signature,
     scheduleScheduledCycle1: cycle1.scheduleScheduledCycle1,
-    scheduleScheduledCycle2: cycle2.scheduleScheduledCycle2,
   });
   const backlog = createBacklogProbe({ getDb, ledger, log, flushRawEmbeddings });
   const tick = createCycleTickLoop({
@@ -97,7 +90,6 @@ export function createCycleScheduler(deps) {
   // running state.
   function resetInFlight() {
     cycle1.reset();
-    cycle2.reset();
     backlog.reset();
     tick.reset();
     ledger.resetRunning();
@@ -113,7 +105,6 @@ export function createCycleScheduler(deps) {
     // run primitives used by MCP action handlers
     startCycle1Run: cycle1.startCycle1Run,
     awaitCycle1Run: cycle1.awaitCycle1Run,
-    finalizeCycle2Run: cycle2.finalizeCycle2Run,
     periodicCycle1Config: enqueue.periodicCycle1Config,
     // lifecycle
     startCycles: tick.start,

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

@@ -11,9 +11,3 @@ export function scheduledCycle1Signature(config) {
     maxConcurrent: undefined,
   });
 }
-
-export function scheduledCycle2Signature(config) {
-  return makeCycleRequestSignature('cycle2', config, {
-    concurrency: undefined,
-  });
-}

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

@@ -3,7 +3,7 @@
 // session fetch with its starvation backfill, session grouping, and the
 // terminal / omitted sentinel updates.
 import { __mixdogMemoryLog } from '../memory-log.mjs';
-import { throwIfAborted } from '../memory-cycle2-shared.mjs';
+import { throwIfAborted } from '../memory-cycle-shared.mjs';
 import { CYCLE1_OMITTED_COOLDOWN_MS } from './cycle1-plan.mjs';
 
 export function isStructurallyUnchunkableInput(row) {

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

@@ -3,7 +3,7 @@
 // through the LLM, commit each chunk as one transaction, and mark what was
 // left out. Rows within the window are one session in chronological order.
 import { __mixdogMemoryLog } from '../memory-log.mjs';
-import { throwIfAborted } from '../memory-cycle2-shared.mjs';
+import { throwIfAborted } from '../memory-cycle-shared.mjs';
 import { assessChunkQuality, generateCycle1Chunks } from '../memory-chunk-quality.mjs';
 import { inferChunkProjectId, syncRootEmbedding } from '../memory-embed.mjs';
 import { isStructurallyUnchunkableInput, markOmittedRows, markTerminalRows, selectRootId } from './cycle1-rows.mjs';
@@ -42,7 +42,7 @@ async function commitCycle1Chunk(db, chunk, rootId, memberIds) {
       `UPDATE entries
        SET chunk_root = $1, is_root = 1, element = $2, category = $3, summary = $4,
            status = 'pending', project_id = $5,
-           last_seen_at = $7, chunk_quality = $8::jsonb, cycle2_reviewed_at = NULL, duplicate_of = NULL
+           last_seen_at = $7, chunk_quality = $8::jsonb, duplicate_of = NULL
        WHERE id = $6`,
       [rootId, element, category, summary, projectId, rootId, Date.now(), JSON.stringify(quality)]
     );

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

@@ -1,4 +1,4 @@
-import { throwIfAborted } from './memory-cycle2-shared.mjs';
+import { throwIfAborted } from './memory-cycle-shared.mjs';
 
 const DEFAULT_PASS_PAUSE_MS = 1_000;
 

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

@@ -60,7 +60,6 @@ export function createLifecycleRoutes({
         active_roots: stats.active_roots,
         archived_roots: stats.archived_roots,
         unchunked_leaves: stats.unchunked_leaves,
-        cycle2_pending_roots: stats.cycle2_pending_roots,
         core_entries: stats.core_entries,
         core_embed_null: stats.core_embed_null,
         cycle_running: cycleScheduler.getCycleRunning(),

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

@@ -1,11 +1,11 @@
 /**
  * memory-action-handlers/cycle-actions.mjs — the cycle-driven memory actions:
- * cycle1, cycle2/sleep, flush, rebuild and backfill. Cycle scheduler
- * primitives and the cycle2 LLM adapter are injected; the whole-action
+ * cycle1, flush, rebuild and backfill. Cycle scheduler
+ * primitives are injected; the whole-action
  * backfill mutex lives here since it only guards this module's backfill path.
  */
-import { runCycle2 } from '../memory-cycle.mjs';
-import { throwIfAborted } from '../memory-cycle2-shared.mjs';
+import { flushSearchEmbeddings } from '../memory-cycle.mjs';
+import { throwIfAborted } from '../memory-cycle-shared.mjs';
 import { createBackfillAction } from './cycle-backfill-action.mjs';
 import { createRebuildAction } from './cycle-rebuild-action.mjs';
 
@@ -56,41 +56,15 @@ function cycle1SummaryText(result) {
   );
 }
 
-function cycle2SummaryResult(result) {
-  const counts = {
-    processed: result?.processed || 0,
-    merged: result?.merged || 0,
-    linked: result?.linked || 0,
-    kept: result?.kept || 0,
-    held: result?.held || 0,
-    deferred: result?.deferred || 0,
-  };
-  const parts = Object.entries(counts)
-    .filter(([, v]) => v > 0)
-    .map(([k, v]) => `${k}=${v}`);
-  if (result?.ok === false)
-    return { text: `cycle2 failed: ${result.error || 'unknown'} ${parts.join(' ')}`.trim(), isError: true };
-  if (parts.length) return { text: `cycle2 ${parts.join(' ')}` };
-  // No applied counts — distinguish an in-flight skip from an empty queue.
-  let cause = '';
-  if (result?.skippedInFlight) cause = ' (skipped: in-flight)';
-  return { text: `cycle2 noop${cause}` };
-}
-
 export function createCycleActions({
   getDb,
   dataDir,
   awaitCycle1Run,
   startCycle1Run,
-  finalizeCycle2Run,
   getSchedulerCycle1InFlight,
-  getCycle2CallLlm,
   ingestTranscriptFile,
   cwdFromTranscriptPath,
 }) {
-  const withCycle2Llm = (options) =>
-    typeof options.callLlm === 'function' ? options : { ...options, callLlm: getCycle2CallLlm() };
-
   async function cycle1(args, config, signal) {
     const cycle1Config = cycle1ConfigFromArgs(args, config?.cycle1 || {});
     const callerDeadlineMs = Number(args?._callerDeadlineMs) || 0;
@@ -104,50 +78,31 @@ export function createCycleActions({
     return { ...result, text: cycle1SummaryText(result) };
   }
 
-  async function cycle2(args, config, signal) {
-    const db = getDb();
-    throwIfAborted(signal);
-    const cycle2Config = { ...(config?.cycle2 || {}) };
-    if (Number.isFinite(Number(args?.batch_size))) {
-      cycle2Config.batch_size = Math.max(1, Math.floor(Number(args.batch_size)));
-    }
-    const result = await runCycle2(db, cycle2Config, withCycle2Llm({ signal }));
-    throwIfAborted(signal);
-    await finalizeCycle2Run(result);
-    return cycle2SummaryResult(result);
-  }
-
   async function flush(_args, config, signal) {
     const db = getDb();
     throwIfAborted(signal);
     const r1 = await awaitCycle1Run(config?.cycle1 || {}, { signal });
     throwIfAborted(signal);
-    const r2 = await runCycle2(db, config?.cycle2 || {}, withCycle2Llm({ signal }));
+    const embeddings = await flushSearchEmbeddings(db, { signal });
     throwIfAborted(signal);
-    await finalizeCycle2Run(r2);
     return {
-      text: `flush: cycle1 chunks=${r1.chunks} processed=${r1.processed}, cycle2 ${JSON.stringify(r2)}`,
-      isError: r2.ok === false,
+      text: `flush: cycle1 chunks=${r1.chunks} processed=${r1.processed}, embeddings=${embeddings.succeeded}`,
     };
   }
 
   const rebuild = createRebuildAction({
     getDb,
     startCycle1Run,
-    finalizeCycle2Run,
     getSchedulerCycle1InFlight,
-    withCycle2Llm,
   });
 
   const backfill = createBackfillAction({
     getDb,
     dataDir,
     awaitCycle1Run,
-    finalizeCycle2Run,
-    withCycle2Llm,
     ingestTranscriptFile,
     cwdFromTranscriptPath,
   });
 
-  return { cycle1, cycle2, flush, rebuild, backfill };
+  return { cycle1, flush, rebuild, backfill };
 }

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]