mixdog 0.9.87 → 0.9.89

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

@@ -32,7 +32,6 @@ import {
   listCoreCandidates,
   promoteCoreCandidate,
   dismissCoreCandidate,
-  CORE_SUMMARY_MAX,
   normalizeCoreInput,
 } from './core-memory-store.mjs'
 import { resolveProjectId, resolveProjectScope } from './project-id-resolver.mjs'
@@ -54,15 +53,26 @@ export function createMemoryActionHandlers({
   startCycle1Run,
   finalizeCycle2Run,
   finalizeCycle3Run,
+  requestCycle3Review,
   getSchedulerCycle1InFlight,
   getCycle2CallLlm,
   getCycle3CallLlm,
   ingestTranscriptFile,
   cwdFromTranscriptPath,
+  addCoreImpl = addCore,
   editCoreImpl = editCore,
 }) {
   const DATA_DIR = dataDir
 
+  async function queueCoreReview(reason) {
+    if (typeof requestCycle3Review !== 'function') return
+    try {
+      await requestCycle3Review(reason)
+    } catch (err) {
+      log?.(`[core-memory] follow-up review queue failed: ${err?.message || err}\n`)
+    }
+  }
+
   // Whole-action backfill mutex. memory-cycle1's _cycle1InFlight only protects
   // cycle1; ingest workers (memory-ops-policy.mjs) and cycle2 can still overlap
   // if a second backfill kicks in (e.g. setup-server timeout + retry). Track the
@@ -634,6 +644,7 @@ export function createMemoryActionHandlers({
           }
           if (op === 'promote') {
             const entry = await promoteCoreCandidate(coreDataDir, args.id, { ...args, scope })
+            await queueCoreReview('core-promote')
             const mergeNote = entry.merged_with ? ` (merged into core id=${entry.merged_with}, sim=${entry.sim})` : ''
             return { text: `core promoted candidate id=${args.id} → core id=${entry.id}${mergeNote}: ${entry.element}` }
           }
@@ -646,14 +657,14 @@ export function createMemoryActionHandlers({
       }
       // Local trim helper — the manage-block trimOrNull at :1807 is scoped to
       // that branch and unreachable from here.
-      // Only the explicit string "common" selects the COMMON pool. Core add
-      // validates missing, null, and blank project_id below; edits use the
-      // target entry's stored pool.
+      // An explicit project_id wins. Otherwise infer from the active cwd/session
+      // and fall back to COMMON. Cycle3 can later reclassify a mis-scoped row.
       const hasProjectIdKey = Object.prototype.hasOwnProperty.call(args, 'project_id')
       const projectIdText = typeof args.project_id === 'string' ? args.project_id.trim() : ''
       const projectId = (() => {
+        if (!hasProjectIdKey || !projectIdText) return resolveProjectScope(args.cwd)
         if (projectIdText.toLowerCase() === 'common') return null
-        return projectIdText || null
+        return projectIdText
       })()
       try {
         if (op === 'add' || op === 'edit') {
@@ -669,17 +680,7 @@ export function createMemoryActionHandlers({
           })
           const errors = [...normalized.errors]
           if (op === 'add') {
-            if (!hasProjectIdKey || !projectIdText) {
-              const inferredProjectId = typeof args.cwd === 'string' && args.cwd
-                ? resolveProjectId(args.cwd)
-                : null
-              errors.unshift(
-                `project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool` +
-                (typeof inferredProjectId === 'string' && /^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)?$/.test(inferredProjectId)
-                  ? ` (cwd suggests "${inferredProjectId}")`
-                  : ''),
-              )
-            } else if (projectId === '*') {
+            if (projectId === '*') {
               errors.unshift('project_id "*" only valid for op="list"')
             }
           }
@@ -721,11 +722,13 @@ export function createMemoryActionHandlers({
           return { text: lines.join('\n') }
         }
         if (op === 'add') {
-          const entry = await addCore(coreDataDir, args, projectId)
+          const entry = await addCoreImpl(coreDataDir, args, projectId)
+          await queueCoreReview('core-add')
           return { text: `core added (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'edit') {
           const entry = await editCoreImpl(coreDataDir, args.id, args)
+          await queueCoreReview('core-edit')
           return { text: `core edited (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'delete') {
@@ -796,7 +799,7 @@ export function createMemoryActionHandlers({
         for (const a of actions) {
           if (a?.action === 'core') {
             const cid = Number(a.entry_id)
-            const core = String(a.core_summary ?? '').replace(/\s+/g, ' ').trim().slice(0, CORE_SUMMARY_MAX)
+            const core = String(a.core_summary ?? '').replace(/\s+/g, ' ').trim()
             if (Number.isFinite(cid) && core) coreSummaryById.set(cid, core)
           } else {
             primaryActions.push(a)

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

@@ -7,7 +7,7 @@
 //   memory-cycle2-gate.mjs       — prompt/parse/validate + runUnifiedGate + cascade
 import { flushEmbeddingDirty } from './memory-embed.mjs'
 import { refreshHotActive } from './memory.mjs'
-import { backfillCoreEmbeddings, nominateCoreCandidates, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
+import { backfillCoreEmbeddings, nominateCoreCandidates } from './core-memory-store.mjs'
 import { markCycleRequest, consumeCycleRequests, resolveCoalesceMaxDrains, scheduleCoalescedCycleRetry, makeCycleRequestSignature, resolveCoalesceMaxRetries } from './memory-cycle-requests.mjs'
 import { __mixdogMemoryLog, throwIfAborted } from './memory-cycle2-shared.mjs'
 import {
@@ -394,7 +394,7 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
       throwIfAborted(signal)
       if (a.action === 'core') {
         const id = Number(a.entry_id)
-        const core = String(a.core_summary ?? '').replace(/\s+/g, ' ').trim().slice(0, CORE_SUMMARY_MAX)
+        const core = String(a.core_summary ?? '').replace(/\s+/g, ' ').trim()
         if (Number.isFinite(id) && core) coreSummaryById.set(id, core)
       } else {
         primaryActions.push(a)
@@ -404,7 +404,7 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
     const setCoreSummary = async (entryId, explicitSummary) => {
       const id = Number(entryId)
       if (!Number.isFinite(id)) return false
-      let core = String(explicitSummary ?? '').replace(/\s+/g, ' ').trim().slice(0, CORE_SUMMARY_MAX)
+      const core = String(explicitSummary ?? '').replace(/\s+/g, ' ').trim()
       if (!core) return false
       await db.query(`UPDATE entries SET core_summary = $1 WHERE id = $2 AND is_root = 1`, [core, id])
       return true

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

@@ -25,7 +25,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, archiveCore, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
+import { listCore, editCore, deleteCore, archiveCore } from './core-memory-store.mjs'
 import { reclassifyCore } from './core-memory-store.mjs'
 import { loadCurrentRulesDigest } from './memory-cycle2.mjs'
 import { embedText } from './embedding-provider.mjs'
@@ -136,8 +136,6 @@ async function isSafeConservativeUpdate(current, action) {
   const newElement = normalizeComparable(action.element)
   const newSummary = normalizeComparable(action.summary)
   if (!newElement || !newSummary) return { ok: false, reason: 'empty rewrite' }
-  if (newSummary.length > CORE_SUMMARY_MAX) return { ok: false, reason: 'summary too long' }
-
   const oldText = coreText(current)
   const newText = `${action.element}\n${action.summary}`
   const oldLen = normalizeComparable(oldText).length

package/src/runtime/memory/lib/memory-recall-store.mjs

@@ -10,6 +10,28 @@ import { recallReadQuery } from './memory-recall-read-query.mjs'
 // uses entries directly; this guard remains for explicit useHotActive callers.
 import { SEMANTIC_ONLY_MIN_SIM, memberTsInWindow, SEMANTIC_TOP_RANK_MAX, SEMANTIC_TOP_RANK_MIN_SIM, SEMANTIC_TOP_RANK_STRICT_SIM, SHORT_QUERY_TOKEN_MAX, SIM_FLOOR, W_DENSE, W_WINDOW_RECENCY, W_RARE, RARE_DF_MAX, queryTokensLower, rowDisplayText, windowRecencyFactor, buildExactTerms, countQueryTokens, hasFullQueryTextMatch, hasQueryTokenCoverage, exactTextBoost, _checkMvHotActivePopulated } from './recall-scoring.mjs';
 
+// Bounded lexical scan window. The trgm/exact CTE legs run `ILIKE '%…%'`
+// which no index accelerates, so their worst case grows linearly with the
+// entries table — on a years-old memory DB every recall pays a full-table
+// substring scan twice. Bound both legs to the newest N rows by id (bigserial
+// ⇒ insertion order; MAX(id) resolves via the pk index, no sort). Dense
+// (HNSW) and sparse (GIN FTS) legs still cover the WHOLE table through real
+// indexes, so old memories remain reachable semantically/topically — only the
+// exact-substring rescue narrows to recent rows. Default 200k: measured on a
+// live DB, a 20k bound regressed recall quality (bench MRR 0.75 → 0.33 — the
+// rescued rows sat beyond the newest 20k inserts), so the default only guards
+// pathological table growth, not today's scale. MIXDOG_RECALL_LEXSCAN_ROWS
+// overrides; 0 restores the unbounded scan.
+const _envLexScan = Number(process.env.MIXDOG_RECALL_LEXSCAN_ROWS)
+const RECALL_LEXSCAN_ROWS = Number.isFinite(_envLexScan) && _envLexScan >= 0
+  ? Math.floor(_envLexScan)
+  : 200_000
+function lexScanBound(alias = '') {
+  if (RECALL_LEXSCAN_ROWS <= 0) return ''
+  const col = alias ? `${alias}.id` : 'id'
+  return `AND ${col} >= (SELECT GREATEST(COALESCE(MAX(id), 0) - ${RECALL_LEXSCAN_ROWS}, 0) FROM entries)`
+}
+
 export async function searchRelevantHybrid(db, query, options = {}) {
   const clean = String(query ?? '').trim()
   if (!clean) return []
@@ -280,6 +302,7 @@ trgm AS (
       OR coalesce(summary, '') ILIKE '%' || $3 || '%'
     )
     ${trgmFilterClause}
+    ${lexScanBound()}
   ORDER BY ts DESC
   LIMIT $4
 ),`
@@ -297,6 +320,7 @@ exact AS (
   )
   WHERE true
     ${exactFilterClause}
+    ${lexScanBound('ee')}
   GROUP BY ee.id, ee.ts
   HAVING COUNT(*) >= ${minExactHits}
   ORDER BY exact_hits DESC, ee.ts DESC

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

@@ -39,6 +39,7 @@ export function createQueryHandlers({
   log,
   resolveProjectScope,
   embeddingWarmupCanStart,
+  ensureKoMorph,
   getBootTimestamp,
   getTraceDb,
 }) {
@@ -123,9 +124,13 @@ export function createQueryHandlers({
     // is fresh (within FRESHNESS_MS of now) — an older newest-unchunked-turn
     // is completed history (cycle1 just hasn't gotten to it, or drain timed
     // out) and must stay visible, not be silently hidden every browse.
+    // Never applies to a compaction digest: that browse runs over a freshly
+    // and fully ingested transcript, so every row (including the previous
+    // turn's FINAL assistant message) carries an ingest-time ts and would be
+    // misread as in-flight, silently dropping the newest turn from the digest.
     const IN_FLIGHT_TURN_FRESHNESS_MS = 5 * 60 * 1000
     let excludeSourceTurnId = null
-    if (terms.length === 0) {
+    if (!compactDigest && terms.length === 0) {
       try {
         const r = await db.query(
           `SELECT source_turn t, MAX(ts) last_ts FROM entries
@@ -140,7 +145,7 @@ export function createQueryHandlers({
         }
       } catch {}
     }
-    if (Number.isFinite(excludeSourceTurnId)) {
+    if (!compactDigest && Number.isFinite(excludeSourceTurnId)) {
       params.push(excludeSourceTurnId)
       where.push(`NOT (chunk_root IS NULL AND source_turn = $${params.length})`)
     }
@@ -166,7 +171,7 @@ export function createQueryHandlers({
       const fillLimit = Math.max(0, fetchLimit - rows.length)
       const fillWhere = ['session_id = $1', 'id <> ALL($2::bigint[])', '(is_root = 1 OR chunk_root IS NULL OR chunk_root = id)']
       const fillParams = [sessionId, [...seen]]
-      if (Number.isFinite(excludeSourceTurnId)) {
+      if (!compactDigest && Number.isFinite(excludeSourceTurnId)) {
         fillParams.push(excludeSourceTurnId)
         fillWhere.push(`NOT (chunk_root IS NULL AND source_turn = $${fillParams.length})`)
       }
@@ -410,6 +415,14 @@ export function createQueryHandlers({
       return { text: header + parts.join('\n\n') }
     }
     const query = String(args.query ?? '').trim()
+    // Kiwi is a large optional analyzer. A Korean query starts it lazily, but
+    // this request keeps the lightweight lexical path instead of waiting for
+    // WASM/model construction. Later queries use it once ready.
+    if (query && /[\uAC00-\uD7AF]/u.test(query)) {
+      void Promise.resolve(ensureKoMorph?.()).catch((err) => {
+        log(`[memory-service] lazy kiwi init failed; recall stays lexical: ${err?.message || err}\n`)
+      })
+    }
     let period = String(args.period ?? '').trim() || undefined
     // Period and sort are caller-supplied only. Lead is responsible for
     // mapping vague time phrases / chronological intent into the period
@@ -500,31 +513,16 @@ export function createQueryHandlers({
       if (isEmbeddingModelReady()) {
         queryVector = await embedText(query, { priority: true })
       } else if (embeddingWarmupCanStart()) {
-        // Cold model: WAIT for warmup (bounded) instead of silently degrading
-        // to lexical-only. Raw rows are already embedded at ingest time, so
-        // the query vector is the only missing piece of the dense leg — a few
-        // seconds of warmup buys full hybrid quality on the first recall.
-        // On timeout the warmup keeps running in the background and this
-        // recall falls back to lexical (same as before).
-        const COLD_RECALL_WARMUP_WAIT_MS = Math.max(0, Number(process.env.MIXDOG_RECALL_WARMUP_WAIT_MS) || 8_000)
-        let timer
-        try {
-          queryVector = await Promise.race([
-            warmupEmbeddingProvider().then(() => embedText(query, { priority: true })),
-            new Promise((resolve) => { timer = setTimeout(() => resolve(null), COLD_RECALL_WARMUP_WAIT_MS) }),
-          ])
-        } catch (err) {
-          log(`[memory-service] embedding warmup during cold recall failed: ${err?.message || err}\n`)
-          queryVector = null
-        } finally {
-          clearTimeout(timer)
-        }
-        if (!Array.isArray(queryVector)) {
-          const now = Date.now()
-          if (now - _embeddingColdRecallLogAt > 10_000) {
-            _embeddingColdRecallLogAt = now
-            log(`[recall] embedding still cold after ${COLD_RECALL_WARMUP_WAIT_MS}ms wait; returning lexical results while background warmup continues\n`)
-          }
+        // Never turn a cold model into an 8-second foreground lock. Start the
+        // isolated worker and return lexical results now; the next recall gets
+        // the dense leg when the model is ready.
+        void warmupEmbeddingProvider().catch((err) => {
+          log(`[memory-service] embedding warmup after cold recall failed: ${err?.message || err}\n`)
+        })
+        const now = Date.now()
+        if (now - _embeddingColdRecallLogAt > 10_000) {
+          _embeddingColdRecallLogAt = now
+          log('[recall] embedding model warming in background; returning lexical results\n')
         }
       } else {
         const now = Date.now()

package/src/runtime/memory/tool-defs.mjs

@@ -27,12 +27,12 @@ export const TOOL_DEFS = [
           description: 'Required for action=core.',
         },
         id: { type: 'number', description: 'Exact memory id.' },
-        element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
-        summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, max 100 chars.' },
+        element: { type: 'string', description: 'Memory key/title. Defaults to the first 40 chars of summary.' },
+        summary: { type: 'string', description: 'Durable memory content; the memory worker compacts it after storage.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
-        project_id: { type: 'string', description: 'Core pool: explicit common or slug. Required for core add only (edit uses the id\'s stored pool); there is no default pool.' },
+        project_id: { type: 'string', description: 'Optional core pool override: common or slug. Omitted values are inferred from cwd/session, then fall back to common.' },
       },
       anyOf: [
         { properties: { action: { const: 'status' } }, required: ['action'] },

package/src/runtime/shared/atomic-file.mjs

@@ -30,7 +30,11 @@ const _execFileAsync = promisify(execFile);
 const RETRY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST']);
 const LOCK_WAIT_CODES = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
 const DEFAULT_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
-const DEFAULT_LOCK_TIMEOUT_MS = 8000;
+const _configuredLockTimeoutMs = Number(process.env.MIXDOG_LOCK_TIMEOUT_MS);
+const DEFAULT_LOCK_TIMEOUT_MS = Number.isFinite(_configuredLockTimeoutMs)
+  && _configuredLockTimeoutMs >= 0
+  ? _configuredLockTimeoutMs
+  : 2000;
 
 // Per-process owner identity. A bare pid is not a durable holder identity:
 // after a holder crashes the OS can recycle its pid onto an unrelated live

package/src/runtime/shared/child-guardian.mjs

@@ -8,6 +8,13 @@ function positiveInt(value) {
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
+const DEFAULT_MIN_FREE_MEMORY_MB = 1024;
+
+export function childGuardianMemoryFloorMb(env = process.env) {
+  const n = Math.floor(Number(env.MIXDOG_MIN_FREE_MEMORY_MB));
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_MIN_FREE_MEMORY_MB;
+}
+
 export function childGuardianSpawnEnv(env = process.env) {
   return {
     PATH: env.PATH || '',
@@ -22,9 +29,20 @@ export function childGuardianSpawnEnv(env = process.env) {
   };
 }
 
-function guardianScript({ parentPid, childPid, childGroupPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
+function guardianScript({
+  parentPid,
+  childPid,
+  childGroupPid,
+  platform,
+  pollMs,
+  orphanGraceMs,
+  forceGraceMs,
+  minFreeMemoryMb,
+  receiptPath,
+}) {
   return `
 const { spawnSync } = require('node:child_process');
+const { freemem } = require('node:os');
 const parentPid = ${JSON.stringify(parentPid)};
 const childPid = ${JSON.stringify(childPid)};
 const childGroupPid = ${JSON.stringify(childGroupPid || childPid)};
@@ -32,6 +50,23 @@ const platform = ${JSON.stringify(platform)};
 const pollMs = ${JSON.stringify(pollMs)};
 const orphanGraceMs = ${JSON.stringify(orphanGraceMs)};
 const forceGraceMs = ${JSON.stringify(forceGraceMs)};
+const minFreeMemoryBytes = ${JSON.stringify(minFreeMemoryMb * 1024 * 1024)};
+const receiptPath = ${JSON.stringify(receiptPath || null)};
+// Kill receipt: guardian kills are otherwise indistinguishable from a crashed
+// wrapper ("process exited without reporting an exit code"). Written BEFORE
+// the kill so the owner's next status refresh can attribute the death.
+function writeReceipt(reason, extra) {
+  if (!receiptPath) return;
+  try {
+    require('node:fs').writeFileSync(receiptPath, JSON.stringify({
+      reason,
+      at: new Date().toISOString(),
+      guardianPid: process.pid,
+      childPid,
+      ...extra,
+    }));
+  } catch {}
+}
 function alive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; }
@@ -57,6 +92,20 @@ let killing = false;
 let orphanedAt = 0;
 const timer = setInterval(() => {
   if (!alive(childPid)) process.exit(0);
+  // Admission protects only NEW work. A running shell can still consume the
+  // host after it starts, so reclaim its entire tree before it starves the
+  // owning Mixdog process. Force is intentional: at the memory floor there is
+  // no safe grace window for a runaway allocator.
+  if (!killing && minFreeMemoryBytes > 0) {
+    let freeBytes = Number.POSITIVE_INFINITY;
+    try { freeBytes = Number(freemem()); } catch {}
+    if (Number.isFinite(freeBytes) && freeBytes < minFreeMemoryBytes) {
+      killing = true;
+      writeReceipt('host-memory-floor', { freeBytes, minFreeMemoryBytes });
+      killTarget(true);
+      process.exit(0);
+    }
+  }
   // Orphaned when the parent PID dies. Matches mainstream CLIs: no console
   // probe — a hidden shell spawn (windowsHide) plus tree-kill on cleanup, so
   // orphan detection is pure parent-liveness.
@@ -67,6 +116,7 @@ const timer = setInterval(() => {
   if (!orphanedAt) orphanedAt = Date.now();
   if (killing || Date.now() - orphanedAt < orphanGraceMs) return;
   killing = true;
+  writeReceipt('parent-exit', {});
   killTarget(false);
   setTimeout(() => { if (alive(childPid)) killTarget(true); process.exit(0); }, forceGraceMs).unref?.();
 }, pollMs);
@@ -82,10 +132,14 @@ export function startChildGuardian({
   graceMs = 3000,
   orphanGraceMs = graceMs,
   forceGraceMs = graceMs,
+  protectHostMemory = false,
+  minFreeMemoryMb = protectHostMemory ? childGuardianMemoryFloorMb() : 0,
+  receiptPath = null,
 } = {}) {
   const parent = positiveInt(parentPid);
   const child = positiveInt(childPid);
   if (!parent || !child || parent === child) return null;
+  const memoryFloorMb = Math.max(0, Math.floor(Number(minFreeMemoryMb) || 0));
 
   try {
     const guardian = spawn(process.execPath, [
@@ -99,6 +153,8 @@ export function startChildGuardian({
         pollMs: Math.max(100, Math.floor(Number(pollMs) || 750)),
         orphanGraceMs: Math.max(100, Math.floor(Number(orphanGraceMs) || Number(graceMs) || 3000)),
         forceGraceMs: Math.max(100, Math.floor(Number(forceGraceMs) || Number(graceMs) || 3000)),
+        minFreeMemoryMb: memoryFloorMb,
+        receiptPath: typeof receiptPath === 'string' && receiptPath ? receiptPath : null,
       }),
     ], {
       stdio: 'ignore',
@@ -106,7 +162,22 @@ export function startChildGuardian({
       ...detachedSpawnOpts,
     });
     guardian.unref?.();
-    return { pid: guardian.pid || null, label, childPid: child };
+    let stopped = false;
+    return {
+      pid: guardian.pid || null,
+      label,
+      childPid: child,
+      stop() {
+        if (stopped) return false;
+        stopped = true;
+        try {
+          guardian.kill();
+          return true;
+        } catch {
+          return false;
+        }
+      },
+    };
   } catch {
     return null;
   }

package/src/runtime/shared/provider-api-key.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { getSecret } = require('../../lib/keychain-cjs.cjs');
+const { getSecret, hasSecret } = require('../../lib/keychain-cjs.cjs');
 
 // Lightweight API-key lookup shared by pristine startup and the general config
 // loader. This module deliberately has no mixdog-config.json dependency: asking
@@ -23,12 +23,32 @@ function providerSecretEnv(provider) {
   return `MIXDOG_AGENT_${String(provider || '').replace(/[.\s]+/g, '_').toUpperCase()}_APIKEY`;
 }
 
-export function getAgentApiKey(provider) {
+function environmentApiKey(provider) {
   const id = String(provider || '').trim();
   const standardEnv = AGENT_PROVIDER_ENV[id];
   if (standardEnv && process.env[standardEnv]) return process.env[standardEnv];
   const mixdogEnv = providerSecretEnv(id);
   if (process.env[mixdogEnv]) return process.env[mixdogEnv];
+  for (const alias of AGENT_PROVIDER_ENV_ALIASES[id] || []) {
+    if (process.env[alias]) return process.env[alias];
+  }
+  return null;
+}
+
+/** Presence-only credential probe. On Windows this is a cheap DPAPI-file
+ * check; decrypting through PowerShell is reserved for an actual API call. */
+export function hasAgentApiKey(provider) {
+  const id = String(provider || '').trim();
+  if (!id) return false;
+  if (environmentApiKey(id)) return true;
+  try { return hasSecret(`agent.${id}.apiKey`); }
+  catch { return false; }
+}
+
+export function getAgentApiKey(provider) {
+  const id = String(provider || '').trim();
+  const environment = environmentApiKey(id);
+  if (environment) return environment;
   try {
     const stored = getSecret(`agent.${id}.apiKey`);
     if (stored) return stored;
@@ -36,8 +56,5 @@ export function getAgentApiKey(provider) {
     // A missing/locked keychain is equivalent to no stored key. Explicit
     // environment aliases remain available as the final provider-local source.
   }
-  for (const alias of AGENT_PROVIDER_ENV_ALIASES[id] || []) {
-    if (process.env[alias]) return process.env[alias];
-  }
   return null;
 }

package/src/runtime/shared/tool-execution-contract.mjs

@@ -204,6 +204,59 @@ export function isLikelyToolCompletionWrapper(text) {
   return quotedCount / quotedLines.length >= 0.8;
 }
 
+const INTERNAL_TRANSCRIPT_CONTEXT_RE =
+  /^<(?:system-reminder|task-notification|skill|memory-context|mcp-instructions|available-deferred-tools|event)\b/i;
+const INTERNAL_TRANSCRIPT_SYNTHETIC_RE =
+  /^(?:\[mixdog-runtime\]|A previous model worked on this task and produced the compacted handoff summary below\b|Re-attached after compaction\b|Reference files:\s)/i;
+const INTERNAL_TRANSCRIPT_ASYNC_HEAD_RE =
+  /^The async (?:agent task|shell task|\w+ execution) \S+ has (?:finished|completed)\b/i;
+// Persisted USER cancellation control rows ("[Request interrupted by user]"
+// and its tool-use variant) exist for the next model step, not for humans:
+// the human already saw the cancel they typed. The live engine path already
+// withholds them; history/lane snapshots deliver them as plain user rows,
+// which flashed in unfocused panes until focus swapped the source (user
+// report). Full-row match only — never hide real prose around them.
+// "[Request interrupted by process restart]" is deliberately NOT matched: it
+// is a user-visible crash-recovery marker showing where a force-killed turn
+// stopped, and the restored transcript must keep that row
+// (scripts/turn-checkpoint-crash-test.mjs).
+const INTERNAL_TRANSCRIPT_INTERRUPT_RE =
+  /^\[request interrupted by user(?: for tool use)?\]$/i;
+
+// One display-only policy for every transcript surface. Runtime control rows
+// may be persisted as ordinary role:user messages so the next model step can
+// consume them; they are never human-authored chat and must not be rendered.
+// The flexible Result separator covers legacy rows and command bodies whose
+// embedded newlines lost their quote prefix during persistence.
+export function isInternalTranscriptDisplayText(text) {
+  const value = String(text ?? '').trim();
+  if (!value) return false;
+  if (INTERNAL_TRANSCRIPT_CONTEXT_RE.test(value)
+    || INTERNAL_TRANSCRIPT_SYNTHETIC_RE.test(value)
+    || INTERNAL_TRANSCRIPT_INTERRUPT_RE.test(value)
+    || isInternalRuntimeNotificationText(value)
+    || isModelVisibleToolCompletionWrapper(value)
+    || isLikelyToolCompletionWrapper(value)) {
+    return true;
+  }
+  if (INTERNAL_TRANSCRIPT_ASYNC_HEAD_RE.test(value) && !/\bResult:\s*(?:\r?\n|$)/i.test(value)) {
+    return true;
+  }
+  const resultSplit = /\r?\n(?:[ \t]*\r?\n)?Result:[ \t]*\r?\n/i.exec(value);
+  if (!resultSplit) return false;
+  const preamble = value.slice(0, resultSplit.index).trim();
+  const instructionLike = MODEL_VISIBLE_COMPLETION_INSTRUCTION_RE.test(preamble)
+    || MODEL_VISIBLE_COMPLETION_REVIEW_RE.test(preamble)
+    || MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
+  if (!instructionLike) return false;
+  const normalizedBody = value.slice(resultSplit.index + resultSplit[0].length)
+    .split(/\r?\n/)
+    .map((line) => line.replace(/^>\s?/, ''))
+    .join('\n')
+    .trim();
+  return isInternalRuntimeNotificationText(normalizedBody);
+}
+
 export function modelVisibleToolCompletionMessage(text, meta = {}) {
   const message = String(text || '').trim();
   if (!message) return '';

package/src/session-runtime/config-helpers.mjs

@@ -122,10 +122,11 @@ const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
 // Lead 11.75M vs 20.11M and agents 14.46M vs 45.04M input-token equivalents,
 // because cold misses rewrite the accumulated tail. Gemini, xAI and Mistral
 // caches run ~1h, Groq's implicit cache persists ~2h, OpenAI/DeepSeek
-// key-prefix/implicit caches persist far longer (~24h), and OpenAI OAuth's
-// in-memory server cache is short-lived (~5-10min), so we round up slightly
-// to 10m to avoid sweeping a still-warm cache. Unknown/unrecognized
-// providers fall back to the 'default' 1h entry.
+// key-prefix/implicit caches persist far longer (~24h), and OpenAI OAuth
+// (Codex backend) guarantees a 30-minute minimum prompt-cache TTL on
+// GPT-5.6+ models (prompt_cache_options.ttl=30m, refreshed on use), so the
+// sweep matches that window to avoid clearing a still-warm cache.
+// Unknown/unrecognized providers fall back to the 'default' 1h entry.
 export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
   'anthropic': 60 * 60 * 1000,
   'anthropic-oauth': 60 * 60 * 1000,
@@ -134,7 +135,7 @@ export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
   'openai': 24 * 60 * 60 * 1000,
   'deepseek': 24 * 60 * 60 * 1000,
   'xai': 60 * 60 * 1000,
-  'openai-oauth': 10 * 60 * 1000,
+  'openai-oauth': 30 * 60 * 1000,
   'mistral': 60 * 60 * 1000,
   'default': AUTO_CLEAR_DEFAULT_IDLE_MS,
 });

package/src/session-runtime/lifecycle-api.mjs

@@ -52,6 +52,7 @@ export function createLifecycleApi(deps) {
     beginRoutePreparation, clearRoutePreparation,
     pushTranscriptRebind,
     notificationListeners, remoteStateListeners, desktopSession,
+    disposeSessionTitles,
   } = deps;
   const closeSurfaceSession = (session, reason, options) => {
     if (!session?.id) return false;
@@ -111,6 +112,7 @@ export function createLifecycleApi(deps) {
       model: s.model,
       provider: s.provider,
       messageCount,
+      title: cleanSessionPreview(s.title || '', 100),
       preview,
       // Working indicator: the .hb sidecar ALONE is the liveness signal. Its
       // deletion at turn end IS the completion signal, so the persisted
@@ -166,6 +168,7 @@ export function createLifecycleApi(deps) {
       // of reaping every session's jobs. CLI exit paths never set this.
       const keepBackgroundWork = options?.keepBackgroundWork === true;
       setCloseRequested(true);
+      try { disposeSessionTitles?.(); } catch {}
       // Self-update now stages in the background and swaps on the next clean
       // launch (see staged-update.mjs) — nothing installs at shutdown. On a
       // real process exit we just drop this session's live-refcount pid file so
@@ -415,12 +418,21 @@ export function createLifecycleApi(deps) {
       if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId)) return null;
       const current = getSession();
       if (current?.id === sessionId) return current;
-      const session = mgr.loadSession?.(sessionId);
+      // Visible desktop panes reconcile dead-owner checkpoints during their
+      // startup peek instead of waiting for a later click/resume. Older test
+      // or embedded managers retain the plain read-only fallback.
+      const session = typeof mgr.recoverSessionAfterProcessRestart === 'function'
+        ? mgr.recoverSessionAfterProcessRestart(sessionId)
+        : mgr.loadSession?.(sessionId);
       // `closed` means the previous live owner released this durable session;
       // it is still a valid historical transcript. Desktop pane peeks are
-      // strictly read-only, so they may inspect it without resuming or
-      // changing ownership. Deleted/tombstoned sessions have no load result.
-      return session || null;
+      // ownership-neutral, so they may inspect it without resuming. Crash
+      // checkpoint reconciliation is the sole durable mutation here.
+      if (!session) return null;
+      return mgr.prepareSessionProjection?.(
+        session,
+        toolSpecForMode(getMode()),
+      ) || session;
     },
     async resume(id) {
       clearRoutePreparation?.();