mixdog 0.9.147 → 0.9.149

package/src/runtime/memory/lib/memory-embedding-migration.test.mjs

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { resetEmbeddingColumnsForModel } from './memory.mjs'
+
+function mockDb({ entriesDims = 640, coreDims = 640, identityMatches = true } = {}) {
+  const execs = []
+  const queries = []
+  return {
+    execs,
+    queries,
+    async exec(sql) {
+      execs.push(sql)
+    },
+    async query(sql, params = []) {
+      queries.push({ sql, params })
+      if (sql.includes('FROM pg_attribute')) {
+        return { rows: [{ atttypmod: params[0] === 'entries' ? entriesDims : coreDims }] }
+      }
+      if (sql.includes('SELECT value = $2::jsonb')) {
+        return { rows: identityMatches ? [{ matches: true }] : [] }
+      }
+      return { rows: [] }
+    },
+  }
+}
+
+const identity = { model: 'onnx-community/harrier-oss-v1-270m-ONNX', dtype: 'q4' }
+
+test('matching embedding dimensions and identity keep stored vectors', async () => {
+  const db = mockDb()
+  assert.equal(await resetEmbeddingColumnsForModel(db, 640, identity), false)
+  assert.deepEqual(db.execs, [])
+})
+
+test('a model identity change invalidates vectors even at the same dimensions', async () => {
+  const db = mockDb({ identityMatches: false })
+  assert.equal(await resetEmbeddingColumnsForModel(db, 640, identity), true)
+  assert.ok(db.execs.some((sql) => sql.includes('UPDATE entries SET embedding = NULL')))
+  assert.ok(db.execs.some((sql) => sql.includes('UPDATE core_entries SET embedding = NULL')))
+  assert.ok(db.execs.some((sql) => sql.includes('DROP TABLE IF EXISTS memory.embedding_cache')))
+  assert.ok(db.queries.some(({ params }) => params[0] === 'embedding.current_model'))
+})
+
+test('a dimension change rebuilds both halfvec columns', async () => {
+  const db = mockDb({ entriesDims: 384, coreDims: 384 })
+  assert.equal(await resetEmbeddingColumnsForModel(db, 640, identity), true)
+  assert.ok(db.execs.some((sql) => sql.includes('ALTER TABLE entries ALTER COLUMN embedding TYPE halfvec(640)')))
+  assert.ok(db.execs.some((sql) => sql.includes('ALTER TABLE core_entries ALTER COLUMN embedding TYPE halfvec(640)')))
+})

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

@@ -46,7 +46,6 @@ export async function searchRelevantHybrid(db, query, options = {}) {
   // page still needs a broad pool so the final decision can outrank them.
   const candidateWindow = Math.max(240, limit * 8)
   const includeMembers = Boolean(options.includeMembers)
-  const writeBackMemberHits = options.writeBackMemberHits !== false
   const rootOnly = options.rootOnly === true
   // Pre-filter knobs. Without them, FTS/vec rank the whole tree and a
   // post-filter time window can wipe the result set.
@@ -423,8 +422,11 @@ LEFT JOIN exact  x ON x.id = c.id`
       if (r.exact_rank != null) exactCount++
     }
   } catch (err) {
+    // A failing hybrid CTE is a DB/schema fault. Returning [] rendered it to the
+    // caller as "no memory found", so a broken index or a migration gap looked
+    // like an empty store instead of an error.
     __mixdogMemoryLog(`[recall] hybrid CTE failed: ${err.message}\n`)
-    return []
+    throw err
   }
 
   if (rawRows.length === 0) return []
@@ -739,27 +741,10 @@ LEFT JOIN exact  x ON x.id = c.id`
     if (rootIdsForReturn.length >= limit) break
   }
 
-  let writeBackCount = 0
-  if (writeBackMemberHits && memberHitRootIds.size > 0) {
-    // Batch UPDATE — single round-trip instead of N (one per member-hit root).
-    const validRootIds = []
-    for (const rootId of memberHitRootIds) {
-      const r = rootIdsForReturn.find(x => x.root.id === rootId)?.root ?? byId.get(rootId)
-      if (r) validRootIds.push(Number(rootId))
-    }
-    if (validRootIds.length > 0) {
-      try {
-        const { rowCount } = await db.query(
-          `UPDATE entries SET last_seen_at = $1::bigint WHERE id = ANY($2::bigint[]) AND is_root = 1
-           AND (last_seen_at IS NULL OR last_seen_at < $1::bigint - 3600000)`,
-          [String(nowMs), validRootIds],
-        )
-        writeBackCount = rowCount ?? validRootIds.length
-      } catch (err) {
-        __mixdogMemoryLog(`[recall] writeback batch failed (count=${validRootIds.length}): ${err.message}\n`)
-      }
-    }
-  }
+  // Recall is a read. The member-hit write-back that used to run here bumped
+  // last_seen_at, which feeds the stored score/freshness ranking — so merely
+  // searching reordered later results. Removed outright: every caller already
+  // passed writeBackMemberHits: false.
 
   // ── Final fetch: full row for each root by id = ANY(bigint[]) ────────────
   const topIds = rootIdsForReturn.map(x => Number(x.root.id))
@@ -929,7 +914,7 @@ LEFT JOIN exact  x ON x.id = c.id`
   }
 
   __mixdogMemoryLog(
-    `[recall] dense=${denseCount} sparse=${sparseCount} trgm=${trgmCount} exact=${exactCount} semantic_only_dropped=${semanticOnlyDropped} weak_text_dropped=${weakTextDropped} merged=${results.length} write_back=${writeBackCount}\n`,
+    `[recall] dense=${denseCount} sparse=${sparseCount} trgm=${trgmCount} exact=${exactCount} semantic_only_dropped=${semanticOnlyDropped} weak_text_dropped=${weakTextDropped} merged=${results.length}\n`,
   )
 
   return results

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

@@ -18,7 +18,7 @@ export const VALID_CATEGORY = new Set([
   'rule', 'constraint', 'decision', 'fact', 'goal', 'preference', 'task', 'issue',
 ])
 
-export async function init(db, dims) {
+export async function init(db, dims, embeddingIdentity = null) {
   const dimCount = Number(dims)
   if (!Number.isInteger(dimCount) || dimCount <= 0) {
     throw new Error(`init: dims must be a positive integer, got ${dims}`)
@@ -266,6 +266,13 @@ export async function init(db, dims) {
      ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
     ['embedding.current_dims', JSON.stringify(dimCount)],
   )
+  if (embeddingIdentity != null) {
+    await db.query(
+      `INSERT INTO meta(key, value) VALUES ($1, $2::jsonb)
+       ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
+      ['embedding.current_model', JSON.stringify(embeddingIdentity)],
+    )
+  }
   await db.query(
     `INSERT INTO meta(key, value) VALUES ($1, $2::jsonb)
      ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
@@ -343,15 +350,24 @@ export async function refreshHotActive(db) {
   }
 }
 
-async function resetEmbeddingColumnsForDims(db, dimCount) {
+export async function resetEmbeddingColumnsForModel(db, dimCount, embeddingIdentity = null) {
   const entriesDims = await getEmbeddingColumnDims(db, 'entries')
   const coreDims = await getEmbeddingColumnDims(db, 'core_entries')
-  const needsEntriesReset = entriesDims != null && entriesDims !== dimCount
-  const needsCoreReset = coreDims != null && coreDims !== dimCount
+  const normalizedIdentity = embeddingIdentity == null ? null : JSON.stringify(embeddingIdentity)
+  let identityChanged = false
+  if (normalizedIdentity != null) {
+    const identity = await db.query(
+      `SELECT value = $2::jsonb AS matches FROM meta WHERE key = $1`,
+      ['embedding.current_model', normalizedIdentity],
+    )
+    identityChanged = identity.rows.length === 0 || identity.rows[0].matches !== true
+  }
+  const needsEntriesReset = entriesDims != null && (entriesDims !== dimCount || identityChanged)
+  const needsCoreReset = coreDims != null && (coreDims !== dimCount || identityChanged)
   if (!needsEntriesReset && !needsCoreReset) return false
 
   __mixdogMemoryLog(
-    `[memory] embedding dimension changed; resetting vectors for halfvec(${dimCount}) ` +
+    `[memory] embedding model changed; resetting vectors for halfvec(${dimCount}) ` +
     `(entries=${entriesDims ?? 'missing'}, core_entries=${coreDims ?? 'missing'})\n`,
   )
 
@@ -360,11 +376,19 @@ async function resetEmbeddingColumnsForDims(db, dimCount) {
   await db.exec(`DROP INDEX IF EXISTS core_entries_embedding_hnsw`)
 
   if (needsEntriesReset) {
-    await db.exec(`ALTER TABLE entries ALTER COLUMN embedding TYPE halfvec(${dimCount}) USING NULL::halfvec(${dimCount})`)
+    if (entriesDims !== dimCount) {
+      await db.exec(`ALTER TABLE entries ALTER COLUMN embedding TYPE halfvec(${dimCount}) USING NULL::halfvec(${dimCount})`)
+    } else {
+      await db.exec(`UPDATE entries SET embedding = NULL WHERE embedding IS NOT NULL`)
+    }
     await db.exec(`UPDATE entries SET summary_hash = NULL WHERE summary_hash IS NOT NULL`)
   }
   if (needsCoreReset) {
-    await db.exec(`ALTER TABLE core_entries ALTER COLUMN embedding TYPE halfvec(${dimCount}) USING NULL::halfvec(${dimCount})`)
+    if (coreDims !== dimCount) {
+      await db.exec(`ALTER TABLE core_entries ALTER COLUMN embedding TYPE halfvec(${dimCount}) USING NULL::halfvec(${dimCount})`)
+    } else {
+      await db.exec(`UPDATE core_entries SET embedding = NULL WHERE embedding IS NOT NULL`)
+    }
   }
 
   await db.exec(`DROP TABLE IF EXISTS memory.embedding_cache`)
@@ -373,6 +397,13 @@ async function resetEmbeddingColumnsForDims(db, dimCount) {
      ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
     ['embedding.current_dims', JSON.stringify(dimCount)],
   )
+  if (normalizedIdentity != null) {
+    await db.query(
+      `INSERT INTO meta(key, value) VALUES ($1, $2::jsonb)
+       ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
+      ['embedding.current_model', normalizedIdentity],
+    )
+  }
   return true
 }
 
@@ -430,7 +461,7 @@ async function _migrateRecallIndexesIfStale(db) {
   }
 }
 
-export async function ensureCurrentSchemaExtensions(db, dims) {
+export async function ensureCurrentSchemaExtensions(db, dims, embeddingIdentity = null) {
   // One-time cleanup: attachment-only placeholder rows ('(attachment)' user
   // content, e.g. Discord provider discord.mjs:724) predate the
   // shouldExcludeIngestMessage() ingest-time filter (session-ingest.mjs).
@@ -607,11 +638,18 @@ export async function ensureCurrentSchemaExtensions(db, dims) {
       ['embedding.current_dims', JSON.stringify(dims)],
     )
   }
+  if (embeddingIdentity != null) {
+    await db.query(
+      `INSERT INTO meta(key, value) VALUES ($1, $2::jsonb)
+       ON CONFLICT(key) DO UPDATE SET value = EXCLUDED.value`,
+      ['embedding.current_model', JSON.stringify(embeddingIdentity)],
+    )
+  }
 
   await ensureHotActiveSearchObjects(db)
 }
 
-export async function openDatabase(dataDir, dims) {
+export async function openDatabase(dataDir, dims, embeddingIdentity = null) {
   const key = resolve(dataDir)
 
   // Fast path — already resolved.
@@ -632,14 +670,14 @@ export async function openDatabase(dataDir, dims) {
       // race skips the redundant DDL instead of re-running init().
       await withSchemaBootstrapLock(pool, async () => {
         if (!(await isBootstrapComplete(db))) {
-          await init(db, dims)
+          await init(db, dims, embeddingIdentity)
         }
       })
     }
     if (await isBootstrapComplete(db)) {
-      await resetEmbeddingColumnsForDims(db, Number(dims))
+      await resetEmbeddingColumnsForModel(db, Number(dims), embeddingIdentity)
     }
-    await ensureCurrentSchemaExtensions(db, Number(dims))
+    await ensureCurrentSchemaExtensions(db, Number(dims), embeddingIdentity)
     await validateEmbeddingDims(db, Number(dims))
 
     dbs.set(key, db)

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

@@ -14,6 +14,7 @@ import { join } from 'path'
 import { spawn, spawnSync } from 'child_process'
 import { createConnection } from 'net'
 import { createServer } from 'net'
+import { isPidAlive } from '../../../shared/pid-liveness.mjs'
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -53,16 +54,6 @@ function isTcpPortFree(port) {
 const PG_PORT_MIN = 55432
 const PG_PORT_MAX = 55632
 
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (err) {
-    return err?.code === 'EPERM'
-  }
-}
-
 function readPostmasterInfo(pgdataDir) {
   try {
     const lines = readFileSync(join(pgdataDir, 'postmaster.pid'), 'utf8').split('\n')

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

@@ -29,6 +29,7 @@ import {
   writeServiceAdvert as _writePgServiceAdvert,
 } from '../../../shared/service-discovery.mjs';
 import { withFileLockSync } from '../../../shared/atomic-file.mjs';
+import { isPidAlive } from '../../../shared/pid-liveness.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../../../shared/runtime-root.mjs';
 
 // ── pg-process interface (Track A) ───────────────────────────────────────────
@@ -350,15 +351,6 @@ function readPostmasterInfo(pgdata) {
   } catch { return { pid: null, port: null }; }
 }
 
-function isPidAlive(pid) {
-  try { process.kill(pid, 0); return true; }
-  catch (e) {
-    // EPERM: process exists but we lack permission → alive.
-    // ESRCH: no such process → dead.
-    return e.code === 'EPERM';
-  }
-}
-
 /**
  * Best-effort process-name check: confirms the pid's comm name contains 'postgres'.
  * Falls back to true (alive) when the name cannot be determined.

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

@@ -432,7 +432,7 @@ export function createQueryHandlers({
           // Race against the same deadline as the fan-out itself: a stuck
           // embedding worker would previously park here indefinitely because
           // the timer hadn't been started yet from the fan-out's perspective.
-          await Promise.race([embedTexts(queries), deadlineRace])
+          await Promise.race([embedTexts(queries, { inputType: 'query' }), deadlineRace])
         } else if (embeddingWarmupCanStart()) {
           void warmupEmbeddingProvider().catch((err) => {
             log(`[memory-service] embedding warmup after cold fan-out skipped dense search: ${err?.message || err}\n`)
@@ -569,7 +569,7 @@ export function createQueryHandlers({
       if (signal?.aborted) throw signal.reason ?? new Error('aborted')
       let queryVector = null
       if (isEmbeddingModelReady()) {
-        queryVector = await embedText(retrievalQuery, { priority: true })
+        queryVector = await embedText(retrievalQuery, { priority: true, inputType: 'query' })
       } else if (embeddingWarmupCanStart()) {
         // Never turn a cold model into an 8-second foreground lock. Start the
         // isolated worker and return lexical results now; the next recall gets
@@ -612,7 +612,6 @@ export function createQueryHandlers({
         projectScope,
         category,
         excludeStatuses,
-        writeBackMemberHits: false,
         latestByConcept: latestIntent && args.period == null,
         // useHotActive was set to true here so default (no-period) calls
         // routed through the mv_hot_active materialized view — a narrow
@@ -648,7 +647,6 @@ export function createQueryHandlers({
               ...searchOptions,
               includeMembers: false,
               rootOnly: true,
-              writeBackMemberHits: false,
             })
           : Promise.resolve([]),
       ])

package/src/runtime/memory/lib/session-ingest-runtime.mjs

@@ -334,12 +334,12 @@ export function createSessionIngestRuntime({
       currentSnapshot.push({ key: snapshotKey, occurrence })
       if (i >= start) {
         considered += 1
-        prepared.push({ m, role, content, occurrence, index: i })
+        prepared.push({ m, role, content, occurrence, index: i, untimestamped })
       }
     }
     ordinalState.snapshot = currentSnapshot
     ordinalState.seeded = true
-    for (const { m, role, content, occurrence, index } of prepared) {
+    for (const { m, role, content, occurrence, index, untimestamped } of prepared) {
       const fallbackTs = Date.now() - (messages.length - index)
       const rawTimestamp = m.ts ?? m.timestamp
       const timeSource = untimestamped ? 'collected' : 'recorded'

package/src/runtime/shared/background-tasks.mjs

@@ -286,6 +286,18 @@ export function cancelBackgroundTasks(options = {}) {
   return { cancelled };
 }
 
+export function acknowledgeBackgroundTaskCompletion(taskId, options = {}) {
+  const task = getBackgroundTask(taskId, options);
+  if (!task || !TERMINAL_STATUSES.has(task.status)) return null;
+  // A terminal task read is an explicit consumer ACK. It wins over a racing
+  // async notify settlement and prevents any later reconcile from re-firing
+  // the same completion.
+  task.completionAcknowledged = true;
+  task.notified = true;
+  task.notifiedWithBody = true;
+  return task;
+}
+
 function resultTextForTask(task) {
   if (task.resultText) return task.resultText;
   if (task.result !== undefined) {
@@ -327,6 +339,7 @@ export function completeBackgroundTask(taskId, {
   if (resultText != null) task.resultText = compactText(resultText);
   if (error != null) task.error = presentErrorText(error, { surface: task.surface });
   if (resultType) task.resultType = resultType;
+  if (instruction) task.notificationInstruction = compactText(instruction, 1_000);
   if (notify) {
     task.meta = sanitizeTaskMeta(task.meta);
     notifyTaskCompletion(task, instruction);
@@ -337,6 +350,7 @@ export function completeBackgroundTask(taskId, {
 export function notifyTaskCompletion(task, instruction) {
   if (!task) return false;
   if (!TERMINAL_STATUSES.has(task.status)) return false;
+  if (task.completionAcknowledged === true) return false;
   // `notified` tracks whether *any* completion notification was sent (e.g. an
   // early header-only preview from the agent surface). A later call that can
   // finally include the result body must still fire once, otherwise the owner
@@ -364,6 +378,7 @@ export function notifyTaskCompletion(task, instruction) {
     // marks, preserving exact-once.
     onSettled: (delivered) => {
       if (delivered) return;
+      if (task.completionAcknowledged === true) return;
       task.notified = false;
       task.notifiedWithBody = false;
     },

package/src/runtime/shared/background-tasks.test.mjs

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  cleanupBackgroundTasks,
+  completeBackgroundTask,
+  getBackgroundTask,
+  registerBackgroundTask,
+  renderBackgroundTask,
+} from './background-tasks.mjs';
+import { modelVisibleToolCompletionMessage } from './tool-execution-contract.mjs';
+import { executeTaskTool } from '../agent/orchestrator/tools/builtin/task-tool.mjs';
+import {
+  _dropPendingMessageState,
+  _settlePendingMessageWrites,
+  drainPendingMessages,
+  enqueuePendingMessage,
+  markCompletionEntry,
+} from '../agent/orchestrator/session/manager/pending-messages.mjs';
+import { _clearDeliveredCompletions } from '../agent/orchestrator/session/manager/delivered-completions.mjs';
+
+test('terminal task read ACKs queued and racing completion notifications', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-task-read-ack-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  const sessionId = `sess_task_read_ack_${process.pid}`;
+  const taskId = `task_read_ack_${process.pid}`;
+  process.env.MIXDOG_DATA_DIR = root;
+  try {
+    const task = registerBackgroundTask({
+      taskId,
+      surface: 'shell',
+      operation: 'shell',
+      context: { callerSessionId: sessionId },
+    });
+    const instruction = `Async shell task ${taskId} (completed, exit 0) finished.`;
+    completeBackgroundTask(taskId, {
+      status: 'completed',
+      resultText: 'command output',
+      resultType: 'shell_task_result',
+      instruction,
+      notify: false,
+    });
+    const completionText = renderBackgroundTask(task, { includeResult: true });
+    const visible = modelVisibleToolCompletionMessage(completionText, {
+      type: 'shell_task_result',
+      execution_surface: 'shell',
+      execution_id: taskId,
+      status: 'completed',
+      instruction,
+    });
+    const entry = markCompletionEntry(visible, { executionId: taskId });
+    assert.ok(enqueuePendingMessage(sessionId, entry) > 0);
+    await _settlePendingMessageWrites();
+
+    assert.match(
+      await executeTaskTool({ action: 'read', task_id: taskId }, { sessionId }),
+      /status: completed/,
+    );
+    assert.equal(getBackgroundTask(taskId).completionAcknowledged, true);
+
+    // Covers both orderings: already queued before the read, and a fallback
+    // enqueue that races in after the read ACK.
+    assert.ok(enqueuePendingMessage(sessionId, entry) > 0);
+    assert.deepEqual(drainPendingMessages(sessionId), []);
+    await _settlePendingMessageWrites();
+  } finally {
+    _dropPendingMessageState(sessionId);
+    await _settlePendingMessageWrites().catch(() => {});
+    cleanupBackgroundTasks({ force: true });
+    _clearDeliveredCompletions();
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -2,6 +2,7 @@
 
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { isPidAlive } from './pid-liveness.mjs';
 import { detachedSpawnOpts } from './spawn-flags.mjs';
 
 function positiveInt(value) {
@@ -169,15 +170,6 @@ function sendBrokerMessage(message) {
   }
 }
 
-function targetPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
 function stopBrokerTargetSweepIfIdle() {
   if (brokerTargets.size > 0 || !brokerTargetSweepTimer) return;
   clearInterval(brokerTargetSweepTimer);
@@ -198,7 +190,7 @@ function ensureBrokerTargetSweep() {
   if (brokerTargetSweepTimer) return;
   brokerTargetSweepTimer = setInterval(() => {
     for (const [id, target] of brokerTargets) {
-      if (!targetPidAlive(target.childPid)) removeBrokerTarget(id);
+      if (!isPidAlive(target.childPid)) removeBrokerTarget(id);
     }
     stopBrokerTargetSweepIfIdle();
   }, 250);

package/src/runtime/shared/pid-liveness.mjs

@@ -0,0 +1,27 @@
+// Canonical process-liveness probe.
+//
+// Discovery files, singleton claims, transports, spawn guardians and the pg
+// supervisor each used to carry their own byte-identical copy of this pair.
+// The rule they all agreed on: a pid is only usable when it is a positive
+// integer, and `process.kill(pid, 0)` failing with EPERM means the process
+// EXISTS but belongs to another user (alive); ESRCH — and any other failure —
+// means it is not addressable.
+//
+// Callers that must fail SAFE on an unknown error (treat anything but ESRCH as
+// alive) keep their own probe on purpose; this is the fail-closed variant.
+
+export function parsePid(value) {
+  const pid = Number(value);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+
+export function isPidAlive(value) {
+  const pid = parsePid(value);
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}

package/src/runtime/shared/pristine-execution-contract.json

@@ -27,7 +27,6 @@
     "MIXDOG_CACHE_MESSAGES_TTL",
     "MIXDOG_OAI_TRANSPORT",
     "MIXDOG_OPENAI_OAUTH_WS_WARMUP",
-    "MIXDOG_OAI_CODEX_WIRE_PARITY",
     "MIXDOG_OAI_WS_DUMP_DIR",
     "MIXDOG_SESSION_TRANSCRIPT_LOG",
     "MIXDOG_USAGE_LOG"

package/src/runtime/shared/runtime-root.mjs

@@ -6,6 +6,7 @@ import {
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { isPidAlive } from './pid-liveness.mjs';
 
 let cachedDefaultRoot = '';
 
@@ -15,17 +16,6 @@ function currentUid() {
   return Number.isInteger(uid) && uid >= 0 ? uid : null;
 }
 
-function isPidAlive(value) {
-  const pid = Number(value);
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
 function safeLiveLegacyRoot(root, uid) {
   try {
     const directory = lstatSync(root);

package/src/runtime/shared/service-discovery.mjs

@@ -13,6 +13,7 @@
 import { readFileSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 import { writeJsonAtomicSync } from './atomic-file.mjs'
+import { isPidAlive } from './pid-liveness.mjs'
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from './runtime-root.mjs'
 
 function discoveryRoot() {
@@ -23,23 +24,6 @@ export function discoveryPath(service) {
   return join(discoveryRoot(), `${service}.json`)
 }
 
-function parsePid(value) {
-  const pid = Number(value)
-  return Number.isInteger(pid) && pid > 0 ? pid : null
-}
-
-export function isPidAlive(value) {
-  const pid = parsePid(value)
-  if (!pid) return false
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (e) {
-    // EPERM: process exists but we lack permission → alive. ESRCH → dead.
-    return e?.code === 'EPERM'
-  }
-}
-
 // Per-process "unreachable port" distrust set: service → { port, updatedAt,
 // pid, ts } a consumer WITHOUT its own health probe proved dead this process
 // (connect-failure). pid-liveness alone cannot catch a recycled owner pid: the

package/src/runtime/shared/singleton-owner.mjs

@@ -1,16 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-
-export function isPidAlive(pid) {
-  const n = Number(pid);
-  if (!Number.isInteger(n) || n <= 0) return false;
-  try {
-    process.kill(n, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
+import { isPidAlive } from './pid-liveness.mjs';
 
 function readJson(path) {
   try {

package/src/runtime/shared/staged-update.mjs

@@ -36,6 +36,8 @@ import { dirname, basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { resolvePluginData } from './plugin-paths.mjs';
+// Same probe every discovery/lock reader uses; `process.pid` is trivially alive.
+import { isPidAlive as pidAlive } from './pid-liveness.mjs';
 import { detachedSpawnOpts, hiddenSpawnOpts } from './spawn-flags.mjs';
 import { renameWithRetrySync } from './atomic-file.mjs';
 import {
@@ -67,18 +69,6 @@ function rmDir(dir) {
   try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
 }
 
-function pidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  if (pid === process.pid) return true;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // EPERM = exists but not signalable → alive; ESRCH = gone.
-    return err?.code === 'EPERM';
-  }
-}
-
 function sleepSync(ms) {
   const dur = Math.max(1, Number(ms) || 1);
   try {

package/src/runtime/shared/tool-status.mjs

@@ -11,7 +11,11 @@ export function normalizeToolTerminalStatus(value) {
   if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
   if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
   if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
-  if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
+  // `cancel-unconfirmed` is task control's honest answer when a cancel was
+  // delivered but the process exit could not be confirmed. It is terminal for
+  // the tool call (the detail lives in the body), so it renders as cancelled
+  // rather than falling through to '' and leaving the surface with no status.
+  if (/^(cancelled|canceled|cancel|cancel[-_ ]unconfirmed|cancel[-_ ]pending|cancelling|canceling)$/.test(raw)) return 'cancelled';
   if (/^(denied|deny|refused|rejected)$/.test(raw)) return 'denied';
   return '';
 }