mixdog 0.9.12 → 0.9.14

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-embed.mjs

@@ -430,7 +430,41 @@ async function syncBatchEmbeddings(db, ids, options = {}) {
   throwIfAborted(signal)
   const writtenIds = (res.rows || []).map(r => Number(r.id))
   if (writtenIds.length < updates.length) {
-    __mixdogMemoryLog(`[embed-sync] ${updates.length - writtenIds.length} stale-write(s) skipped — text changed since read\n`)
+    const writtenSet = new Set(writtenIds)
+    const missed = updates.filter((u) => !writtenSet.has(u.id))
+    const missedIds = missed.map((u) => u.id)
+    const curRows = missedIds.length
+      ? (await db.query(
+          `SELECT id, embedding IS NOT NULL AS has_embedding, element, summary
+           FROM memory.entries WHERE id = ANY($1::bigint[]) AND is_root = 1`,
+          [missedIds],
+        )).rows
+      : []
+    const curById = new Map(curRows.map((r) => [Number(r.id), r]))
+    let staleSkips = 0
+    let concurrentSkips = 0
+    for (const u of missed) {
+      const cur = curById.get(u.id)
+      if (!cur) continue
+      const textUnchanged =
+        (cur.element === u.element || (cur.element == null && u.element == null)) &&
+        (cur.summary === u.summary || (cur.summary == null && u.summary == null))
+      if (!textUnchanged) {
+        staleSkips++
+        continue
+      }
+      if (cur.has_embedding) {
+        concurrentSkips++
+        continue
+      }
+      staleSkips++
+    }
+    if (staleSkips > 0) {
+      __mixdogMemoryLog(`[embed-sync] ${staleSkips} stale-write(s) skipped — text changed since read\n`)
+    }
+    if (concurrentSkips > 0 && process.env.MIXDOG_DEBUG_EMBED) {
+      __mixdogMemoryLog(`[embed-sync] ${concurrentSkips} concurrent embed write(s) skipped — already embedded\n`)
+    }
   }
   return writtenIds
 }

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

package/src/standalone/agent-tool.mjs

@@ -16,9 +16,13 @@ import { updateJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { normalizeAgentPermission } from '../runtime/shared/markdown-frontmatter.mjs';
 import { prepareAgentSession } from '../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import {
+  abortAgentProgressWatchdog,
   agentWatchdogPolicyActive,
   evaluateAgentWatchdogAbort,
   resolveAgentWatchdogPolicy,
+  resolveHandoffMessageStartIndex,
+  watchdogPartialHandoffFromError,
+  AgentStallAbortError,
 } from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { buildAgentTaskProgressFields } from './agent-task-status.mjs';
 import { AGENT_OWNER } from '../runtime/agent/orchestrator/agent-owner.mjs';
@@ -962,13 +966,15 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     }, notifyContext);
   }
 
-  function startProgressIdleWatchdog(sessionId, watchdogPolicy) {
+  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
     if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
     if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
     if (typeof mgr.linkParentSignalToSession !== 'function') return null;
     const controller = new AbortController();
+    const anchorTs = Date.now();
     try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
     const timer = setInterval(() => {
+      if (controller.signal?.aborted) return;
       const now = Date.now();
       const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
         ? mgr.getSessionProgressSnapshot(sessionId)
@@ -976,15 +982,36 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       const abortErr = snapshot
         ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
         : null;
+      const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
+      const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
       if (!abortErr && !snapshot) {
-        const last = mgr.getSessionLastProgressAt(sessionId);
-        if (watchdogPolicy.idleStaleMs > 0 && last && now - last > watchdogPolicy.idleStaleMs) {
-          try { controller.abort(new Error(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`)); } catch {}
+        const reported = mgr.getSessionLastProgressAt(sessionId);
+        const last = reported || anchorTs;
+        if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
+          abortAgentProgressWatchdog(controller, {
+            sessionId,
+            agent,
+            error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
+            policy: watchdogPolicy,
+            now,
+            anchorTs,
+            lastProgressAt: reported,
+            iteration,
+          });
         }
         return;
       }
       if (abortErr) {
-        try { controller.abort(abortErr); } catch {}
+        abortAgentProgressWatchdog(controller, {
+          sessionId,
+          agent,
+          error: abortErr,
+          snapshot,
+          policy: watchdogPolicy,
+          now,
+          anchorTs,
+          iteration,
+        });
       }
     }, 1000);
     timer.unref?.();
@@ -1072,7 +1099,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
 
   async function runSpawn(prepared, notifyContext = null, job = null) {
     const { args, tag, session, agent, preset, presetName, workerCwd, prompt, watchdogPolicy } = prepared;
-    const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy);
+    const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy, agent);
     let finalStatus = 'idle';
     // SubagentStart: a worker session is about to run its first turn.
     emitSubagentEvent('start', agent, { session_id: session.id, tag });
@@ -1086,6 +1113,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       status: 'running',
       stage: 'running',
     });
+    let handoffMsgStart = 0;
     try {
       const completionValue = (result) => {
         // Promote an abnormal finish (iteration cap, truncation, or a public
@@ -1107,6 +1135,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           ...(abnormalError ? { error: abnormalError } : {}),
         };
       };
+      handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
       const result = await mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, {
         notifyFn: workerNotifyFn(session.id, notifyContext || {}),
         ...(job ? {
@@ -1155,6 +1184,33 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       }
       return finalValue;
     } catch (error) {
+      const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
+      if (partial) {
+        finalStatus = 'idle';
+        const value = {
+          tag,
+          sessionId: session.id,
+          agent,
+          preset: presetKey(preset) || presetName,
+          provider: preset.provider,
+          model: preset.model,
+          effort: preset.effort || null,
+          fast: preset.fast === true,
+          content: partial,
+          stallAbort: true,
+        };
+        if (job) job._terminalResultValue = value;
+        if (job?.taskId) {
+          try {
+            reconcileBackgroundTask(job.taskId, {
+              status: 'completed',
+              result: value,
+              terminalReason: 'agent-watchdog-partial',
+            });
+          } catch {}
+        }
+        return value;
+      }
       finalStatus = 'error';
       // Part C: a mid-stream stall (StreamStalledError / ESTREAMSTALL) throws
       // here WITHOUT a terminal result, so the finally reconcile below (gated on
@@ -1229,10 +1285,11 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   async function runSend(prepared, notifyContext = null, job = null) {
     const { args, session, sessionId, prompt } = prepared;
     const sendAgent = session.agent || normalizeAgentName(args.agent);
-    const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent));
+    const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent);
     const tag = tagForSession(sessionId);
     let finalStatus = 'idle';
     upsertWorkerSessionDeferred(session, tag, { status: 'running', stage: 'running' });
+    let handoffMsgStart = 0;
     try {
       const completionValue = (result) => {
         // Same abnormal-empty → error promotion as runSpawn: a reused/`send`
@@ -1249,6 +1306,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           ...(abnormalError ? { error: abnormalError } : {}),
         };
       };
+      handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const result = await mgr.askSession(sessionId, prompt, args.context || null, null, session.cwd || defaultCwd, null, {
         notifyFn: workerNotifyFn(sessionId, notifyContext || {}),
         ...(job ? {
@@ -1287,6 +1345,30 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       }
       return finalValue;
     } catch (error) {
+      const partial = watchdogPartialHandoffFromError(error, mgr.getSession(sessionId), handoffMsgStart);
+      if (partial) {
+        finalStatus = 'idle';
+        const value = {
+          tag,
+          sessionId,
+          agent: session.agent || null,
+          provider: session.provider,
+          model: session.model,
+          content: partial,
+          stallAbort: true,
+        };
+        if (job) job._terminalResultValue = value;
+        if (job?.taskId) {
+          try {
+            reconcileBackgroundTask(job.taskId, {
+              status: 'completed',
+              result: value,
+              terminalReason: 'agent-watchdog-partial',
+            });
+          } catch {}
+        }
+        return value;
+      }
       finalStatus = 'error';
       // Part C (send path mirror): a mid-stream stall throws with no terminal
       // result — reconcile to `failed` so the owner is notified rather than the