mixdog 1.0.4 → 1.0.5

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -15,7 +15,7 @@ import {
   emitCompactEvent,
   resolveHandoffSummaryModel,
 } from './loop/compact-policy.mjs';
-import { runFreshContextCompact } from './loop/fresh-context.mjs';
+import { previewFreshContextCompaction, runFreshContextCompact } from './loop/fresh-context.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
 import { messagesArrayChanged } from './loop/tool-helpers.mjs';
 import { normalizeUsage, addUsage } from './loop/usage.mjs';
@@ -72,8 +72,8 @@ function transcriptPrefixHash(messages) {
 // same event. A pending reactive-overflow retry makes THIS compact pass the
 // recovery from a provider overflow refusal, not the proactive pressure
 // trigger — the emitted events are tagged so telemetry can tell them apart.
-// An agent whose 5m message cache expired compacts before the cold send
-// whatever its size (trigger 'cache_expired').
+// Cache expiry arms a cold-send compact regardless of the threshold, but all
+// proactive triggers still need a smaller predicted transcript.
 function preSendCompactDecision(state, compactPolicy) {
   const { messages, sessionRef } = state;
   const messageTokensEst = estimateMessagesTokensSafe(messages);
@@ -84,24 +84,45 @@ function preSendCompactDecision(state, compactPolicy) {
     sessionRef,
   });
   const cacheExpired = shouldCompactForExpiredAgentCache(sessionRef, state.opts);
-  const shouldCompact =
+  const mediaPressure = shouldCompactForRequestMedia(messages);
+  const requireReduction = !reactivePending && !mediaPressure;
+  let shouldCompact =
     state.skipProactiveCompact !== true &&
     (cacheExpired ||
-      shouldCompactForRequestMedia(messages) ||
+      mediaPressure ||
       shouldCompactForSession(messageTokensEst, compactPolicy, {
         forceReactive: reactivePending,
         messages,
         sessionRef,
         pressureTokens,
       }));
+  const compactBudgetTokens = shouldCompact
+    ? compactTargetBudget({ ...compactPolicy, pressureTokens }) || compactPolicy.boundaryTokens
+    : compactPolicy.boundaryTokens;
+  if (shouldCompact && requireReduction) {
+    // Price the same Goal reminder the real pass will attach, without marking
+    // or acknowledging it on a session whose compaction may be skipped.
+    const previewSession = { ...sessionRef };
+    markPendingGoalReminder(previewSession, 'compaction');
+    const reminder = snapshotPendingGoalReminder(previewSession);
+    shouldCompact = previewFreshContextCompaction({
+      sessionRef,
+      messages,
+      compactBudgetTokens,
+      compactPolicy,
+      sessionId: state.sessionId,
+      provider: state.provider,
+      goalReminderText: reminder?.content || '',
+      activeTurn: true,
+    }).reducesTokens;
+  }
   return {
     messageTokensEst,
     pressureTokens,
     shouldCompact,
+    requireReduction,
     compactTrigger: reactivePending ? 'reactive' : cacheExpired ? 'cache_expired' : 'auto',
-    compactBudgetTokens: shouldCompact
-      ? compactTargetBudget({ ...compactPolicy, pressureTokens }) || compactPolicy.boundaryTokens
-      : compactPolicy.boundaryTokens,
+    compactBudgetTokens,
   };
 }
 
@@ -243,6 +264,7 @@ async function compactTranscript(ctx, run) {
     sendOpts: opts,
     goalReminderText: run.inlineGoalReminder?.content || '',
     activeTurn: true,
+    requireReduction: decision.requireReduction,
   });
   const freshMessages = Array.isArray(run.freshContextResult?.messages) ? run.freshContextResult.messages : null;
   if (!freshMessages) throw new Error('fresh-context compact produced no messages');
@@ -461,6 +483,10 @@ async function compactBeforeSend(ctx) {
     throwCompactFailure(ctx, run, compactErr);
   }
   await setStage(opts, 'requesting');
+  if (run.freshContextResult?.skipped) {
+    compactTelemetry(ctx, 'pre_send_check', { skipReason: 'no_token_reduction' });
+    return;
+  }
   ctx.compactChanged = messagesArrayChanged(messages, run.compacted);
   if (ctx.compactChanged) adoptCompactedTranscript(ctx, run);
   reportCompactOutcome(ctx, run);

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -190,10 +190,12 @@ function buildPreview(text, maxChars = TOOL_RESULT_PREVIEW_CHARS) {
   };
 }
 
-function artifactMeta(sessionId, toolCallId, channel, content) {
+function artifactMeta(sessionId, toolCallId, channel, content, preview = false) {
   if (!sessionId || !toolCallId || typeof content !== 'string') return null;
   const sha256 = createHash('sha256').update(content, 'utf8').digest('hex');
-  const dir = ensureToolResultsDir(sessionId);
+  const dir = preview
+    ? join(getPluginData(), 'tool-results', safeSessionSegment(sessionId))
+    : ensureToolResultsDir(sessionId);
   return {
     stream: channel,
     path: join(dir, artifactIdentity(sha256)),
@@ -208,6 +210,12 @@ function artifactShapeMatches(meta, info) {
   return info.isFile() && info.size === meta.bytes;
 }
 
+// Same content-addressed reference as persistence, without creating a directory
+// or a file. Compaction previews must not archive a transcript they will keep.
+export function previewToolResultArtifact({ sessionId, toolCallId, channel = 'result', content } = {}) {
+  return artifactMeta(sessionId, toolCallId, channel, content, true);
+}
+
 export function persistToolResultArtifactSync({ sessionId, toolCallId, channel = 'result', content } = {}) {
   let meta;
   try {

package/src/runtime/agent/orchestrator/session/transcript-restore/agent-envelope.mjs

@@ -2,7 +2,7 @@
  * src/tui/session/agent-envelope.mjs - parse agent/background-task/shell
  * notification envelopes into synthetic tool-item shapes, and derive
  * status/result text. parseBackgroundTaskEnvelope
- * remains part of session-local.mjs's public surface.
+ * remains part of local-session-runtime.mjs's public surface.
  */
 import { isBackgroundErrorOnlyBody } from '../../../../shared/err-text.mjs';
 import { textBetweenTag } from '../../../../shared/tool-result-summary.mjs';

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -66,6 +66,7 @@ function restoredAssistantTranscriptItems(message, nextId) {
       kind: 'turndone',
       id: nextId(),
       ...completion,
+      ...(completion.status === 'done' ? { finalAssistantId: items[0].id } : {}),
       ...(metadata.at ? { at: metadata.at } : {}),
     });
   }

package/src/runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs

@@ -619,7 +619,9 @@ export function preflightPowerShellHygiene(command, { shellType, shellName } = {
 const POWERSHELL_ONLY_SYNTAX = [
   /\$(?:null|true|false|env:|_\b|args\b|host\b|profile\b|pwd\b|psversiontable\b|psscriptroot\b|lastexitcode\b|erroractionpreference\b)/i,
   /\$[A-Za-z_]\w*\s*=/,
-  /\b(?:get|set|new|remove|select|where|foreach|invoke|out|write|start|stop|test|measure|sort|join|split|convert|import|export|add|copy|move|rename|resolve|compare|clear|push|pop)-[A-Za-z]+\b/i,
+  // A verb joined to the previous character by a path/word char (`mixdog-test-scratch`, `a/test-x`) is part of a
+  // path or name, not a cmdlet.
+  /(?<![\w\-./\\:])(?:get|set|new|remove|select|where|foreach|invoke|out|write|start|stop|test|measure|sort|join|split|convert|import|export|add|copy|move|rename|resolve|compare|clear|push|pop)-[A-Za-z]+\b/i,
   /\[[A-Za-z_][\w.]*\]::/,
   /(?:^|\s)-(?:eq|ne|gt|lt|ge|le|match|notmatch|like|notlike|contains|replace|not|and|or|is|as|ErrorAction|Recurse|Force|Encoding|TotalCount|Tail|Pattern|Path|LiteralPath)\b/,
   /2>\s*\$/,

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 };
 }