mixdog 0.9.60 → 0.9.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.60",
+  "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/scripts/tui-transcript-perf-test.mjs

@@ -409,6 +409,32 @@ test('abort before a newline settles the accumulated partial response', async ()
   assert.equal(assistants[0].text, 'partial without newline');
 });
 
+test('abort after tool boundaries does not replay committed progress as one giant assistant row', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onAssistantText('first progress');
+    await options.onToolCall(1, [{
+      id: 'call_1',
+      name: 'shell',
+      input: { command: 'first' },
+    }]);
+    options.onToolResult({ tool_call_id: 'call_1', content: 'ok' });
+    options.onAssistantText('second progress');
+    await options.onToolCall(2, [{
+      id: 'call_2',
+      name: 'shell',
+      input: { command: 'second' },
+    }]);
+    const error = new Error('interrupted');
+    error.name = 'SessionClosedError';
+    throw error;
+  });
+
+  assert.equal(await harness.runTurn('go'), 'cancelled');
+  assert.equal(harness.getState().streamingTail, null);
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.deepEqual(assistants.map((item) => item.text), ['first progress', 'second progress']);
+});
+
 // Codifies pre-existing parity: the old in-items completed-line snapshot survived starved recovery.
 test('starved Esc recovery settles a non-empty tail exactly once', async () => {
   let state = {

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`

package/src/tui/dist/index.mjs

@@ -27537,9 +27537,9 @@ function createRunTurn(bag) {
         flushStreamBatch();
         if (error?.name === "SessionClosedError") {
           cancelled = true;
-          if (assistantText.trim()) {
-            const id = currentAssistantId || ensureAssistant(assistantText);
-            settleStreamingTail(id, { text: currentAssistantText || assistantText });
+          if (currentAssistantText.trim()) {
+            const id = currentAssistantId || ensureAssistant(currentAssistantText);
+            settleStreamingTail(id, { text: currentAssistantText });
           }
           flushToolResults([], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true, cancelled: true });
           finalizeToolHeaders();

package/src/tui/engine/turn.mjs

@@ -1278,9 +1278,13 @@ export function createRunTurn(bag) {
         flushStreamBatch(); // ensure any batched text lands before the error notice
         if (error?.name === 'SessionClosedError') {
           cancelled = true;
-          if (assistantText.trim()) {
-            const id = currentAssistantId || ensureAssistant(assistantText);
-            settleStreamingTail(id, { text: currentAssistantText || assistantText });
+          // Tool boundaries already sealed prior progress segments into their
+          // own rows. On abort, preserve only the still-open segment; replaying
+          // turn-global assistantText creates one giant duplicate after the
+          // cancelled tool card.
+          if (currentAssistantText.trim()) {
+            const id = currentAssistantId || ensureAssistant(currentAssistantText);
+            settleStreamingTail(id, { text: currentAssistantText });
           }
           // Finalize pending tool cards so they don't stay "Running..." forever
           // after cancellation. Without this, the spinner vanishes and TurnDone