mixdog 0.9.12 → 0.9.14

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

@@ -30,6 +30,8 @@ const CYCLE1_AUTO_RESTART_COOLDOWN_MS = 5 * 60_000
 const BACKLOG_WARN_COOLDOWN_MS = 10 * 60_000
 const BACKLOG_WARN_PENDING = 500
 const BACKLOG_WARN_FAILURES = 5
+// Max back-to-back cycle2 passes per scheduled slot (config: cycle2.catchup_passes).
+const CYCLE2_CATCHUP_PASSES = 4
 
 export function createCycleScheduler(deps) {
   const {
@@ -255,20 +257,41 @@ export function createCycleScheduler(deps) {
       _cycle2InFlight = true
       markCycleRunning('cycle2')
       try {
-        let c2Options = {
-          coalescedRetry: true,
-          onCoalescedSuccess: _finalizeCycle2Run,
-        }
-        if (typeof c2Options?.callLlm !== 'function') {
-          c2Options = { ...c2Options, callLlm: getCycle2CallLlm() }
-        }
-        const result = await runCycle2(getDb(), config, c2Options, dataDir)
-        if (result?.skippedInFlight) {
-          scheduleScheduledCycle2(config, signature, attempt + 1)
-        } else if (result?.coalescedRetryNoop) {
-          log('[cycle2] scheduled queue noop\n')
-        } else if (result?.ok === false) {
-          await _finalizeCycle2Run(result)
+        // Catch-up drain: one scheduled slot may run several back-to-back
+        // passes while pending roots remain, so a backlog above the batch
+        // size drains in one interval instead of one batch per hour.
+        const drainPasses = Math.max(1, Number(config?.catchup_passes ?? CYCLE2_CATCHUP_PASSES))
+        for (let pass = 0; pass < drainPasses; pass++) {
+          let c2Options = {
+            coalescedRetry: true,
+            onCoalescedSuccess: _finalizeCycle2Run,
+          }
+          if (typeof c2Options?.callLlm !== 'function') {
+            c2Options = { ...c2Options, callLlm: getCycle2CallLlm() }
+          }
+          const result = await runCycle2(getDb(), config, c2Options, dataDir)
+          if (result?.skippedInFlight) {
+            scheduleScheduledCycle2(config, signature, attempt + 1)
+            break
+          }
+          if (result?.coalescedRetryNoop) {
+            log('[cycle2] scheduled queue noop\n')
+            break
+          }
+          if (result?.ok === false) {
+            await _finalizeCycle2Run(result)
+            break
+          }
+          // A gate parse/coverage failure marks the run failed even with
+          // ok=true; never chain passes on a failing gate.
+          if (result?.gate_failed === true) break
+          if (pass + 1 >= drainPasses) break
+          const pendingRes = await getDb().query(
+            `SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'pending'`,
+          )
+          const pendingLeft = Number(pendingRes?.rows?.[0]?.c ?? 0)
+          if (pendingLeft <= 0) break
+          log(`[cycle2] catch-up pass ${pass + 2}/${drainPasses}: pending=${pendingLeft}\n`)
         }
       } catch (err) {
         log(`[cycle2] scheduled queue failed: ${err?.message || err}\n`)
@@ -324,15 +347,17 @@ export function createCycleScheduler(deps) {
       log('[cycle2] skipped: in flight\n')
       return
     }
-    if (result.ok) {
+    const gateFailed = result?.gate_failed === true
+    if (result.ok && !gateFailed) {
       await setCycleLastRun('cycle2', Date.now())
       await setCycleLastRun('cycle2_last_error', '')
       log('[cycle2] completed\n')
       markCycleDone('cycle2', true)
     } else {
-      await setCycleLastRun('cycle2_last_error', result.error || 'unknown error')
-      log(`[cycle2] failed: ${result.error}\n`)
-      markCycleDone('cycle2', false, result.error || 'unknown error')
+      const err = gateFailed ? 'gate_failed' : (result.error || 'unknown error')
+      await setCycleLastRun('cycle2_last_error', err)
+      log(`[cycle2] failed: ${err}\n`)
+      markCycleDone('cycle2', false, err)
     }
   }
 
@@ -487,6 +512,15 @@ export function createCycleScheduler(deps) {
     startCycle1Run: _startCycle1Run,
     awaitCycle1Run: _awaitCycle1Run,
     finalizeCycle2Run: _finalizeCycle2Run,
+    // cycle3 success recorder: MCP-driven runs go through runCycle3 directly
+    // (no coalesced onCoalescedSuccess), so callers stamp success here to keep
+    // cycles.cycle3.last_success_at honest. Non-mutating/failed runs skipped.
+    finalizeCycle3Run: async (result) => {
+      if (!result || result.skippedInFlight || result.coalescedRetryNoop) return
+      if (result.error) { markCycleDone('cycle3', false, result.error); return }
+      await setCycleLastRun('cycle3', Date.now())
+      markCycleDone('cycle3', true)
+    },
     periodicCycle1Config,
     // lifecycle
     startCycles,

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'
@@ -48,8 +48,8 @@ function formatEntriesForPromotePrompt(rows, pidMap, opts = {}) {
   const map = pidMap ?? buildPidMap([rows])
   // When numbered, prefix each row with its 1-based prompt-order ordinal so the
   // gate LLM can echo a row number it can see, instead of inventing one. The
-  // ordinal domain (1..N) and the 5-digit batch-id domain must stay disjoint —
-  // see the ordinalToId invariant in runUnifiedGate.
+  // ordinal domain (1..N) vs batch ids that share those integers on a *different*
+  // row — see batchOrdinalIdCollides in runUnifiedGate.
   const numbered = opts.numbered === true
   const lines = rows.map((r, i) => {
     const tag = r.project_id ? (map.get(r.project_id) ?? 'C') : 'C'
@@ -78,6 +78,17 @@ function formatUserCoreForPrompt(rows, pidMap) {
 // Parse pipe-format unified verdicts. Each line: <id>|<verb> [|...].
 // Verbs validated against the row's current status via STATUS_ALLOWED_VERBS.
 // Returns { actions, rejected } or null when no parseable lines.
+// True when some entry id K in 1..N is also the row-ordinal label for a different
+// entry (token K is ambiguous between id K and "row K").
+export function batchOrdinalIdCollides(statusById, ordinalToId, rowCount) {
+  const n = Math.max(0, Number(rowCount) || 0)
+  for (let k = 1; k <= n; k++) {
+    if (!statusById.has(k)) continue
+    if (ordinalToId.get(k) !== k) return k
+  }
+  return null
+}
+
 function parseUnifiedFormat(raw, statusById, ordinalToId = null) {
   if (raw == null) return null
   const text = String(raw).trim()
@@ -88,10 +99,9 @@ function parseUnifiedFormat(raw, statusById, ordinalToId = null) {
   const support = new Map()
   let sawValid = false
   // Resolve a first-field/merge token to a real batch id. The gate may echo
-  // either the exact 5-digit batch id OR the 1-based row ordinal shown in the
-  // numbered Entries block. The two domains are disjoint (asserted in
-  // runUnifiedGate), so an exact-id hit always wins and an unmatched value
-  // falls back to ordinal lookup; anything else is NaN (line treated invalid).
+  // either the exact batch id OR the 1-based row ordinal shown in the numbered
+  // Entries block. When batchOrdinalIdCollides is false, an exact-id hit wins
+  // and an unmatched value falls back to ordinal lookup; anything else is NaN.
   const resolveId = (tok) => {
     const n = Number(String(tok ?? '').trim())
     if (!Number.isFinite(n)) return NaN
@@ -194,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 {
@@ -333,18 +350,13 @@ export async function runUnifiedGate(db, rows, activeContext, config = {}, optio
 
   const statusById = new Map(rows.map(r => [Number(r.id), String(r.status)]))
   // Ordinal → batch-id map, keyed by 1-based prompt order (the same order the
-  // numbered Entries block uses). The gate may echo either the real 5-digit
-  // batch id or the row ordinal 1..N; the parser resolves both. The two domains
-  // MUST be disjoint or an ordinal could shadow a real id (ids are 5-digit,
-  // ordinals are <= rows.length, so disjointness always holds in practice).
-  // On a violation a row-number line is indistinguishable from an exact-id
-  // line, so no safe interpretation exists — skip this batch (gate failure)
-  // rather than risk applying a verdict to the wrong entry. The cycle itself
-  // proceeds; the batch re-queues for a later run.
+  // numbered Entries block uses). The gate may echo either the real batch id
+  // or the row ordinal 1..N; the parser resolves both when no integer token is
+  // ambiguous (id K present in batch but row K points at a different entry).
   const ordinalToId = new Map(rows.map((r, i) => [i + 1, Number(r.id)]))
-  const minBatchId = Math.min(...[...statusById.keys()])
-  if (Number.isFinite(minBatchId) && minBatchId <= rows.length) {
-    __mixdogMemoryLog(`[cycle2] batch id ${minBatchId} collides with ordinal range 1..${rows.length} — skipping batch (no safe id resolution)\n`)
+  const collideToken = batchOrdinalIdCollides(statusById, ordinalToId, rows.length)
+  if (collideToken != null) {
+    __mixdogMemoryLog(`[cycle2] batch id ${collideToken} collides with row ordinal ${collideToken} (id ${ordinalToId.get(collideToken)}) — skipping batch (no safe id resolution)\n`)
     return { actions: null, rejected: new Set(), parseOk: false }
   }
 

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}` +