mixdog 0.9.61 → 0.9.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.61",
+  "version": "0.9.62",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -72,10 +72,10 @@
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:tui-ambiguous-width": "node --test scripts/tui-ambiguous-width-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
-    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs",
+    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",

package/scripts/session-heartbeat-lifecycle-test.mjs

@@ -0,0 +1,68 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const originalDataDir = process.env.MIXDOG_DATA_DIR;
+const dataDir = await mkdtemp(join(tmpdir(), 'mixdog-heartbeat-lifecycle-'));
+process.env.MIXDOG_DATA_DIR = dataDir;
+
+const {
+  deleteHeartbeat,
+  listSessionHeartbeatMtimes,
+  publishHeartbeat,
+} = await import('../src/runtime/agent/orchestrator/session/store/paths-heartbeat.mjs');
+const {
+  _clearSessionRuntime,
+  _getRuntimeEntry,
+  markSessionAskStart,
+  markSessionDone,
+  markSessionStreamDelta,
+  markSessionToolCall,
+  markSessionTransportActivity,
+} = await import('../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs');
+
+const heartbeatPath = (id) => join(dataDir, 'sessions', `${id}.hb`);
+
+after(async () => {
+  if (originalDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+  else process.env.MIXDOG_DATA_DIR = originalDataDir;
+  await rm(dataDir, { recursive: true, force: true });
+});
+
+test('heartbeat deletion wins over an already queued write', async () => {
+  const id = `heartbeat_delete_race_${Date.now()}`;
+  const write = publishHeartbeat(id, Date.now());
+  const deletion = deleteHeartbeat(id);
+  await Promise.all([write, deletion]);
+
+  assert.equal(existsSync(heartbeatPath(id)), false);
+  assert.equal(listSessionHeartbeatMtimes().has(id), false);
+
+  await publishHeartbeat(id, Date.now() + 10_000);
+  assert.equal(existsSync(heartbeatPath(id)), true, 'a later real turn can publish again');
+  await deleteHeartbeat(id);
+  assert.equal(existsSync(heartbeatPath(id)), false);
+});
+
+test('terminal sessions ignore late transport, stream, and tool callbacks', async () => {
+  const id = `heartbeat_terminal_${Date.now()}`;
+  await markSessionAskStart(id);
+  assert.equal(existsSync(heartbeatPath(id)), true);
+
+  await markSessionDone(id);
+  assert.equal(_getRuntimeEntry(id)?.stage, 'done');
+  assert.equal(existsSync(heartbeatPath(id)), false);
+
+  markSessionTransportActivity(id);
+  await markSessionStreamDelta(id, 'text');
+  await markSessionToolCall(id, 'shell');
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(existsSync(heartbeatPath(id)), false);
+  assert.equal(listSessionHeartbeatMtimes().has(id), false,
+    'desktop session catalog must not receive a working marker after completion');
+  _clearSessionRuntime(id);
+});

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -156,7 +156,7 @@ export function markSessionAskStart(id) {
     // statusline showed no maintenance/agent badge. STREAM_FRESH_MS (5 min)
     // still drops a session whose provider truly never returns a chunk;
     // markSessionStreamDelta keeps refreshing once chunks arrive.
-    publishHeartbeat(id, now);
+    return publishHeartbeat(id, now);
 }
 export function enableSessionTransportTracking(id) {
     if (!id) return;
@@ -173,7 +173,7 @@ export function disableSessionTransportTracking(id) {
 export function markSessionTransportActivity(id) {
     if (!id) return;
     const entry = _runtimeState.get(id);
-    if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    if (!entry || entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
     const now = Date.now();
     entry.lastTransportAt = now;
     entry.updatedAt = now;
@@ -199,7 +199,7 @@ export async function markSessionStreamDelta(id, kind = 'semantic') {
     // heartbeat indefinitely (the disk tombstone blocks ask resumption but not this
     // path). Skip a missing, tombstoned, or aborted entry — never refresh liveness.
     const entry = _runtimeState.get(id);
-    if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    if (!entry || entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
     const progressKind = _normalizeModelProgressKind(kind);
     if (progressKind === 'transport') {
         markSessionTransportActivity(id);
@@ -237,7 +237,10 @@ export async function markSessionStreamDelta(id, kind = 'semantic') {
 }
 export function markSessionToolCall(id, toolName, selfDeadlineMs) {
     if (!id) return;
-    const entry = _touchRuntime(id);
+    // A real tool call always follows markSessionAskStart. Never create or
+    // revive a runtime from a late provider callback after the turn settled.
+    const entry = _runtimeState.get(id);
+    if (!entry || entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
     entry.stage = 'tool_running';
     entry.lastToolCall = toolName || null;
     // A new tool call invalidates the previous call's live-output tail.
@@ -258,8 +261,9 @@ export function markSessionToolCall(id, toolName, selfDeadlineMs) {
     entry.lastToolProtocolAt = entry.toolStartedAt;
     entry.lastProgressAt = entry.toolStartedAt;
     entry.updatedAt = entry.toolStartedAt;
-    publishHeartbeat(id, entry.toolStartedAt);
+    const heartbeat = publishHeartbeat(id, entry.toolStartedAt);
     _startToolActivityHeartbeat(id);
+    return heartbeat;
 }
 // Live shell-output tail for the CURRENT running tool. Written by the shell
 // tool's onOutputTail timer (~1 s cadence), read by engine transcript
@@ -298,7 +302,7 @@ export function markSessionDone(id, { empty = false } = {}) {
     // Terminal stage — drop the heartbeat so the status badge releases
     // immediately. A subsequent ask on the same session re-publishes via
     // markSessionStreamDelta on the first chunk.
-    deleteHeartbeat(id);
+    return deleteHeartbeat(id);
 }
 // Tag a session as having completed with empty final synthesis (no
 // content/reasoning). Distinct from `markSessionDone`: still a success
@@ -327,8 +331,9 @@ export function markSessionError(id, msg) {
     entry.doneAt = errTs;
     entry.lastProgressAt = errTs;
     entry.updatedAt = errTs;
-    deleteHeartbeat(id);
+    const heartbeatDeleted = deleteHeartbeat(id);
     _unlinkParentAbortListener(entry);
+    return heartbeatDeleted;
 }
 export function markSessionCancelled(id) {
     if (!id) return;
@@ -344,8 +349,9 @@ export function markSessionCancelled(id) {
     entry.doneAt = doneTs;
     entry.lastProgressAt = doneTs;
     entry.updatedAt = doneTs;
-    deleteHeartbeat(id);
+    const heartbeatDeleted = deleteHeartbeat(id);
     _unlinkParentAbortListener(entry);
+    return heartbeatDeleted;
 }
 export function getSessionRuntime(id) {
     return id ? (_runtimeState.get(id) || null) : null;

package/src/runtime/agent/orchestrator/session/store/paths-heartbeat.mjs

@@ -28,6 +28,17 @@ export function sessionPath(id) {
 // directory and matches `<id>.hb` to `<id>.json`.
 const _HEARTBEAT_THROTTLE_MS = 5_000;
 const _hbLastAt = new Map();
+const _hbOperations = new Map();
+
+function _queueHeartbeatOperation(id, operation) {
+    const prior = _hbOperations.get(id) || Promise.resolve();
+    const next = prior.then(operation, operation).catch(() => {});
+    _hbOperations.set(id, next);
+    void next.then(() => {
+        if (_hbOperations.get(id) === next) _hbOperations.delete(id);
+    });
+    return next;
+}
 
 function _heartbeatPath(id) {
     if (!id || typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) {
@@ -37,18 +48,27 @@ function _heartbeatPath(id) {
 }
 
 export function publishHeartbeat(id, ts) {
-    if (!id) return;
+    if (!id) return Promise.resolve();
     const now = ts || Date.now();
     const last = _hbLastAt.get(id) || 0;
-    if (now - last < _HEARTBEAT_THROTTLE_MS) return;
+    if (now - last < _HEARTBEAT_THROTTLE_MS) {
+        return _hbOperations.get(id) || Promise.resolve();
+    }
     const target = _heartbeatPath(id);
     _hbLastAt.set(id, now);
-    void fsp.writeFile(target, `${now}\n`, 'utf8').catch(() => {});
+    return _queueHeartbeatOperation(id, () => fsp.writeFile(target, `${now}\n`, 'utf8'));
 }
 
 export function deleteHeartbeat(id) {
-    try { unlinkSync(_heartbeatPath(id)); } catch { /* ignore */ }
+    if (!id) return Promise.resolve();
+    const target = _heartbeatPath(id);
+    // Remove the visible marker immediately, then queue a second delete behind
+    // any pending write. Without the ordered cleanup, a write started just
+    // before turn completion can land after this unlink and resurrect the
+    // session's working badge for the full freshness window.
+    try { unlinkSync(target); } catch { /* ignore */ }
     _hbLastAt.delete(id);
+    return _queueHeartbeatOperation(id, () => fsp.unlink(target).catch(() => {}));
 }
 
 // Batch reader for session catalogs. Scanning only the handful of `.hb`