mixdog 0.9.52 → 0.9.53

package/scripts/freevar-smoke.mjs

@@ -20,8 +20,11 @@ import { analyze } from 'eslint-scope';
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 // Plain .mjs source roots. src/tui is covered by smoke:tui on the BUILT
 // bundle (App.jsx is JSX — acorn can't parse it raw); vendor is third-party.
-const SCAN_ROOTS = ['src/runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
-const SKIP_DIRS = new Set(['node_modules', 'dist', '.git']);
+const SCAN_ROOTS = ['src/runtime', 'src/session-runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
+const ROOT_RUNTIME_FACADES = readdirSync(join(ROOT, 'src'), { withFileTypes: true })
+  .filter(entry => entry.isFile() && entry.name.endsWith('.mjs'))
+  .map(entry => join(ROOT, 'src', entry.name));
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'vendor', '.git']);
 
 const KNOWN_GLOBALS = new Set([
   'Array', 'ArrayBuffer', 'Atomics', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
@@ -61,9 +64,9 @@ function* walk(dir) {
 
 let failures = 0;
 let scanned = 0;
-for (const root of SCAN_ROOTS) {
+for (const root of [...SCAN_ROOTS, ...ROOT_RUNTIME_FACADES]) {
   let files;
-  try { files = [...walk(root)]; } catch { continue; }
+  try { files = statSync(root).isDirectory() ? [...walk(root)] : [root]; } catch { continue; }
   for (const file of files) {
     scanned++;
     const source = readFileSync(file, 'utf8');

package/scripts/lifecycle-api-test.mjs

@@ -1,6 +1,10 @@
 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 { createConfigLifecycle } from '../src/session-runtime/config-lifecycle.mjs';
 import { createLifecycleApi } from '../src/session-runtime/lifecycle-api.mjs';
 import {
   _clearWebSocketPoolForTest,
@@ -17,7 +21,7 @@ function socket() {
   };
 }
 
-function lifecycleFor(session) {
+function lifecycleFor(session, overrides = {}) {
   let current = session;
   return createLifecycleApi({
     getSession: () => current,
@@ -45,15 +49,14 @@ function lifecycleFor(session) {
     mcpClient: { disconnectAll: () => null },
     warmupTimers: {},
     prewarmTimers: {},
-    flushConfigSave: () => {},
-    flushBackendSave: () => {},
-    flushOutputStyleSave: () => {},
+    flushAllConfigSavesAsync: async () => {},
     withTeardownDeadline: (promise) => promise,
     closePatchRuntimeIfLoaded: () => null,
     invalidateContextStatusCache: () => {},
     invalidatePreSessionToolSurface: () => {},
     notificationListeners: { clear: () => {} },
     remoteStateListeners: { clear: () => {} },
+    ...overrides,
   });
 }
 
@@ -74,3 +77,61 @@ test('lifecycle drains the OpenAI WS pool only for process exit', async () => {
 
   assert.deepEqual(retainedSocket.closed, ['cli-exit']);
 });
+
+test('lifecycle barrier drains a direct updateSectionAsync with no queued lifecycle save', async () => {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-lifecycle-config-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  const previousBackupRoot = process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
+  process.env.MIXDOG_DATA_DIR = dataDir;
+  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = join(dataDir, 'backups');
+  const sharedCfgMod = await import(`../src/runtime/shared/config.mjs?lifecycle-tail=${Date.now()}`);
+  const configLifecycle = createConfigLifecycle({
+    getConfig: () => ({}),
+    setConfig: () => {},
+    getSearchRoute: () => null,
+    setSearchRoute: () => {},
+    getConfigHasSecrets: () => false,
+    setConfigHasSecrets: () => {},
+    getRoute: () => ({}),
+    cfgMod: {
+      saveConfigAsync: async () => {},
+      patchSkillsDisabledAsync: async () => {},
+      getPluginData: () => dataDir,
+    },
+    sharedCfgMod,
+    setBackendAsync: async () => {},
+    setConfiguredShell: () => {},
+    normalizeSystemShellConfig: () => ({ command: '' }),
+    normalizeSearchRouteConfig: () => null,
+    outputStyleStatus: () => ({}),
+    LAZY_SECRET_PROVIDERS: new Set(),
+    clean: (value) => String(value || ''),
+    resolve: (value) => value,
+    STANDALONE_DATA_DIR: dataDir,
+  });
+
+  const events = [];
+  let directSettled = false;
+  try {
+    const directWrite = sharedCfgMod.updateSectionAsync('cycle3', () => ({ value: 'direct' }))
+      .finally(() => { directSettled = true; events.push('direct:settled'); });
+    assert.equal(directSettled, false);
+
+    const lifecycle = lifecycleFor(
+      { id: 'tail-drain', messages: [], liveTurnMessages: [] },
+      {
+        flushAllConfigSavesAsync: configLifecycle.flushAllConfigSavesAsync,
+        closePatchRuntimeIfLoaded: async () => { events.push('teardown:continued'); },
+      },
+    );
+    await lifecycle.close('engine-replace');
+    await directWrite;
+    assert.deepEqual(events, ['direct:settled', 'teardown:continued']);
+  } finally {
+    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    if (previousBackupRoot == null) delete process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
+    else process.env.MIXDOG_USER_DATA_BACKUP_ROOT = previousBackupRoot;
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+});

package/scripts/max-output-recovery-test.mjs

@@ -118,6 +118,37 @@ test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery
     assert.equal(provider.sent[1][1].content, 'gemini ');
 });
 
+test('Gemini MAX_TOKENS recovery derives missing prompt usage from total minus output', async () => {
+    const incomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'MAX_TOKENS',
+        partialContent: 'gemini ',
+        rawUsage: {
+            total_token_count: 20,
+            candidates_token_count: 4,
+            thoughts_token_count: 1,
+        },
+    });
+    const result = await run(queuedProvider([
+        incomplete,
+        {
+            content: 'complete',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 1, outputTokens: 2, promptTokens: 1 },
+        },
+    ]), undefined, { onTextDelta: () => {} });
+
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 16, outputTokens: 7, promptTokens: 16 },
+    );
+});
+
 test('Gemini MAX_TOKENS continuation preserves provider-scoped replay metadata', async () => {
     const providerMetadata = {
         gemini: { thoughtParts: [{ text: 'signed thought', thoughtSignature: 'sig-gemini' }] },

package/scripts/memory-core-input-test.mjs

@@ -7,6 +7,7 @@ import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.
 import { createMemoryActionHandlers } from '../src/runtime/memory/lib/memory-action-handlers.mjs'
 import { TOOL_DEFS as MEMORY_TOOL_DEFS } from '../src/runtime/memory/tool-defs.mjs'
 import { parseMemoryCandidateRows, parseMemoryCoreRows } from '../src/tui/app/input-parsers.mjs'
+import { memoryToolArgsForCaller } from '../src/session-runtime/runtime-core.mjs'
 
 test('memory mutation schema omits category while recall keeps its internal filter', () => {
   const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory')
@@ -16,6 +17,15 @@ test('memory mutation schema omits category while recall keeps its internal filt
   assert.equal(Object.hasOwn(recallTool.inputSchema.properties, 'category'), true)
 })
 
+test('memory tool calls inherit the active caller cwd only when cwd is omitted', () => {
+  assert.deepEqual(memoryToolArgsForCaller({ action: 'status' }, '/active/project'), {
+    action: 'status',
+    cwd: '/active/project',
+  })
+  const explicit = { action: 'status', cwd: '/explicit/project' }
+  assert.equal(memoryToolArgsForCaller(explicit, '/active/project'), explicit)
+})
+
 test('core content aliases summary, derives an element, and accepts no category', () => {
   const content = 'A durable preference that callers should receive concise answers.'
   const input = normalizeCoreInput({ content }, {

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -5,6 +5,7 @@ import { EventEmitter } from 'node:events';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import { applyAskTerminalUsageTotals } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
 import {
     _clearWebSocketPoolForTest,
     _closeAllPooledSockets,
@@ -247,6 +248,42 @@ test('pre-response 1006 opens a fresh WS and replays the same request', async ()
     assert.doesNotMatch(stderr, /mid-stream recovered|Reconnecting/);
 });
 
+test('completed warmup usage survives a same-send WS retry exactly once', async () => {
+    let streams = 0;
+    const result = await sendViaWebSocket(wsArgs({
+        warmupBody: { model: 'gpt-5.5', instructions: 'base', input: [], generate: false },
+        _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
+        _streamFn: async ({ state }) => {
+            streams += 1;
+            if (state.warmup) {
+                return {
+                    content: '',
+                    model: 'gpt-5.5',
+                    toolCalls: [],
+                    usage: { inputTokens: 10, outputTokens: 0, cachedTokens: 4, promptTokens: 10 },
+                    responseId: 'warm-retry-1',
+                    responseItems: [],
+                };
+            }
+            if (streams === 2) throw close1006();
+            return {
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 8, promptTokens: 20 },
+                responseId: 'main-retry-1',
+                responseItems: [],
+                closeSocket: true,
+            };
+        },
+    }));
+    assert.equal(streams, 3, 'one warmup plus two main attempts');
+    assert.equal(result.usage.inputTokens, 30);
+    assert.equal(result.usage.outputTokens, 2);
+    assert.equal(result.usage.mainInputTokens, 20);
+    assert.equal(result.usage.warmupInputTokens, 10);
+});
+
 test('successful iteration emits one compact send-spans row', async () => {
     const rows = [];
     const result = await sendViaWebSocket(wsArgs({
@@ -311,7 +348,7 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
     Object.assign(process.env, {
         MIXDOG_OAI_TRANSPORT: 'auto',
         MIXDOG_OPENAI_HTTP_FALLBACK: '1',
-        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '1',
         MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK: '0',
         MIXDOG_AGENT_TRACE_DISABLE: '1',
     });
@@ -327,7 +364,17 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
                 ...args,
                 _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
                 _sendFrameFn: async () => {},
-                _streamFn: async () => {
+                _streamFn: async ({ state }) => {
+                    if (state.warmup) {
+                        return {
+                            content: '',
+                            model: 'gpt-5.5',
+                            toolCalls: [],
+                            usage: { inputTokens: 10, outputTokens: 0, cachedTokens: 4, promptTokens: 10 },
+                            responseId: 'warm-fallback-1',
+                            responseItems: [],
+                        };
+                    }
                     streamAttempts += 1;
                     throw close1006();
                 },
@@ -335,7 +382,11 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
             }),
             _sendViaHttpSseFn: async () => {
                 httpCalls += 1;
-                return { content: 'http-recovered', toolCalls: [], usage: {} };
+                return {
+                    content: 'http-recovered',
+                    toolCalls: [],
+                    usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 8, promptTokens: 20 },
+                };
             },
         };
         const result = await provider.send([], 'gpt-5.5', [], sendOpts);
@@ -345,6 +396,15 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
         assert.equal(httpCalls, 2);
         assert.equal(result.content, 'http-recovered');
         assert.equal(stickyResult.content, 'http-recovered');
+        assert.equal(result.usage.inputTokens, 30, 'fallback bills the completed WS warmup once');
+        assert.equal(result.usage.mainInputTokens, 20, 'fallback context remains HTTP-main-only');
+        assert.equal(result.usage.warmupInputTokens, 10);
+        assert.equal(stickyResult.usage.inputTokens, 20, 'sticky HTTP sends do not rebill the old warmup');
+        assert.equal(stickyResult.usage.warmupInputTokens, undefined);
+        const session = { provider: 'openai-oauth' };
+        applyAskTerminalUsageTotals(session, { usage: result.usage, lastTurnUsage: result.usage });
+        assert.equal(session.totalInputTokens, 30, 'lifetime billing includes WS warmup plus HTTP main once');
+        assert.equal(session.lastContextTokens, 20, 'last context remains HTTP-main-only');
         assert.equal(provider._httpFallbackUntilByPoolKey.get(sendOpts.sessionId), Number.POSITIVE_INFINITY);
     } finally {
         for (const [name, value] of Object.entries(savedEnv)) {

package/scripts/openai-ws-early-settle-test.mjs

@@ -12,6 +12,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
+import { classifyMidstreamError, MIDSTREAM_RETRY_POLICY } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
 
 // Minimal fake WS: matches the .on/.off/.close/.ping surface _streamResponse
 // uses. close() is a no-op here -- the early-settle path sets done=true before
@@ -174,3 +175,42 @@ test('ws early settle: function args.done without item.done does NOT early-settl
     await assert.rejects(p, /inter-chunk inactivity/);
     assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'function item must stay active until output_item.done');
 });
+
+test('OpenAI WS rejects an oversized Buffer before UTF-8 conversion and marks it retryable', async () => {
+    const socket = new FakeSocket();
+    const state = { attemptIndex: 0 };
+    const payload = Buffer.alloc(33);
+    payload.toString = () => { throw new Error('oversized Buffer was decoded'); };
+    const p = _streamResponse({
+        entry: { socket },
+        state,
+        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 32 },
+    });
+    socket.emit('message', payload);
+    await assert.rejects(p, (error) => {
+        assert.equal(error.code, 'EOPENAIWSFRAMETOOLARGE');
+        assert.equal(error.retryable, true);
+        assert.match(error.message, /33 bytes; limit 32 bytes.*retryable/);
+        assert.equal(
+            classifyMidstreamError(error, state, MIDSTREAM_RETRY_POLICY.ws),
+            'ws_frame_too_large',
+        );
+        return true;
+    });
+    assert.deepEqual(socket.closed, { code: 1009, reason: 'frame_too_large' });
+});
+
+test('OpenAI WS preserves normal-size Buffer handling', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({
+        entry: { socket },
+        state: {},
+        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 1024 },
+    });
+    socket.emit('message', Buffer.from(JSON.stringify({
+        type: 'response.completed',
+        response: { id: 'resp_normal', model: 'gpt-5.5', output: [] },
+    })));
+    const result = await p;
+    assert.equal(result.responseId, 'resp_normal');
+});

package/scripts/parent-abort-link-test.mjs

@@ -6,6 +6,10 @@ import {
   markSessionCancelled,
   markSessionError,
 } from '../src/runtime/agent/orchestrator/session/manager.mjs';
+import {
+  _clearSessionRuntime,
+  _sweepTerminalSessionRuntimes,
+} from '../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs';
 
 test('markSessionError drops parent AbortSignal listener but keeps runtime entry', () => {
   const sessionId = `parent-abort-error-${Date.now()}`;
@@ -64,3 +68,23 @@ test('markSessionCancelled drops parent AbortSignal listener but keeps runtime e
   assert.equal(childAborted, false);
 });
 
+test('terminal runtime sweep drains the full backlog but preserves in-flight controllers', () => {
+  const prefix = `terminal-retention-${Date.now()}`;
+  const terminalIds = Array.from({ length: 40 }, (_, i) => `${prefix}-${i}`);
+  for (const id of terminalIds) {
+    linkParentSignalToSession(id, new AbortController().signal);
+    markSessionError(id, 'finished');
+    getSessionRuntime(id).controller = null;
+  }
+  const activeId = `${prefix}-active`;
+  linkParentSignalToSession(activeId, new AbortController().signal);
+  markSessionError(activeId, 'provider still unwinding');
+
+  const cleaned = _sweepTerminalSessionRuntimes();
+
+  assert.ok(cleaned >= terminalIds.length, 'one pass drains every settled terminal entry');
+  for (const id of terminalIds) assert.equal(getSessionRuntime(id), null);
+  assert.ok(getSessionRuntime(activeId)?.controller, 'active in-flight controller is retained');
+  _clearSessionRuntime(activeId);
+});
+

package/scripts/process-lifecycle-test.mjs

@@ -4,6 +4,7 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
   rmSync,
   unlinkSync,
   utimesSync,
@@ -103,71 +104,107 @@ test('vanished evidence uses only old-process fields and both ledger files stay
   }
 });
 
-test('PID reuse is detected by process identity while uncertain live identity is preserved', () => {
+test('PID reuse is detected by process identity while uncertain live identity is preserved', async () => {
   const root = tempRoot();
+  let child;
   try {
     const paths = lifecyclePathsForTest(root);
     mkdirSync(paths.markerDir, { recursive: true });
-    const seed = beginProcessLifecycle({ directory: root, configureReports: false });
-    const currentIdentity = JSON.parse(readFileSync(seed.markerPath, 'utf8')).processIdentity;
+    child = spawn(process.execPath, ['--input-type=module', '--eval', `
+      import { beginProcessLifecycle } from './src/runtime/shared/process-lifecycle.mjs';
+      beginProcessLifecycle({ directory: process.env.LEDGER_DIR, configureReports: false });
+      setTimeout(() => {}, 10000);
+    `], {
+      cwd: REPO_ROOT,
+      env: { ...process.env, LEDGER_DIR: root },
+      stdio: 'ignore',
+    });
+    let childMarker;
+    let currentIdentity;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const name = readdirSync(paths.markerDir).find((entry) => entry.startsWith(`${child.pid}-`));
+      if (name) {
+        childMarker = join(paths.markerDir, name);
+        currentIdentity = JSON.parse(readFileSync(childMarker, 'utf8')).processIdentity;
+        if (currentIdentity?.kind === 'linux-start-ticks' || currentIdentity?.method === 'powershell') break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
     assert.ok(currentIdentity);
-    finishProcessLifecycle('clean-shutdown', 0);
-    const reused = join(paths.markerDir, `${process.pid}-reused.json`);
-    const matching = join(paths.markerDir, `${process.pid}-matching.json`);
-    const uncertain = join(paths.markerDir, `${process.pid}-uncertain.json`);
-    const malformed = join(paths.markerDir, `${process.pid}-malformed.json`);
-    const clockAmbiguous = join(paths.markerDir, `${process.pid}-clock.json`);
-    const differentKind = join(paths.markerDir, `${process.pid}-different-kind.json`);
+    if (process.platform === 'win32') assert.equal(currentIdentity.method, 'powershell');
+
+    const reused = join(paths.markerDir, `${child.pid}-reused.json`);
+    const matching = join(paths.markerDir, `${child.pid}-matching.json`);
+    const uncertain = join(paths.markerDir, `${child.pid}-uncertain.json`);
+    const malformed = join(paths.markerDir, `${child.pid}-malformed.json`);
+    const clockAmbiguous = join(paths.markerDir, `${child.pid}-clock.json`);
+    const differentKind = join(paths.markerDir, `${child.pid}-different-kind.json`);
+    const mixedTransient = join(paths.markerDir, `${child.pid}-mixed-transient.json`);
+    const samePidForeign = join(paths.markerDir, `${process.pid}-same-pid-foreign.json`);
     const reusedIdentity = currentIdentity.kind === 'linux-start-ticks'
       ? { kind: currentIdentity.kind, value: String(BigInt(currentIdentity.value) + 1n) }
-      : { kind: currentIdentity.kind, value: currentIdentity.value + 1 };
+      : { ...currentIdentity, value: currentIdentity.value + 1 };
     writeFileSync(reused, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'reused',
       processIdentity: reusedIdentity,
     }));
     writeFileSync(matching, JSON.stringify({
-      pid: process.pid,
+      pid: child.pid,
       token: 'matching',
       processIdentity: currentIdentity,
     }));
     writeFileSync(uncertain, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'uncertain',
     }));
     writeFileSync(malformed, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'malformed',
       processIdentity: process.platform === 'linux'
         ? { kind: 'linux-start-ticks', value: 'not-a-number' }
         : { kind: 'start-seconds', value: 'not-a-number' },
     }));
     writeFileSync(clockAmbiguous, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'clock-adjusted',
       processIdentity: { kind: 'legacy-wall-clock', value: Date.now() + 86400000 },
     }));
     writeFileSync(differentKind, JSON.stringify({
-      pid: process.pid,
+      pid: child.pid,
       token: 'different-kind',
       processIdentity: currentIdentity.kind === 'linux-start-ticks'
         ? { kind: 'start-seconds', value: 1 }
         : { kind: 'linux-start-ticks', value: '1' },
     }));
+    if (currentIdentity.kind === 'start-seconds') {
+      writeFileSync(mixedTransient, JSON.stringify({
+        pid: child.pid,
+        token: 'mixed-transient',
+        processIdentity: { kind: currentIdentity.kind, value: currentIdentity.value + 1, method: 'uptime' },
+      }));
+    }
+    writeFileSync(samePidForeign, JSON.stringify({
+      pid: process.pid,
+      token: 'same-pid-foreign',
+      processIdentity: currentIdentity,
+    }));
     beginProcessLifecycle({ directory: root, configureReports: false });
     finishProcessLifecycle('clean-shutdown', 0);
-    assert.equal(entries(paths.ledger).filter((row) => row.reason === 'prior-process-vanished').length, 1);
+    assert.equal(entries(paths.ledger).filter((row) => row.reason === 'prior-process-vanished').length, 2);
     assert.equal(existsSync(reused), false);
     assert.equal(existsSync(matching), true);
     assert.equal(existsSync(uncertain), true);
     assert.equal(existsSync(malformed), true);
     assert.equal(existsSync(clockAmbiguous), true);
     assert.equal(existsSync(differentKind), true);
+    assert.equal(existsSync(samePidForeign), false);
+    assert.equal(existsSync(childMarker), true);
+    if (currentIdentity.kind === 'start-seconds') assert.equal(existsSync(mixedTransient), true);
   } finally {
+    child?.kill();
+    if (child) await childExit(child);
     rmSync(root, { recursive: true, force: true });
   }
 });
@@ -315,6 +352,27 @@ test('cleanup rejection and timeout are forced cleanup, not clean shutdown', asy
   }
 });
 
+test('uncaughtException synchronously restores terminal modes before cleanup', () => {
+  const source = `
+    import { installProcessSignalCleanup } from './src/runtime/shared/process-shutdown.mjs';
+    const reset = '\\x1b[?1000l\\x1b[?1002l\\x1b[?1006l\\x1b[?1049l';
+    installProcessSignalCleanup({
+      signals: [],
+      exit: false,
+      restoreTerminal: () => process.stdout.write(reset),
+      cleanup: async () => {},
+      log: () => {},
+    });
+    throw new Error('terminal fixture crash');
+  `;
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval', source], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stdout, '\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1049l');
+});
+
 test('Node report is compact, excludes environment, and rotates to one previous report', () => {
   const root = tempRoot();
   try {