mixdog 0.9.13 → 0.9.14

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

@@ -122,7 +122,8 @@ export function buildEntriesText(entries) {
 const DEFAULT_CYCLE1_RULES = [
   `Chunk these entries. Emit one chunk per line, NO JSON, NO tool calls, NO prose.`,
   `Format: idx_csv|element|category|summary.`,
-  `Every substantive @N should appear in exactly one chunk; omit entries with no standalone memory value.`,
+  `Target ${3}-${8} @N indexes per chunk when entries share topic, goal, or cause→resolution; singleton chunks only when one entry is truly isolated.`,
+  `Every substantive @N must appear in exactly one chunk; omit only entries with zero standalone memory value — excessive omissions are invalid.`,
   `Group by coherent topic, keep cause and resolution together, and never merge across [sess:] markers.`,
   `Category must be one of rule / constraint / decision / fact / goal / preference / task / issue; choose the one that best preserves future recall intent.`,
   `Keep summary compact and source-grounded; preserve decisive identifiers, constraints, causes, and outcomes when present.`,
@@ -164,7 +165,92 @@ export function parseCycle1LineFormat(raw) {
   return chunks.length > 0 ? { chunks } : null
 }
 
+// Compactness guard thresholds (post-parse); retry LLM once when exceeded on non-trivial windows.
+const CYCLE1_TARGET_CHUNK_MIN = 3
+const CYCLE1_TARGET_CHUNK_MAX = 8
+const CYCLE1_MAX_SINGLETON_RATIO = 0.6
+const CYCLE1_MAX_OMITTED_RATIO = 0.35
+const CYCLE1_MIN_ROWS_FOR_COMPACTNESS_RETRY = 6
+
 // Partition by session_id; MIN_BATCH gates total pending rows, SESSION_CAP bounds per-tick session fan-out.
+function computeCycle1GroupingQuality(chunks, rowCount) {
+  const rows = Math.max(0, Number(rowCount) || 0)
+  const list = Array.isArray(chunks) ? chunks : []
+  const usedIdx = new Set()
+  const referenced = new Set()
+  let singletonCount = 0
+  let chunkCount = 0
+  for (const chunk of list) {
+    const raw = Array.isArray(chunk?._idxList) ? chunk._idxList.map(n => Number(n)) : []
+    if (raw.some(n => !Number.isFinite(n) || n <= 0 || n > rows)) continue
+    if (raw.length !== new Set(raw).size) continue
+    if (raw.some(n => usedIdx.has(n))) continue
+    chunkCount += 1
+    if (raw.length === 1) singletonCount += 1
+    for (const n of raw) {
+      usedIdx.add(n)
+      referenced.add(n)
+    }
+  }
+  const omittedCount = Math.max(0, rows - referenced.size)
+  const singleton_ratio = chunkCount > 0 ? singletonCount / chunkCount : 0
+  const omitted_ratio = rows > 0 ? omittedCount / rows : 0
+  return {
+    chunkCount,
+    singletonCount,
+    omittedCount,
+    referencedCount: referenced.size,
+    singleton_ratio,
+    omitted_ratio,
+  }
+}
+
+function countCycle1CommittableChunks(chunkList, entryByIdx, entryById) {
+  const usedIds = new Set()
+  let count = 0
+  for (const chunk of chunkList) {
+    const idxList = chunk._idxList.map(n => Number(n))
+    const outOfRange = idxList.filter(n => !entryByIdx.has(n))
+    if (outOfRange.length > 0) continue
+    const rawIds = idxList.map(n => Number(entryByIdx.get(n).id))
+    const dupeWithin = rawIds.length !== new Set(rawIds).size
+    const externalIds = rawIds.filter(n => !Number.isFinite(n) || !entryById.has(n))
+    const reusedIds = rawIds.filter(n => usedIds.has(n))
+    const memberIds = rawIds.filter(n => Number.isFinite(n) && entryById.has(n) && !usedIds.has(n))
+    const element = String(chunk?.element ?? '').trim()
+    const category = String(chunk?.category ?? '').trim().toLowerCase()
+    const summary = String(chunk?.summary ?? '').trim()
+    if (dupeWithin || externalIds.length > 0 || reusedIds.length > 0) continue
+    if (memberIds.length === 0 || !element || !summary || !VALID_CATEGORIES.has(category)) continue
+    if (_isStructurallyInvalidSummary(summary)) continue
+    const members = memberIds.map(id => entryById.get(id))
+    if (selectRootId(members) === null) continue
+    for (const mid of memberIds) usedIds.add(mid)
+    count += 1
+  }
+  return count
+}
+
+function cycle1GroupingQualityScore(metrics) {
+  return 1 - (metrics.omitted_ratio * 1.5 + metrics.singleton_ratio * 0.75)
+}
+
+function shouldRetryCycle1Grouping(metrics, rowCount) {
+  if (rowCount < CYCLE1_MIN_ROWS_FOR_COMPACTNESS_RETRY) return false
+  if (!metrics || metrics.chunkCount === 0) return false
+  return metrics.singleton_ratio > CYCLE1_MAX_SINGLETON_RATIO
+    || metrics.omitted_ratio > CYCLE1_MAX_OMITTED_RATIO
+}
+
+function buildCycle1CorrectiveRules(metrics) {
+  return [
+    `CORRECTION: prior grouping was too fragmented (singleton_ratio=${metrics.singleton_ratio.toFixed(2)}, omitted_ratio=${metrics.omitted_ratio.toFixed(2)}).`,
+    `Merge related @N into chunks of about ${CYCLE1_TARGET_CHUNK_MIN}-${CYCLE1_TARGET_CHUNK_MAX} entries when they share topic, goal, or causal chain.`,
+    `Use singleton chunks only when one entry is truly isolated; otherwise combine neighbors.`,
+    `Reference every substantive @N; minimize omissions.`,
+  ]
+}
+
 const CYCLE1_MIN_BATCH = 3
 const CYCLE1_SESSION_CAP = 10
 
@@ -513,13 +599,11 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
       }
     }
 
-    const userMessage = buildCycle1ChunkPrompt(rows)
     const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callAgentDispatch
 
-    let raw
-    const _tLlm = Date.now()
-    try {
-      raw = await llmCall({
+    async function callCycle1Grouping(userMessage) {
+      const _tLlm = Date.now()
+      const raw = await llmCall({
         agent: 'cycle1-agent',
         taskType: 'maintenance',
         mode: 'cycle1',
@@ -528,8 +612,64 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
         // Pin cwd to null so every memory cycle call hits the same agent cache shard.
         cwd: null,
       }, userMessage)
+      throwIfAborted(signal)
+      __mixdogMemoryLog(`[cycle1-time] window=${windowIdx} llmMs=${Date.now() - _tLlm}\n`)
+      const parsed = parseCycle1LineFormat(raw)
+      const chunks = Array.isArray(parsed?.chunks) ? parsed.chunks : null
+      return { raw, chunks }
+    }
+
+    let groupingAttempt = 1
+    let groupingRetried = false
+    let chosenQuality = null
+    let firstChunkList = null
+    let secondChunkList = null
+    let chunkList
+    try {
+      const first = await callCycle1Grouping(buildCycle1ChunkPrompt(rows))
+      if (!first.chunks) {
+        __mixdogMemoryLog(`[cycle1] unparseable response (window=${windowIdx}) (${String(first.raw).slice(0, 200)})\n`)
+        return {
+          committedChunks: 0, committedMembers: 0, skippedChunks: rows.length, rowsConsidered: originalRows.length,
+          invalidChunks: [{ reason: 'unparseable_response', member_ids: rows.map(r => Number(r.id)) }],
+          failedRowIds: rows.map(r => Number(r.id)),
+          omittedRowIds: prefilteredRowIds,
+          prefilteredRowIds,
+          prefilterMarked,
+          prefilterMarkFailed,
+        }
+      }
+      firstChunkList = first.chunks
+      chunkList = firstChunkList
+      chosenQuality = computeCycle1GroupingQuality(chunkList, rows.length)
+
+      if (shouldRetryCycle1Grouping(chosenQuality, rows.length)) {
+        groupingRetried = true
+        const correctiveRules = [
+          ...DEFAULT_CYCLE1_RULES,
+          '',
+          ...buildCycle1CorrectiveRules(chosenQuality),
+        ]
+        try {
+          const second = await callCycle1Grouping(buildCycle1ChunkPrompt(rows, correctiveRules))
+          if (second.chunks) {
+            secondChunkList = second.chunks
+            const secondQuality = computeCycle1GroupingQuality(second.chunks, rows.length)
+            const scoreFirst = cycle1GroupingQualityScore(chosenQuality)
+            const scoreSecond = cycle1GroupingQualityScore(secondQuality)
+            if (scoreSecond > scoreFirst) {
+              chunkList = second.chunks
+              chosenQuality = secondQuality
+              groupingAttempt = 2
+            }
+          }
+        } catch (retryErr) {
+          if (signal?.aborted) throw retryErr.reason ?? retryErr
+          __mixdogMemoryLog(`[cycle1] compactness retry LLM error (window=${windowIdx}): ${retryErr.message}\n`)
+        }
+      }
     } catch (err) {
-      if (signal?.aborted) throw signal.reason ?? err
+      if (signal?.aborted) throw err.reason ?? err
       __mixdogMemoryLog(`[cycle1] LLM error (window=${windowIdx}): ${err.message}\n`)
       return {
         committedChunks: 0, committedMembers: 0, skippedChunks: rows.length, rowsConsidered: originalRows.length,
@@ -541,26 +681,29 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
         prefilterMarkFailed,
       }
     }
-    throwIfAborted(signal)
-    __mixdogMemoryLog(`[cycle1-time] window=${windowIdx} llmMs=${Date.now() - _tLlm}\n`)
 
-    const parsed = parseCycle1LineFormat(raw)
-    const chunkList = Array.isArray(parsed?.chunks) ? parsed.chunks : null
-    if (!chunkList) {
-      __mixdogMemoryLog(`[cycle1] unparseable response (window=${windowIdx}) (${String(raw).slice(0, 200)})\n`)
-      return {
-        committedChunks: 0, committedMembers: 0, skippedChunks: rows.length, rowsConsidered: originalRows.length,
-        invalidChunks: [{ reason: 'unparseable_response', member_ids: rows.map(r => Number(r.id)) }],
-        failedRowIds: rows.map(r => Number(r.id)),
-        omittedRowIds: prefilteredRowIds,
-        prefilteredRowIds,
-        prefilterMarked,
-        prefilterMarkFailed,
+    const entryByIdx = new Map(rows.map((r, i) => [i + 1, r]))
+    const entryById = new Map(rows.map(r => [Number(r.id), r]))
+
+    if (countCycle1CommittableChunks(chunkList, entryByIdx, entryById) === 0) {
+      const fallback = groupingAttempt === 2 ? firstChunkList : secondChunkList
+      if (fallback && countCycle1CommittableChunks(fallback, entryByIdx, entryById) > 0) {
+        chunkList = fallback
+        groupingAttempt = groupingAttempt === 2 ? 1 : 2
+        chosenQuality = computeCycle1GroupingQuality(chunkList, rows.length)
+        __mixdogMemoryLog(
+          `[cycle1] grouping_fallback window=${windowIdx} chosen_attempt=${groupingAttempt}\n`,
+        )
       }
     }
 
-    const entryByIdx = new Map(rows.map((r, i) => [i + 1, r]))
-    const entryById = new Map(rows.map(r => [Number(r.id), r]))
+    __mixdogMemoryLog(
+      `[cycle1] grouping_quality window=${windowIdx} prompt_entries=${rows.length}` +
+      ` chunks=${chosenQuality.chunkCount} singleton_ratio=${chosenQuality.singleton_ratio.toFixed(3)}` +
+      ` omitted_ratio=${chosenQuality.omitted_ratio.toFixed(3)}` +
+      ` retry=${groupingRetried ? 1 : 0} chosen_attempt=${groupingAttempt}\n`,
+    )
+
     const usedIds = new Set()
     const committedRowIds = new Set()
     let committedChunks = 0

package/src/runtime/memory/lib/memory-cycle2-gate.mjs

@@ -2,7 +2,7 @@
 // pipe-verdict parsing/validation, the rules-digest cache, the single LLM
 // gate pass (runUnifiedGate) and the Sonnet re-judge cascade. Facade
 // (memory-cycle2.mjs) re-exports the public members unchanged.
-import { existsSync, readFileSync } from 'fs'
+import { existsSync, readFileSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
 import { callAgentDispatch } from './agent-ipc.mjs'
@@ -204,13 +204,20 @@ let _currentRulesDigestTs = 0
 export function loadCurrentRulesDigest() {
   const now = Date.now()
   if (_currentRulesDigest && now - _currentRulesDigestTs < 60_000) return _currentRulesDigest
-  const sources = [
-    join(resourceDir(), 'rules', 'shared', '01-general.md'),
-    join(resourceDir(), 'rules', 'shared', '01-tool.md'),
-    join(resourceDir(), 'rules', 'shared', '04-memory.md'),
-    join(resourceDir(), 'rules', 'shared', '06-team.md'),
-    join(resourceDir(), 'rules', 'shared', '07-workflow.md'),
-  ]
+  // Collect every rule file that loads into live sessions (lead + shared).
+  // Discovered dynamically so rule-layout refactors can't silently empty the
+  // digest again (the old hardcoded shared/* list rotted to one file and the
+  // dedup gate compared against nothing).
+  const sources = []
+  for (const dir of ['lead', 'shared']) {
+    const base = join(resourceDir(), 'rules', dir)
+    try {
+      if (!existsSync(base)) continue
+      for (const f of readdirSync(base).sort()) {
+        if (f.endsWith('.md')) sources.push(join(base, f))
+      }
+    } catch {}
+  }
   const parts = []
   for (const p of sources) {
     try {

package/src/runtime/memory/lib/memory-cycle2-mutations.mjs

@@ -9,6 +9,42 @@ const TIER1_THRESHOLD = 0.78
 const TIER2_LOW = 0.65
 const LLM_JUDGE_CAP = 20
 
+const TRANSIENT_PROMOTE_CATEGORIES = new Set(['task', 'issue'])
+
+// After the gate, cap how many pending→active promotions may land in one batch.
+// Overflow stays pending (not archived). Tiebreak: durable category before
+// task/issue, then score DESC, then older last_seen_at, then id ASC.
+export function clampPendingPromotions(statusBatch, rowsById, activeCount, activeTargetCap) {
+  if (!statusBatch?.length) return { batch: statusBatch ?? [], clamped: 0 }
+  const archives = []
+  const promotions = []
+  for (const item of statusBatch) {
+    if (item.was_pending && item.new_status === 'active') promotions.push(item)
+    else archives.push(item)
+  }
+  const slots = Math.max(0, Number(activeTargetCap) - Number(activeCount))
+  if (promotions.length <= slots) return { batch: statusBatch, clamped: 0 }
+
+  promotions.sort((a, b) => {
+    const ra = rowsById.get(Number(a.entry_id))
+    const rb = rowsById.get(Number(b.entry_id))
+    const ta = TRANSIENT_PROMOTE_CATEGORIES.has(String(ra?.category ?? '').toLowerCase()) ? 1 : 0
+    const tb = TRANSIENT_PROMOTE_CATEGORIES.has(String(rb?.category ?? '').toLowerCase()) ? 1 : 0
+    if (ta !== tb) return ta - tb
+    const sa = Number(ra?.score ?? 0)
+    const sb = Number(rb?.score ?? 0)
+    if (sb !== sa) return sb - sa
+    const la = Number(ra?.last_seen_at ?? 0)
+    const lb = Number(rb?.last_seen_at ?? 0)
+    if (la !== lb) return la - lb
+    return Number(a.entry_id) - Number(b.entry_id)
+  })
+
+  const allowed = promotions.slice(0, slots)
+  const clamped = promotions.length - allowed.length
+  return { batch: [...archives, ...allowed], clamped }
+}
+
 // Batch CTE UPDATE for status-only verdicts (active/archived from pending or active rows).
 // Trigger handles score recompute automatically — no app-side score writes.
 export async function applyBatchStatusVerdicts(db, batch, nowMs) {
@@ -268,6 +304,7 @@ export async function runPhaseMerge(db, options = {}) {
               1 - (e.embedding <=> inner_c.embedding)::float8 AS sim
        FROM core_entries inner_c
        WHERE inner_c.embedding IS NOT NULL
+         AND (inner_c.status IS NULL OR inner_c.status = 'active')
          AND (inner_c.project_id IS NULL OR inner_c.project_id IS NOT DISTINCT FROM e.project_id)
        ORDER BY
          CASE WHEN inner_c.project_id IS NOT DISTINCT FROM e.project_id THEN 0 ELSE 1 END,

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

@@ -10,7 +10,7 @@ import { backfillCoreEmbeddings, nominateCoreCandidates, CORE_SUMMARY_MAX } from
 import { markCycleRequest, consumeCycleRequests, resolveCoalesceMaxDrains, scheduleCoalescedCycleRetry, makeCycleRequestSignature, resolveCoalesceMaxRetries } from './memory-cycle-requests.mjs'
 import { __mixdogMemoryLog, throwIfAborted } from './memory-cycle2-shared.mjs'
 import {
-  applyBatchStatusVerdicts, applySimpleStatus, applyUpdate, applyMerge, runPhaseMerge,
+  applyBatchStatusVerdicts, clampPendingPromotions, applySimpleStatus, applyUpdate, applyMerge, runPhaseMerge,
 } from './memory-cycle2-mutations.mjs'
 import {
   CYCLE2_ACTIVE_TARGET_CAP, loadCurrentRulesDigest, runUnifiedGate, sonnetCascade,
@@ -82,6 +82,7 @@ export async function runCycle2(db, config = {}, options = {}, dataDir = null) {
     promoted: 0, archived: 0, merged: 0, updated: 0, kept: 0, rejected_verb: 0,
     merge_rejected: 0,
     missing_core_summary: 0,
+    promotion_clamped: 0,
     core_embedding_backfill: 0,
     rescore: { updated: 0 },
     phase_merge: { merged: 0, llm_calls: 0, tier1_pairs: 0, tier2_pairs: 0, core_overlap: 0 },
@@ -255,7 +256,10 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
     WHERE is_root = 1
       AND (status = 'pending' OR ($2::boolean AND status = 'active'))
     ORDER BY
-      CASE status WHEN 'pending' THEN 0 WHEN 'active' THEN 1 END ASC,
+      CASE WHEN $2::boolean THEN CASE status WHEN 'active' THEN 0 WHEN 'pending' THEN 1 END
+           ELSE CASE status WHEN 'pending' THEN 0 WHEN 'active' THEN 1 END
+      END ASC,
+      CASE WHEN NOT $2::boolean AND LOWER(category) IN ('task', 'issue') THEN 1 ELSE 0 END ASC,
       reviewed_at ASC NULLS FIRST,
       error_count ASC,
       score ${scoreDir},
@@ -472,7 +476,14 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
       // Status verdicts are applied as one SQL batch; checkpoint before the
       // batch and then again at the next cycle2 unit boundary.
       throwIfAborted(signal)
-      const batchRes = await applyBatchStatusVerdicts(db, statusBatch, nowMs)
+      let activeDemotionsInBatch = 0
+      for (const item of statusBatch) {
+        if (item.new_status === 'archived' && !item.was_pending) activeDemotionsInBatch += 1
+      }
+      const activeCountForClamp = Math.max(0, activeCount - activeDemotionsInBatch)
+      const clampRes = clampPendingPromotions(statusBatch, rowsById, activeCountForClamp, activeTargetCap)
+      stats.promotion_clamped = clampRes.clamped
+      const batchRes = await applyBatchStatusVerdicts(db, clampRes.batch, nowMs)
       stats.promoted += batchRes.promoted
       stats.archived += batchRes.archived
     }
@@ -567,10 +578,8 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
     }
   }
 
-  // Active-cap enforcement is delegated to the gate (phases 1-3): the prompt
-  // exposes Active/cap counts and instructs aggressive `archived` verdicts on
-  // overflow. No deterministic safety net here — if the gate ever fails to
-  // contain growth, fix the prompt, not bolt a fallback back on.
+  // Post-gate promotion clamp (clampPendingPromotions) is the deterministic
+  // active-cap safety net; the gate still contracts when Active > cap.
 
   // Chronic gate-failure sweep: pending roots that have failed the gate 5+
   // times AND are 30+ days old will realistically never pass (their content
@@ -604,6 +613,7 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
     ` core_backfill=${stats.core_embedding_backfill}` +
     ` active=${activeCount}/${activeTargetCap} review_active=${reviewActiveRows ? 1 : 0}` +
     ` | gate promoted=${stats.promoted} archived=${stats.archived}` +
+    ` promotion_clamped=${stats.promotion_clamped}` +
     ` updated=${stats.updated} kept=${stats.kept}` +
     ` rejected_verb=${stats.rejected_verb} merge_rejected=${stats.merge_rejected}` +
     ` missing_core=${stats.missing_core_summary}` +

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

@@ -24,7 +24,7 @@ import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
 import { callAgentDispatch } from './agent-ipc.mjs'
-import { listCore, editCore, deleteCore, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
+import { listCore, editCore, deleteCore, archiveCore, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
 import { loadCurrentRulesDigest } from './memory-cycle2.mjs'
 import { embedText } from './embedding-provider.mjs'
 import { searchRelevantHybrid } from './memory-recall-store.mjs'
@@ -207,6 +207,16 @@ function parseVerdicts(raw, idSet) {
       actions.push({ id, verb: 'merge', targetId, sourceIds })
     } else if (verb === 'delete') {
       actions.push({ id, verb: 'delete' })
+    } else if (verb === 'superseded' || verb === 'supersede') {
+      // Require newer-id proof: `id|superseded|<newer_id>`. Without a valid
+      // newer active core id the supersession has no evidence → drop to keep.
+      const newerId = Number((parts[2] ?? '').trim())
+      if (!Number.isFinite(newerId) || !idSet.has(newerId) || newerId === id) {
+        __mixdogMemoryLog(`[cycle3] superseded rejected: id=${id} invalid/missing newer_id=${parts[2] ?? ''} → keep\n`)
+        actions.push({ id, verb: 'keep' })
+        continue
+      }
+      actions.push({ id, verb: 'superseded', newerId })
     }
   }
   if (!sawValid) return null
@@ -481,9 +491,66 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     if (!actionIds.has(id)) parsed.actions.push({ id, verb: 'keep' })
   }
 
-  let kept = 0, updated = 0, merged = 0, deleted = 0
-  const proposed = { kept: 0, updated: 0, merged: 0, deleted: 0 }
-  const held = { updated: 0, merged: 0, deleted: 0 }
+  // Supersession target liveness: a `superseded` verdict points at a newerId
+  // that must remain LIVE after this batch. If newerId is itself superseded/
+  // delete/merged-away in the same batch, archiving against it retires a row
+  // against a non-live replacement. Resolve the newerId transitively through
+  // chained supersessions to the final live target; if that target is retired
+  // (deleted/merged-away or a supersession cycle/dead-end) → downgrade to keep.
+  {
+    const byId = new Map(parsed.actions.map(a => [Number(a.id), a]))
+    // Two-phase, cycle-safe. Phase 1 computes every resolution against a FROZEN
+    // snapshot of the original verbs/newerIds — the walk never observes another
+    // action's in-progress mutation, so an A→B, B→A mutual cycle can't have A
+    // downgrade first and then let B see A as live. Any id that enters a
+    // supersession cycle yields null (no live target) for ALL its members.
+    // Phase 2 applies the computed resolutions in one pass.
+    const snap = new Map(parsed.actions.map(a => [Number(a.id), {
+      verb: a.verb,
+      newerId: a.newerId != null ? Number(a.newerId) : null,
+      id: Number(a.id),
+      sourceIds: a.sourceIds,
+      targetId: a.targetId,
+    }]))
+    // ids removed from the live pool by their own verdict (not superseded —
+    // that is chased transitively below).
+    const retiredBySnap = (s) => s && (s.verb === 'delete' ||
+      (s.verb === 'merge' && s.sourceIds?.includes(s.id) && s.targetId !== s.id))
+    const resolveLiveTarget = (startId) => {
+      let cur = Number(startId)
+      const seen = new Set()
+      while (true) {
+        if (seen.has(cur)) return null // supersession cycle → no live target
+        seen.add(cur)
+        const s = snap.get(cur)
+        if (!s) return null
+        if (retiredBySnap(s)) return null // target itself removed this batch
+        if (s.verb === 'superseded') { cur = Number(s.newerId); continue }
+        return cur // keep/update/merge-survivor → live
+      }
+    }
+    // Phase 1: resolve against frozen snapshot.
+    const resolutions = []
+    for (const a of parsed.actions) {
+      if (a.verb !== 'superseded') continue
+      resolutions.push({ action: a, live: resolveLiveTarget(a.newerId) })
+    }
+    // Phase 2: apply.
+    for (const { action: a, live } of resolutions) {
+      if (live == null) {
+        __mixdogMemoryLog(`[cycle3] superseded downgraded to keep: id=${a.id} newerId=${a.newerId} not live after batch\n`)
+        a.verb = 'keep'
+        delete a.newerId
+      } else if (live !== Number(a.newerId)) {
+        __mixdogMemoryLog(`[cycle3] superseded newerId resolved transitively: id=${a.id} ${a.newerId}->${live}\n`)
+        a.newerId = live
+      }
+    }
+  }
+
+  let kept = 0, updated = 0, merged = 0, deleted = 0, superseded = 0
+  const proposed = { kept: 0, updated: 0, merged: 0, deleted: 0, superseded: 0 }
+  const held = { updated: 0, merged: 0, deleted: 0, superseded: 0 }
   const details = []
   const touched = new Set() // ids already acted on this cycle — avoid double action
 
@@ -550,6 +617,38 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
       }
       continue
     }
+    if (a.verb === 'superseded') {
+      proposed.superseded++
+      // Supersession archives (status flip), never physical DELETE, and applies
+      // in DEFAULT (conservative) mode — reversible and audit-retained, so it is
+      // safe without the confirmed gate that outright deletes require.
+      if (!mutate) {
+        held.superseded++
+        details.push({
+          id: a.id, verb: 'superseded', applied: false, held: true,
+          reason: 'proposal mode',
+        })
+        touched.add(a.id)
+        continue
+      }
+      try {
+        const core = coreById.get(a.id)
+        const res = await archiveCore(dataDir, a.id, core ? { element: core.element, summary: core.summary } : null)
+        if (res?.skipped) {
+          held.superseded++
+          details.push({ id: a.id, verb: 'superseded', newerId: a.newerId, applied: false, held: true, reason: res.reason })
+        } else {
+          superseded++
+          details.push({ id: a.id, verb: 'superseded', newerId: a.newerId, applied: true })
+        }
+        touched.add(a.id)
+      } catch (err) {
+        if (signal?.aborted) throw signal.reason ?? err
+        __mixdogMemoryLog(`[cycle3] supersede archive failed id=${a.id}: ${err.message}\n`)
+        details.push({ id: a.id, verb: 'superseded', error: err.message })
+      }
+      continue
+    }
     if (a.verb === 'merge') {
       if (a.targetId !== a.id && !a.sourceIds.includes(a.id)) {
         __mixdogMemoryLog(
@@ -638,9 +737,10 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     `[cycle3] reviewed=${cores.length} kept=${kept}` +
     ` proposed_update=${proposed.updated} proposed_merge=${proposed.merged} proposed_delete=${proposed.deleted}` +
     ` applied_update=${updated} applied_merge=${merged} applied_delete=${deleted}` +
-    ` held_update=${held.updated} held_merge=${held.merged} held_delete=${held.deleted}` +
+    ` applied_superseded=${superseded}` +
+    ` held_update=${held.updated} held_merge=${held.merged} held_delete=${held.deleted} held_superseded=${held.superseded}` +
     ` mode=${applyMode}\n`,
   )
 
-  return { reviewed: cores.length, kept, updated, merged, deleted, proposed, held, applied: mutate, applyMode, details }
+  return { reviewed: cores.length, kept, updated, merged, deleted, superseded, proposed, held, applied: mutate, applyMode, details }
 }

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

@@ -455,6 +455,11 @@ export async function ensureCurrentSchemaExtensions(db, dims) {
   // re-nominates the same entry.
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS core_candidate_status text`)
   await db.exec(`ALTER TABLE entries ADD COLUMN IF NOT EXISTS core_candidate_at bigint`)
+  // cycle3 supersession retirement: archive (status flip) instead of physical
+  // DELETE for facts a newer active fact replaced. Additive nullable columns —
+  // legacy rows read as NULL status = active. No data migration required.
+  await db.exec(`ALTER TABLE core_entries ADD COLUMN IF NOT EXISTS status text`)
+  await db.exec(`ALTER TABLE core_entries ADD COLUMN IF NOT EXISTS archived_at bigint`)
   // No index on core_candidate_status by design (round-2 finding #4): the only
   // readers are listCoreCandidates (user picker, on-demand) and
   // nominateCoreCandidates (once per cycle2, hourly). Both are rare and the
@@ -470,7 +475,8 @@ export async function ensureCurrentSchemaExtensions(db, dims) {
       SELECT id,
              row_number() OVER (
                PARTITION BY project_id, element
-               ORDER BY updated_at DESC NULLS LAST, id DESC
+               ORDER BY (CASE WHEN status IS NULL OR status = 'active' THEN 0 ELSE 1 END),
+                        updated_at DESC NULLS LAST, id DESC
              ) AS rn
       FROM core_entries
     ), deleted AS (

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

@@ -241,6 +241,7 @@ export function createQueryHandlers({
              (${hitExpr}) AS hit_count
       FROM core_entries
       WHERE ${where.join(' AND ')}
+        AND (status IS NULL OR status = 'active')
       ORDER BY hit_count DESC, updated_at DESC, id ASC
       LIMIT $${params.length}
     `, params)).rows