mixdog 0.9.24 → 0.9.26

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

@@ -11,6 +11,65 @@ const LLM_JUDGE_CAP = 20
 
 const TRANSIENT_PROMOTE_CATEGORIES = new Set(['task', 'issue'])
 
+// Category grades the pipeline trusts outright: user/cycle1 tagged durable
+// knowledge. These are NEVER content-scanned — a curated constraint like
+// "95% pass threshold" or a rule that cites a metric must still promote.
+const DURABLE_TRUSTED_CATEGORIES = new Set(['rule', 'constraint', 'decision', 'preference', 'goal'])
+
+// Deterministic (non-LLM) signature for transient work-state: status/review
+// churn and benchmark/measurement RESULT snapshots. Narrow on purpose — it
+// requires snapshot phrasing (a measurement verb or an explicit result-metric
+// noun), NOT a bare percentage, so SLO/threshold constraints don't trip it.
+// Applied only to non-durable categories (e.g. 'fact'), catching benchmark
+// snapshots mis-tagged as durable-ish. The gate prompt only *discourages*
+// these; this is the structural enforcement.
+const TRANSIENT_SNAPSHOT_RE = new RegExp(
+  [
+    'terminal-bench',
+    '\\bbenchmark(ed|ing|\\s+(run|result|score))\\b',
+    'pass@\\d',
+    '\\btokens?\\s?\\/\\s?s(ec)?\\b',
+    'status\\s+snapshot',
+    'review(er)?\\s+(validation\\s+)?cycles?',
+    'in[-\\s]progress',
+    '\\bWIP\\b',
+    '\\b(scored|achieved|measured|reached)\\b[^.]{0,40}\\d+(\\.\\d+)?\\s?%',
+    '\\d+(\\.\\d+)?\\s?%\\s+(pass\\s+rate|accuracy|score|throughput|latency)',
+  ].join('|'),
+  'i',
+)
+
+// Structural promotion gate: is this row transient content (task/issue chatter
+// or a status/benchmark snapshot) that must not be promoted pending→active?
+// task/issue block by category. Durable knowledge categories are trusted and
+// skip the content scan. Everything else (e.g. 'fact') is content-scanned so
+// snapshots mis-categorized as durable are still blocked.
+export function isTransientPromotion(row) {
+  if (!row) return false
+  const cat = String(row.category ?? '').toLowerCase()
+  if (TRANSIENT_PROMOTE_CATEGORIES.has(cat)) return true
+  if (DURABLE_TRUSTED_CATEGORIES.has(cat)) return false
+  return TRANSIENT_SNAPSHOT_RE.test(`${row.element ?? ''} ${row.summary ?? ''}`)
+}
+
+// Strip pending→active promotions for transient content out of the status
+// batch BEFORE the cap clamp. Blocked rows are simply dropped from the batch,
+// so they stay pending (held for re-confirmation on a later cycle) — never
+// archived here, and reviewed_at is still bumped via the caller's reviewedIds.
+export function blockTransientPromotions(statusBatch, rowsById) {
+  if (!statusBatch?.length) return { batch: statusBatch ?? [], blocked: 0 }
+  let blocked = 0
+  const batch = statusBatch.filter((item) => {
+    if (item.was_pending && item.new_status === 'active'
+        && isTransientPromotion(rowsById.get(Number(item.entry_id)))) {
+      blocked += 1
+      return false
+    }
+    return true
+  })
+  return { batch, blocked }
+}
+
 // 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.

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

@@ -11,7 +11,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, clampPendingPromotions, applySimpleStatus, applyUpdate, applyMerge, runPhaseMerge,
+  applyBatchStatusVerdicts, clampPendingPromotions, blockTransientPromotions, applySimpleStatus, applyUpdate, applyMerge, runPhaseMerge,
 } from './memory-cycle2-mutations.mjs'
 import {
   CYCLE2_ACTIVE_TARGET_CAP, CYCLE2_ACTIVE_MIN_FLOOR, loadCurrentRulesDigest, runUnifiedGate, sonnetCascade,
@@ -54,6 +54,7 @@ function mergeCycle2Results(a, b) {
     rejected_verb: Number(a.rejected_verb || 0) + Number(b.rejected_verb || 0),
     merge_rejected: Number(a.merge_rejected || 0) + Number(b.merge_rejected || 0),
     missing_core_summary: Number(a.missing_core_summary || 0) + Number(b.missing_core_summary || 0),
+    promotion_blocked: Number(a.promotion_blocked || 0) + Number(b.promotion_blocked || 0),
     core_embedding_backfill: Number(a.core_embedding_backfill || 0) + Number(b.core_embedding_backfill || 0),
     core_candidates_nominated: Number(a.core_candidates_nominated || 0) + Number(b.core_candidates_nominated || 0),
     rescore: mergeNestedNumeric(a.rescore, b.rescore),
@@ -211,6 +212,7 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
     updated: 0, kept: 0, rejected_verb: 0,
     merge_rejected: 0,
     missing_core_summary: 0,
+    promotion_blocked: 0,
     core_embedding_backfill: 0,
     core_candidates_nominated: 0,
     rescore: { updated: 0 },
@@ -523,8 +525,13 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
         }
         guardedBatch.push(item)
       }
+      // Structural transient block runs BEFORE the cap clamp: task/issue chatter
+      // and status/benchmark snapshots can never promote pending→active, so they
+      // are stripped here (held pending) regardless of remaining cap slots.
+      const blockRes = blockTransientPromotions(guardedBatch, rowsById)
+      stats.promotion_blocked = blockRes.blocked
       const activeCountForClamp = Math.max(0, activeCount - reservedDemotions)
-      const clampRes = clampPendingPromotions(guardedBatch, rowsById, activeCountForClamp, activeTargetCap)
+      const clampRes = clampPendingPromotions(blockRes.batch, rowsById, activeCountForClamp, activeTargetCap)
       stats.promotion_clamped = clampRes.clamped
       const batchRes = await applyBatchStatusVerdicts(db, clampRes.batch, nowMs)
       stats.promoted += batchRes.promoted
@@ -702,7 +709,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}` +
+    ` promotion_clamped=${stats.promotion_clamped} promotion_blocked=${stats.promotion_blocked}` +
     ` 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

@@ -11,13 +11,17 @@ function __mixdogMemoryLog(...args) {
 // {{CORE_REVIEW}} block for defaults/cycle3-review-prompt.md, then asks the
 // maintenance-preset LLM for one verdict per id. By default Cycle3 performs
 // conservative cleanup: safe compression updates and strict duplicate merges
-// are applied, while deletes stay proposals unless explicitly confirmed.
+// are applied. Deletes now also apply in conservative mode when the model
+// tags the entry as clear junk (a whitelisted junk reason) and — for
+// redundant-with-default reasons — the text actually echoes a current rule,
+// bounded by a per-run delete cap so a run keeps a safety margin instead of
+// nuking the whole set. Unreasoned / non-junk deletes still require APPLY.
 //
 // Verdict line grammar (mirrors parseUnifiedFormat in memory-cycle2.mjs):
 //   <id>|keep
 //   <id>|update|<element>|<summary>
 //   <id>|merge|<target_id>|<source_ids_csv>
-//   <id>|delete
+//   <id>|delete|<reason>
 
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
@@ -136,6 +140,58 @@ function isStrictDuplicate(a, b) {
   return sim >= 0.78
 }
 
+// Whitelisted delete reasons that conservative mode may auto-apply. These are
+// the "clear junk" classes: a copy of a built-in/default rule, a bare
+// restatement, an obsolete/already-implemented decision, or a past-event log.
+// Anything outside this set (or a bare `delete` with no reason) stays held for
+// APPLY CYCLE3 so genuinely durable rules are never removed unattended.
+const SAFE_DELETE_REASONS = new Set([
+  'duplicate', 'dup', 'duplicate_of_default', 'default', 'redundant',
+  'restatement', 'restate', 'restates_default',
+  'obsolete', 'implemented', 'done', 'completed', 'resolved',
+  'superseded_decision', 'stale', 'past_event', 'event_log', 'log',
+])
+// Reasons that claim redundancy with a built-in/default rule — these demand
+// corroboration (the core text must actually echo the current rules digest)
+// before a conservative auto-delete, so a mislabelled durable rule survives.
+const DEFAULT_ECHO_REASONS = new Set([
+  'duplicate', 'dup', 'duplicate_of_default', 'default', 'redundant',
+  'restatement', 'restate', 'restates_default',
+])
+
+function normalizeDeleteReason(reason) {
+  return String(reason ?? '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+}
+
+// Max trigram similarity of `text` against any substantive line of the current
+// rules digest — how strongly a core entry echoes a built-in rule.
+function digestRedundancy(text, rulesDigest) {
+  if (!text || !rulesDigest) return 0
+  const lines = String(rulesDigest).split('\n').map(l => l.trim()).filter(l => l.length >= 12)
+  let best = 0
+  for (const line of lines) {
+    const d = charDice(text, line)
+    if (d > best) best = d
+    if (best >= 0.9) break
+  }
+  return best
+}
+
+function isSafeConservativeDelete(core, action, rulesDigest) {
+  const reason = normalizeDeleteReason(action?.reason)
+  if (!reason) return { ok: false, reason: 'delete needs a junk reason → APPLY CYCLE3' }
+  if (!SAFE_DELETE_REASONS.has(reason)) return { ok: false, reason: `delete reason "${reason}" not in safe set → APPLY CYCLE3` }
+  if (DEFAULT_ECHO_REASONS.has(reason)) {
+    const red = digestRedundancy(coreText(core), rulesDigest)
+    if (red < 0.5) return { ok: false, reason: `not redundant with defaults (sim=${red.toFixed(2)})` }
+  }
+  return { ok: true, reason }
+}
+
 function formatRelatedRow(r) {
   const tag = r.project_id ? r.project_id : 'COMMON'
   const stat = r.status ? `[${r.status}]` : '[?]'
@@ -206,7 +262,8 @@ function parseVerdicts(raw, idSet) {
       }
       actions.push({ id, verb: 'merge', targetId, sourceIds })
     } else if (verb === 'delete') {
-      actions.push({ id, verb: 'delete' })
+      const reason = (parts[2] ?? '').trim()
+      actions.push({ id, verb: 'delete', reason: reason || null })
     } 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.
@@ -553,6 +610,10 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
   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
+  // Safety margin: even when every junk verdict is legitimate, a single
+  // conservative run applies at most this many outright deletes and holds the
+  // rest for the next pass. Prevents an over-eager model from clearing the set.
+  const conservativeDeleteCap = Math.max(1, Math.ceil(cores.length * 0.35))
 
   // Core-store edit/delete calls are the mutation unit; checkpoints sit before
   // each action/source and after each awaited unit, not inside one file-store write.
@@ -596,19 +657,28 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     }
     if (a.verb === 'delete') {
       proposed.deleted++
-      if (!confirmed) {
+      // confirmed → always delete. conservative → delete only clear junk (safe
+      // reason, corroborated for redundant-with-default), capped per run.
+      // proposal → always hold.
+      let applyDelete = confirmed
+      let holdReason = 'proposal mode'
+      let safeReason = null
+      if (!confirmed && conservative) {
+        const safeDel = isSafeConservativeDelete(coreById.get(a.id), a, rulesDigest)
+        if (!safeDel.ok) holdReason = safeDel.reason
+        else if (deleted >= conservativeDeleteCap) holdReason = `conservative delete cap ${conservativeDeleteCap} reached`
+        else { applyDelete = true; safeReason = safeDel.reason }
+      }
+      if (!applyDelete) {
         held.deleted++
-        details.push({
-          id: a.id, verb: 'delete', applied: false, held: true,
-          reason: conservative ? 'delete requires APPLY CYCLE3' : 'proposal mode',
-        })
+        details.push({ id: a.id, verb: 'delete', applied: false, held: true, reason: holdReason })
         touched.add(a.id)
         continue
       }
       try {
         await deleteCore(dataDir, a.id)
         deleted++
-        details.push({ id: a.id, verb: 'delete', applied: true })
+        details.push({ id: a.id, verb: 'delete', applied: true, reason: safeReason || 'confirmed' })
         touched.add(a.id)
       } catch (err) {
         if (signal?.aborted) throw signal.reason ?? err

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

@@ -75,7 +75,11 @@ async function _initClient(client, schema) {
   // memory.entries from a trace-schema connection, or recall × trace JOIN
   // analytics) MUST use fully-qualified names (memory.entries / trace.trace_events).
   // Relying on search_path silently in cross-schema code = bug magnet.
-  const sp = schema === 'trace' ? 'trace, public' : 'memory, public'
+  const sp = schema === 'trace'
+    ? 'trace, public'
+    : schema === 'scheduler'
+      ? 'scheduler, public'
+      : 'memory, public'
   await client.query(`SET search_path = ${sp}`)
   // pg_trgm similarity threshold: session-local, must be set per connection.
   await client.query(`SELECT set_limit(0.10)`)
@@ -331,6 +335,7 @@ async function bootstrapInstance(pgPool, dataDirKey) {
       await client.query(`CREATE EXTENSION IF NOT EXISTS pg_trgm WITH SCHEMA public`)
       await client.query(`CREATE SCHEMA IF NOT EXISTS memory`)
       await client.query(`CREATE SCHEMA IF NOT EXISTS trace`)
+      await client.query(`CREATE SCHEMA IF NOT EXISTS scheduler`)
     } finally {
       client.release()
     }

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

@@ -290,7 +290,12 @@ export async function startPg({ runtimeDir, pgdataDir, port: preferredPort = 554
   // so we return the instant pg_isready succeeds rather than waiting on pg_ctl.
   // Only the long-lived child handle is unref'd; poll timers stay ref'd.
   async function startAndWaitReady() {
-    const child = spawn(pgctl, startArgs, { env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    // detached on win32: give pg_ctl (and the postmaster it spawns) its own
+    // process group / console so an ancestor `taskkill /F /T` cannot enumerate
+    // it via the Node process tree. The orphaned postmaster survives and is
+    // re-adopted next boot via supervisor tryReusePgInstance (postmaster.pid).
+    const detached = process.platform === 'win32'
+    const child = spawn(pgctl, startArgs, { env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, detached })
     child.unref?.()
     let stdout = '', stderr = '', closed = false, exitCode = null
     child.stdout?.on('data', d => { stdout += d.toString() })
@@ -375,6 +380,19 @@ export async function stopPg({ runtimeDir, pgdataDir }) {
   }
 }
 
+// Synchronous best-effort variant for a process 'exit' hook (only sync work is
+// possible there). One bounded `pg_ctl stop -m fast`; never throws. On Windows
+// a force-kill of the daemon can orphan the postmaster mid-write, so this is
+// the last-ditch graceful attempt before the process goes away.
+export function stopPgSync({ runtimeDir, pgdataDir }) {
+  try {
+    spawnSync(pgBin(runtimeDir, 'pg_ctl'), ['stop', '-m', 'fast', '-D', pgdataDir], {
+      env: libEnv(runtimeDir), stdio: 'ignore', timeout: 8_000, windowsHide: true,
+    })
+    __mixdogMemoryLog('[pg-process] stopPgSync: pg_ctl stop -m fast issued on exit\n')
+  } catch {}
+}
+
 // ---------------------------------------------------------------------------
 // healthcheckPg
 // ---------------------------------------------------------------------------

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

@@ -28,7 +28,12 @@ import {
 }                                             from 'node:fs';
 import { join, resolve }                      from 'node:path';
 import { tmpdir }                             from 'node:os';
-import { updateJsonAtomicSync }               from '../../../shared/atomic-file.mjs';
+import {
+  discoveryPath as _pgDiscoveryPath,
+  readServiceAdvert as _readPgServiceAdvert,
+  writeServiceAdvert as _writePgServiceAdvert,
+} from '../../../shared/service-discovery.mjs';
+import { withFileLockSync } from '../../../shared/atomic-file.mjs';
 
 // ── pg-process interface (Track A) ───────────────────────────────────────────
 // Dynamic import so this module loads even before Track A's file exists.
@@ -42,6 +47,7 @@ async function _getPgProc() {
     stopPg:           mod.stopPg,
     healthcheckPg:    mod.healthcheckPg,
     reconcileConfV2:  mod.reconcileConfV2,
+    stopPgSync:       mod.stopPgSync,
   };
   return _pgProc;
 }
@@ -181,23 +187,95 @@ const _RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
   ? resolve(process.env.MIXDOG_RUNTIME_ROOT)
   : join(tmpdir(), 'mixdog');
 const _ACTIVE_FILE = join(_RUNTIME_ROOT, 'active-instance.json');
+// Single-writer PG advert. Port discovery (pg_port et al.) moved OUT of the
+// shared, lock-guarded active-instance.json into discovery/pg.json, written by
+// this supervisor via a plain atomic rename (NO .lock) so it can never be
+// starved by active-instance lock contention.
+const _PG_DISCOVERY = 'pg';
+
+// Read the PG advert, preferring the single-writer discovery file
+// (discovery/pg.json) and falling back to the legacy active-instance.json pg_*
+// fields for cross-version compat. Field names are identical in both sources.
+function _readPgAdvert() {
+  const advert = _readPgServiceAdvert(_PG_DISCOVERY);
+  if (advert && Number(advert.pg_port) > 0) return advert;
+  try {
+    const ai = JSON.parse(readFileSync(_ACTIVE_FILE, 'utf8'));
+    if (ai && Number(ai.pg_port) > 0) return ai;
+  } catch {}
+  return advert ?? null;
+}
 
-// Lock contention codes thrown by withFileLockSync when the active-instance
-// lock cannot be acquired within timeoutMs (or try-once contention).
-const _LOCK_CONTENTION_CODES = new Set(['ELOCKTIMEOUT', 'ELOCKCONTENDED']);
+// Transient write-contention codes. ELOCK* survive from the old locked path;
+// EPERM/EBUSY/EACCES cover Windows atomic-rename hiccups on the plain-rename
+// discovery write so it backs off and retries rather than dropping the advert.
+const _LOCK_CONTENTION_CODES = new Set(['ELOCKTIMEOUT', 'ELOCKCONTENDED', 'EPERM', 'EBUSY', 'EACCES']);
+
+// Is the current on-disk advert owned by a DIFFERENT, still-live supervisor?
+// A clear (pg_port → null) must never unlink a NEWER supervisor's fresh advert:
+// re-read under the lock and, if pg_owner_pid names another live process, leave
+// it. Our own pid, a dead owner, or a missing/legacy owner → safe to unlink.
+function _pgAdvertIsForeignLive(adv) {
+  const owner = Number(adv?.pg_owner_pid);
+  if (!Number.isInteger(owner) || owner <= 0) return false;
+  if (owner === process.pid) return false;
+  return isPidAlive(owner);
+}
 
 function _applyActiveInstancePatch(fields, timeoutMs) {
-  updateJsonAtomicSync(_ACTIVE_FILE, (curRaw) => {
-    // Drop stale fields (pid/startedAt) written by older server versions.
-    const { pid: _legacyPid, startedAt: _legacyStartedAt, ...cur } = curRaw ?? {};
-    // Omit null-valued fields (clean removal when pg is stopped).
-    const merged = { ...cur, updatedAt: Date.now() };
+  // pg.json is NOT single-writer: start/attach/stop paths write it across
+  // separate supervisor processes, so the unlocked read-merge-write raced and
+  // lost cross-process updates. Guard it with pg.json's OWN private lock —
+  // supervisor-only contention, so it never recreates the shared
+  // active-instance.json bottleneck (memory.json stays lock-free).
+  const file = _pgDiscoveryPath(_PG_DISCOVERY);
+  withFileLockSync(`${file}.lock`, () => {
+    const cur = _readPgServiceAdvert(_PG_DISCOVERY) ?? {};
+    // Drop stale fields (pid/startedAt/updatedAt) written by older versions.
+    const { pid: _legacyPid, startedAt: _legacyStartedAt, updatedAt: _prevUpdatedAt, ...merged } = cur;
     for (const [k, v] of Object.entries(fields)) {
       if (v == null) delete merged[k];
       else merged[k] = v;
     }
-    return merged;
-  }, { compact: true, fsyncDir: true, renameFallback: 'truncate', timeoutMs });
+    const port = Number(merged.pg_port);
+    if (!Number.isInteger(port) || port <= 0) {
+      // No live port left → drop the advert (clean pg shutdown). But a late
+      // clear from an old shutdown/recovery path must NOT delete a fresh advert
+      // a newer supervisor just published — unlink only when it is ours or a
+      // dead corpse, never another live owner's.
+      if (_pgAdvertIsForeignLive(cur)) return;
+      try { unlinkSync(file); } catch {}
+      return;
+    }
+    // Stamp our supervisor pid so a later clear can prove advert ownership.
+    merged.pg_owner_pid = process.pid;
+    _writePgServiceAdvert(_PG_DISCOVERY, merged);
+  }, { timeoutMs });
+}
+
+// Re-stamp advert ownership on REUSE without clobbering a concurrently-updated
+// advert. Unlike patchActiveInstance (which blindly overwrites pg_port/pg_pgdata
+// /pg_runtime_dir from the reuse-time snapshot — already stale by the time the
+// lock is acquired, so a restart or a different live owner that landed meanwhile
+// gets clobbered), this RE-READS under the lock and only stamps our pid when the
+// advert STILL describes the same instance we reused (same pgdata + port) and no
+// DIFFERENT live owner has since taken it. It touches only pg_owner_pid — never
+// rewriting other fields from the stale snapshot.
+function _restampReuseOwner({ pgdata, port }) {
+  const file = _pgDiscoveryPath(_PG_DISCOVERY);
+  try {
+    withFileLockSync(`${file}.lock`, () => {
+      const cur = _readPgServiceAdvert(_PG_DISCOVERY);
+      if (!cur) return;                                   // advert gone — nothing to re-stamp
+      if (Number(cur.pg_port) !== Number(port)) return;   // restarted on a new port
+      if (!cur.pg_pgdata || resolve(cur.pg_pgdata) !== resolve(pgdata)) return; // different instance
+      if (_pgAdvertIsForeignLive(cur)) return;            // a different live owner holds it
+      if (Number(cur.pg_owner_pid) === process.pid) return; // already ours
+      const { pid: _legacyPid, startedAt: _legacyStartedAt, updatedAt: _prevUpdatedAt, ...merged } = cur;
+      merged.pg_owner_pid = process.pid;                  // minimal: owner pid only (updatedAt re-stamped on write)
+      _writePgServiceAdvert(_PG_DISCOVERY, merged);
+    }, { timeoutMs: 1000 });
+  } catch { /* best-effort: lock contention → skip re-stamp (guard reverts to prior owner) */ }
 }
 
 // Single module-level background-retry slot: a delayed retry must NEVER replay
@@ -347,7 +425,7 @@ async function tryReusePgInstance({ pgdata, runtimeDir, healthcheckPg, source =
   let existingPort = null;
   let existingRtDir = runtimeDir;
   try {
-    ai = JSON.parse(readFileSync(_ACTIVE_FILE, 'utf8'));
+    ai = _readPgAdvert();
     if (ai?.pg_port && ai?.pg_pgdata && resolve(ai.pg_pgdata) === resolve(pgdata)) {
       existingPort = ai.pg_port;
       existingRtDir = ai?.pg_runtime_dir ?? runtimeDir;
@@ -359,6 +437,14 @@ async function tryReusePgInstance({ pgdata, runtimeDir, healthcheckPg, source =
       if (await healthcheckPg({ port: existingPort })) {
         __mixdogMemoryLog(`[supervisor-pg] reusing PG on port ${existingPort} (${source}:active-instance)\n`);
         _live = { port: existingPort, pgdata, runtimeDir: existingRtDir, proc: null };
+        // Re-stamp advert ownership: this process is now a live owner of the
+        // reused postmaster. Without it the advert keeps the previous (possibly
+        // dead) owner pid, and a later sync exit hook's _pgAdvertIsForeignLive
+        // guard would judge it "not foreign-live" and wrongly sync-stop a
+        // postmaster this reuser still uses. Use the revalidating re-stamp (not
+        // patchActiveInstance) so a concurrent restart/owner change is not
+        // clobbered by this reuse-time snapshot.
+        _restampReuseOwner({ pgdata, port: existingPort });
         return { host: '127.0.0.1', port: existingPort, runtimeDir: existingRtDir, pgdataDir: pgdata };
       }
     } catch {}
@@ -452,7 +538,7 @@ async function _doEnsure(dataDir) {
     let existingPort = null;
     let ai = null;
     try {
-      ai = JSON.parse(readFileSync(_ACTIVE_FILE, 'utf8'));
+      ai = _readPgAdvert();
       // Only reuse a recorded instance when it was started for THIS pgdata.
       // active-instance.json is process-global; without matching pg_pgdata a
       // healthy PG serving a different data directory would be reused, binding
@@ -536,7 +622,7 @@ export async function stopPgForShutdown() {
     // _live may be null if PG was started by another process or adapter call.
     // Attempt graceful stop via active-instance.json.
     let ai = null;
-    try { ai = JSON.parse(readFileSync(_ACTIVE_FILE, 'utf8')); } catch {}
+    try { ai = _readPgAdvert(); } catch {}
     if (!ai?.pg_port || !ai?.pg_pgdata) return;
     const pgdataDir2  = ai.pg_pgdata;
     const runtimeDir2 = ai.pg_runtime_dir;
@@ -570,3 +656,28 @@ export async function stopPgForShutdown() {
   // tolerated — readers healthcheck-verify the port before reuse.
   patchActiveInstance({ pg_port: null, pg_started_at: null, pg_pgdata: null, pg_runtime_dir: null }, { timeoutMs: 2000, syncRetries: 1 });
 }
+
+/**
+ * Synchronous last-ditch PG stop for a process 'exit' hook. Covers the paths
+ * where the async stopPgForShutdown() above never runs/completes — a Windows
+ * force-kill, or stop() hitting its exit timeout — which otherwise kill the
+ * postmaster mid-write and force WAL crash recovery on next boot. No-op once
+ * the async path has cleared _live + active-instance (its record is gone), so
+ * a graceful shutdown is never double-stopped.
+ */
+export function stopPgForShutdownSync() {
+  // Mirror the async clear's ownership guard (_pgAdvertIsForeignLive) and apply
+  // it UNCONDITIONALLY — even when _live is set. Async shutdown or a
+  // cross-process reuse may have handed this postmaster to a different, still-
+  // live owner that re-stamped pg_owner_pid; that owner will stop it itself, so
+  // the exit hook must never sync-stop it out from under them.
+  let ai = null;
+  try { ai = _readPgAdvert(); } catch {}
+  if (_pgAdvertIsForeignLive(ai)) return;
+  let runtimeDir = _live?.runtimeDir, pgdataDir = _live?.pgdata;
+  if (!runtimeDir || !pgdataDir) {
+    runtimeDir = ai?.pg_runtime_dir; pgdataDir = ai?.pg_pgdata;
+  }
+  if (!runtimeDir || !pgdataDir || !_pgProc?.stopPgSync) return;
+  try { _pgProc.stopPgSync({ runtimeDir, pgdataDir }); } catch {}
+}

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

@@ -23,6 +23,7 @@ import {
 import { searchRelevantHybrid } from './memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './memory-recall-id-patch.mjs'
 import { retrieveEntries } from './memory-retrievers.mjs'
+import { buildPromotedExclusionClauses } from './memory-recall-scope-filter.mjs'
 import { cleanMemoryText } from './memory.mjs'
 import { insertTraceEvents } from './trace-store.mjs'
 import {
@@ -661,6 +662,107 @@ export function createQueryHandlers({
       return out
     }
 
+    // period='last': session-grouped browse. Pick the N most-recently-active
+    // sessions (limit = session count, default 5; offset = session-level
+    // paging) ranked by MAX(ts) DESC, then fill each with its newest rows
+    // under a per-session row cap. Session selection and per-session fetch
+    // reuse the same projectScope / excludeStatuses filters as the generic
+    // browse below; the grouped renderer adds activity-span headers. Output
+    // size is bounded by session count x per-session row cap plus the
+    // orchestrator-level tool-output KB cap — no recall-local line budget.
+    if (temporal?.mode === 'last') {
+      const sessionCount = Number.isFinite(requestedLimit) ? limit : 5
+      const PER_SESSION_ROW_CAP = 10
+      const excludeStatuses = includeArchived ? [] : ['archived']
+      const VALID_LAST_CATS = new Set(['rule', 'constraint', 'decision', 'fact', 'goal', 'preference', 'task', 'issue'])
+      const catList = category == null
+        ? []
+        : (Array.isArray(category) ? category : [category])
+            .map((c) => String(c).trim().toLowerCase())
+            .filter((c) => VALID_LAST_CATS.has(c))
+      // 1) rank sessions by most-recent activity (MAX(ts)) over the SAME pool
+      //    the fill draws from — roots (status-filtered) + unchunked raw
+      //    leaves, member rows excluded — so a session ranked here can never
+      //    fill empty (e.g. an archived-root session whose only surviving rows
+      //    are members). projectScope + excludeStatuses + category + promoted
+      //    exclusion all match the fill filters below.
+      const selWhere = [
+        'session_id IS NOT NULL',
+        "btrim(session_id) <> ''",
+        '(is_root = 1 OR chunk_root IS NULL OR chunk_root = id)',
+      ]
+      const selParams = []
+      if (projectScope === 'common') {
+        selWhere.push('project_id IS NULL')
+      } else if (typeof projectScope === 'string' && projectScope && projectScope !== 'all') {
+        selParams.push(projectScope)
+        selWhere.push(`(project_id IS NULL OR project_id = $${selParams.length})`)
+      }
+      if (excludeStatuses.length > 0) {
+        const ph = excludeStatuses.map((s) => { selParams.push(s); return `$${selParams.length}` }).join(',')
+        selWhere.push(`(status IS NULL OR status NOT IN (${ph}))`)
+      }
+      if (catList.length > 0) {
+        const ph = catList.map((c) => { selParams.push(c); return `$${selParams.length}` }).join(',')
+        selWhere.push(`category IN (${ph})`)
+      }
+      for (const c of buildPromotedExclusionClauses()) selWhere.push(c)
+      selParams.push(sessionCount, offset)
+      // Deterministic tie-breaker: equal MAX(ts) across sessions would let the
+      // LIMIT/OFFSET window skip or duplicate a session between offset pages
+      // without a stable secondary sort.
+      const sessSql = `SELECT session_id, MAX(ts) AS last_ts
+                       FROM entries
+                       WHERE ${selWhere.join(' AND ')}
+                       GROUP BY session_id
+                       ORDER BY last_ts DESC, session_id DESC
+                       LIMIT $${selParams.length - 1} OFFSET $${selParams.length}`
+      const sessRows = (await db.query(sessSql, selParams)).rows
+      // 2) per selected session, fetch its newest rows (roots+members, sort by
+      //    date) plus the fresh raw window, capped at PER_SESSION_ROW_CAP.
+      const allRows = []
+      for (const s of sessRows) {
+        const sid = String(s?.session_id || '').trim()
+        if (!sid) continue
+        const sf = { limit: PER_SESSION_ROW_CAP, session_id: sid, projectScope, sort: 'date' }
+        if (includeMembers) sf.includeMembers = true
+        if (excludeStatuses.length > 0) sf.excludeStatuses = excludeStatuses
+        if (catList.length > 0) sf.category = catList
+        const sRows = await retrieveEntries(db, sf)
+        let merged = sRows
+        if (includeRaw) {
+          const rawRows = await readRawRowsInWindow(db, null, Date.now(), PER_SESSION_ROW_CAP, { projectScope, sessionId: sid })
+          const seenIds = new Set(sRows.map((r) => Number(r.id)))
+          for (const r of sRows) if (Array.isArray(r.members)) for (const m of r.members) seenIds.add(Number(m.id))
+          // readRawRowsInWindow carries no category filter, so a category-
+          // scoped last must gate raw rows here to match the ranking/fill
+          // category predicate (unclassified raw rows have no category and
+          // are correctly dropped when a category is requested).
+          let newRaw = rawRows.filter((r) => !seenIds.has(Number(r.id)))
+          if (catList.length > 0) {
+            newRaw = newRaw.filter((r) => catList.includes(String(r.category || '').trim().toLowerCase()))
+          }
+          // readRawRowsInWindow carries no status filter either, so an
+          // includeArchived:false browse must drop archived raw rows here to
+          // match the ranking/root-fill excludeStatuses predicate.
+          if (excludeStatuses.length > 0) {
+            newRaw = newRaw.filter((r) => {
+              const st = String(r.status || '').trim().toLowerCase()
+              return !st || !excludeStatuses.includes(st)
+            })
+          }
+          if (newRaw.length > 0) {
+            merged = [...sRows, ...newRaw]
+            merged.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
+            merged = merged.slice(0, PER_SESSION_ROW_CAP)
+          }
+        }
+        for (const r of merged) allRows.push(r)
+      }
+      const _currentSessionHint = String(args?.currentSessionId || '').trim()
+      return { text: recallCapPrefix + renderSessionGroupedLines(allRows, { currentSessionId: _currentSessionHint, recencyOrder: true, spanHeaders: true }) }
+    }
+
     const filters = { limit: limit + offset }
     if (temporal?.startMs != null) { filters.ts_from = temporal.startMs; filters.ts_to = temporal.endMs }
     filters.projectScope = projectScope