mixdog 0.9.33 → 0.9.35

package/scripts/agent-live-arg-guard-smoke.mjs

@@ -0,0 +1,20 @@
+// Standalone regression smoke for validateBuiltinArgs guard behavior.
+// Mirrors arg-guard-test.mjs style; runs with `node --test`.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
+
+test('smoke: valid read args pass and numeric strings coerce', () => {
+    const a = { path: 'x.mjs', offset: '2', limit: '10' };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.offset, 2);
+    assert.equal(a.limit, 10);
+});
+
+test('smoke: non-numeric arg still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: 'nope' }), /must be an integer/);
+});
+
+test('smoke: below-min arg still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', offset: -1 }), /must be >= 0/);
+});

package/scripts/agent-live-path-suffix-smoke.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findBySuffixStrip } from '../src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs';
+
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-suffix-smoke-'));
+    mkdirSync(join(root, 'src', 'tui'), { recursive: true });
+    writeFileSync(join(root, 'src', 'tui', 'input-editing.mjs'), '// real file\n');
+    return root;
+}
+
+test('smoke: hallucinated absolute prefix resolves to the real repo-relative file', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/nobody/Elsewhere/Project/ink/src/tui/input-editing.mjs';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'src/tui/input-editing.mjs');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('smoke: a non-existent tail resolves to null', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, '/Users/nobody/Elsewhere/Project/does/not/here.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/scripts/agent-live-toolcall-args-smoke.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Standalone regression smoke pinning the tool_call arguments contract used by
+// the native providers (see scripts/toolcall-args-test.mjs for the full suite).
+// Same unit-test style: synthetic inputs fed to the exported parser, asserting
+// the outcome — no network, no model. Kept minimal so it can run in isolation
+// via `node --test scripts/agent-live-toolcall-args-smoke.mjs`.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    parseCompletedToolCallArgumentsJson,
+    isInvalidToolArgsMarker,
+    formatInvalidToolArgsResult,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+
+test('smoke: valid arguments JSON parses to the intended object', () => {
+    const out = parseCompletedToolCallArgumentsJson(
+        '{"pattern":"x","path":"src"}', 'smoke', { finishReason: 'stop' });
+    assert.deepEqual(out, { pattern: 'x', path: 'src' });
+});
+
+test('smoke: empty/missing arguments default to {}', () => {
+    assert.deepEqual(parseCompletedToolCallArgumentsJson('', 'smoke', { finishReason: 'stop' }), {});
+    assert.deepEqual(parseCompletedToolCallArgumentsJson(undefined, 'smoke'), {});
+});
+
+test('smoke: malformed args with finishReason → invalid-args marker (no throw)', () => {
+    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
+    const out = parseCompletedToolCallArgumentsJson(bareword, 'smoke', { finishReason: 'stop' });
+    assert.equal(isInvalidToolArgsMarker(out), true);
+    assert.equal(out.__rawArguments, bareword);
+    const msg = formatInvalidToolArgsResult({ name: 'grep', arguments: out });
+    assert.match(msg, /Re-issue this tool call with valid JSON arguments/);
+});
+
+test('smoke: malformed args without finishReason → retryable TruncatedStreamError', () => {
+    let threw;
+    try {
+        parseCompletedToolCallArgumentsJson('{', 'smoke');
+    } catch (err) {
+        threw = err;
+    }
+    assert.ok(threw instanceof Error, 'must throw on mid-stream truncation');
+    assert.equal(threw.code, 'TRUNCATED_STREAM');
+    assert.equal(threw.truncatedStream, true);
+});

package/scripts/apply-patch-edit-smoke.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertOk(label, result) {
+  const text = String(result || '');
+  if (!text || /^Error[\s:]/.test(text)) {
+    throw new Error(`${label} failed:\n${text}`);
+  }
+  return text;
+}
+
+const tmp = mkdtempSync(join(tmpdir(), 'mixdog-apply-patch-smoke-'));
+
+try {
+  writeFileSync(join(tmp, 'target.txt'), 'alpha\nbeta\ngamma\n', 'utf8');
+
+  const editResult = await executePatchTool('apply_patch', {
+    base_path: tmp,
+    patch: `*** Begin Patch
+*** Update File: target.txt
+@@
+ alpha
+-beta
++bravo
+ gamma
+*** Add File: created.txt
++created by apply_patch smoke
++second line
+*** End Patch
+`,
+  }, tmp, {});
+  assertOk('apply_patch edit', editResult);
+
+  assert(
+    readFileSync(join(tmp, 'target.txt'), 'utf8') === 'alpha\nbravo\ngamma\n',
+    'apply_patch update did not write the expected target.txt contents',
+  );
+  assert(
+    readFileSync(join(tmp, 'created.txt'), 'utf8') === 'created by apply_patch smoke\nsecond line\n',
+    'apply_patch add did not write the expected created.txt contents',
+  );
+
+  const deleteResult = await executePatchTool('apply_patch', {
+    base_path: tmp,
+    patch: `*** Begin Patch
+*** Delete File: created.txt
+*** End Patch
+`,
+  }, tmp, {});
+  assertOk('apply_patch delete', deleteResult);
+
+  let deleteMissing = false;
+  try {
+    readFileSync(join(tmp, 'created.txt'), 'utf8');
+  } catch (err) {
+    if (err?.code === 'ENOENT') deleteMissing = true;
+    else throw err;
+  }
+  assert(deleteMissing, 'apply_patch delete left created.txt on disk');
+
+  process.stdout.write('apply_patch edit smoke passed\n');
+} finally {
+  rmSync(tmp, { recursive: true, force: true });
+}

package/scripts/async-notify-settlement-test.mjs

@@ -0,0 +1,99 @@
+// A Promise-returning notifyFn must only *mark* a background-task completion
+// delivered after the promise settles. When it rejects/declines AND the
+// enqueueFallback rescue also fails, the task must be left UN-marked so a later
+// reconcile can retry — never silently marked delivered before settlement.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  registerBackgroundTask,
+  completeBackgroundTask,
+  getBackgroundTask,
+  setBackgroundTaskEnqueueFallback,
+  reconcileBackgroundTask,
+} from '../src/runtime/shared/background-tasks.mjs';
+
+const tick = () => new Promise((r) => setImmediate(r));
+
+test('async notifyFn rejection with no rescue does not mark delivered', async () => {
+  setBackgroundTaskEnqueueFallback(null); // no fallback channel → nothing lands
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')) },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  // Optimistic marks were applied synchronously; settlement must clear them.
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(t.notifiedWithBody, false, 'body delivery un-marked after async failure');
+  assert.equal(t.notified, false, 'notified un-marked after async failure');
+});
+
+test('async notifyFn success keeps the completion marked delivered', async () => {
+  setBackgroundTaskEnqueueFallback(null);
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.resolve(true) },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(t.notifiedWithBody, true, 'successful async delivery stays marked');
+  assert.equal(t.notified, true, 'successful async delivery stays notified');
+});
+
+test('async notifyFn rejection is rescued by fallback and stays marked', async () => {
+  const enqueued = [];
+  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_rescue' },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+
+  await tick();
+  await tick();
+  const t = getBackgroundTask(task.taskId);
+  assert.equal(enqueued.length, 1, 'fallback rescued the completion once');
+  assert.equal(t.notifiedWithBody, true, 'rescued delivery stays marked exactly once');
+});
+
+test('reconcile retries an un-marked completion on an already-terminal task', async () => {
+  // First completion: async notifyFn rejects and there is NO fallback, so the
+  // task is driven terminal but the body notification un-marks itself.
+  setBackgroundTaskEnqueueFallback(null);
+  const task = registerBackgroundTask({
+    surface: 'tool',
+    operation: 'run',
+    resultType: 'tool_task_result',
+    context: { notifyFn: () => Promise.reject(new Error('boom')), callerSessionId: 'sess_reconcile' },
+  });
+  completeBackgroundTask(task.taskId, { status: 'completed', resultText: 'body payload', terminalReason: 'test' });
+  await tick();
+  await tick();
+  const before = getBackgroundTask(task.taskId);
+  assert.equal(before.notifiedWithBody, false, 'body un-marked after the failed async notify');
+
+  // A later reconcile on the (already-terminal) task must retry the delivery
+  // rather than returning early. With a working fallback now in place it lands.
+  const enqueued = [];
+  setBackgroundTaskEnqueueFallback((sessionId, text) => { enqueued.push({ sessionId, text }); return 1; });
+  reconcileBackgroundTask(task.taskId, { status: 'completed', terminalReason: 'reconciled' });
+  await tick();
+  await tick();
+  const after = getBackgroundTask(task.taskId);
+  assert.equal(enqueued.length, 1, 'reconcile re-fired the completion once on the terminal task');
+  assert.equal(after.notifiedWithBody, true, 'reconcile retry marks the body delivered');
+});
+
+test.after(() => { setBackgroundTaskEnqueueFallback(null); });

package/scripts/compact-trigger-migration-smoke.mjs

@@ -55,52 +55,58 @@ function assert(condition, message) {
     `sub-boundary explicit limit should be preserved, got ${meta.autoCompactTokenLimit}`);
 }
 
-// 3) compactTriggerForSession ignores a boundary-equal stored autoCompactTokenLimit
-//    (legacy artifact) and applies the default 10% buffer; honors a sub-boundary one.
+// 3) compactTriggerForSession: main/user (non-agent) recall-fasttrack compacts
+//    on the boundary itself (100%, no early-trigger buffer); a truly-explicit
+//    sub-boundary autoCompactTokenLimit still wins. Agent-owned semantic
+//    sessions keep the default 10% buffer (90%).
 {
   const boundary = 200000;
   const legacy = compactTriggerForSession({ autoCompactTokenLimit: boundary, compaction: {} }, boundary);
-  assert(legacy === 180000, `legacy boundary-equal limit should yield default 10% trigger 180000, got ${legacy}`);
+  assert(legacy === 200000, `main/user boundary-equal limit should yield 100% trigger 200000, got ${legacy}`);
   const explicit = compactTriggerForSession({ autoCompactTokenLimit: 150000, compaction: {} }, boundary);
   assert(explicit === 150000, `sub-boundary explicit limit should be the trigger, got ${explicit}`);
+  const agent = compactTriggerForSession({ owner: 'agent', autoCompactTokenLimit: boundary, compaction: {} }, boundary);
+  assert(agent === 180000, `agent boundary-equal limit should yield default 10% trigger 180000, got ${agent}`);
+  const agentExplicit = compactTriggerForSession({ owner: 'agent', autoCompactTokenLimit: 150000, compaction: {} }, boundary);
+  assert(agentExplicit === 150000, `agent sub-boundary explicit limit should be the trigger, got ${agentExplicit}`);
 }
 
-// 4) A configured bufferPercent flows into the trigger via session.compaction.
+// 4) A configured bufferPercent flows into the trigger for agent-owned sessions;
+//    main/user sessions ignore the buffer and stay on the boundary (100%).
 {
   const boundary = 200000;
-  // bufferPercent: 5 → 5% → trigger 190000.
-  const trigger = compactTriggerForSession({ compaction: { bufferPercent: 5 } }, boundary);
-  assert(trigger === 190000, `bufferPercent 5 should yield trigger 190000, got ${trigger}`);
+  const agentTrigger = compactTriggerForSession({ owner: 'agent', compaction: { bufferPercent: 5 } }, boundary);
+  assert(agentTrigger === 190000, `agent bufferPercent 5 should yield trigger 190000, got ${agentTrigger}`);
+  const userTrigger = compactTriggerForSession({ compaction: { bufferPercent: 5 } }, boundary);
+  assert(userTrigger === 200000, `main/user should ignore bufferPercent and stay at 100% 200000, got ${userTrigger}`);
 }
 
-// 5) Legacy telemetry from the old default 10% buffer is non-config and reapplies
-//    the current default 10% headroom (trigger 180000). Persisted zero-buffer
-//    telemetry migrates the same way.
+// 5) Legacy/zero buffer telemetry migration is an agent-path concern (the
+//    default-buffer sanitizer). Agent-owned sessions reapply the current 10%
+//    default (trigger 180000); explicit bufferTokens still lowers the agent
+//    trigger. Main/user sessions ignore all of it and compact at 100%.
 {
   const boundary = 200000;
-  const legacyTelemetry = compactTriggerForSession({
-    compaction: {
-      boundaryTokens: boundary,
-      triggerTokens: 180000,
-      bufferTokens: 20000,
-      bufferRatio: 0.1,
-    },
+  const agentLegacy = compactTriggerForSession({
+    owner: 'agent',
+    compaction: { boundaryTokens: boundary, triggerTokens: 180000, bufferTokens: 20000, bufferRatio: 0.1 },
   }, boundary);
-  assert(legacyTelemetry === 180000,
-    `legacy default buffer telemetry should yield 10% headroom trigger 180000, got ${legacyTelemetry}`);
-  const zeroTelemetry = compactTriggerForSession({
-    compaction: {
-      boundaryTokens: boundary,
-      triggerTokens: boundary,
-      bufferTokens: 0,
-      bufferRatio: 0,
-    },
+  assert(agentLegacy === 180000,
+    `agent legacy default buffer telemetry should yield 10% headroom trigger 180000, got ${agentLegacy}`);
+  const agentZero = compactTriggerForSession({
+    owner: 'agent',
+    compaction: { boundaryTokens: boundary, triggerTokens: boundary, bufferTokens: 0, bufferRatio: 0 },
   }, boundary);
-  assert(zeroTelemetry === 180000,
-    `persisted zero-buffer telemetry should restore default 10% trigger 180000, got ${zeroTelemetry}`);
-  const explicitTokens = compactTriggerForSession({ compaction: { bufferTokens: 10000 } }, boundary);
-  assert(explicitTokens === 190000,
-    `explicit bufferTokens should still lower trigger to 190000, got ${explicitTokens}`);
+  assert(agentZero === 180000,
+    `agent persisted zero-buffer telemetry should restore default 10% trigger 180000, got ${agentZero}`);
+  const agentExplicitTokens = compactTriggerForSession({ owner: 'agent', compaction: { bufferTokens: 10000 } }, boundary);
+  assert(agentExplicitTokens === 190000,
+    `agent explicit bufferTokens should lower trigger to 190000, got ${agentExplicitTokens}`);
+  const userTelemetry = compactTriggerForSession({
+    compaction: { boundaryTokens: boundary, triggerTokens: 180000, bufferTokens: 20000, bufferRatio: 0.1 },
+  }, boundary);
+  assert(userTelemetry === 200000,
+    `main/user should ignore buffer telemetry and stay at 100% 200000, got ${userTelemetry}`);
 }
 
 // 6) preserveBufferConfigFields copies only finite-positive percent/ratio fields.

package/scripts/forwarder-rebind-tail-test.mjs

@@ -0,0 +1,67 @@
+// Regression: on channel connect/change/rebind, OutputForwarder.setContext must
+// NOT pull the read cursor back to a prior/unrelated transcript's tail. Only a
+// genuinely-unsynced tail of the SAME transcript (crash recovery) is recovered;
+// a fresh binding to a DIFFERENT transcript stays at EOF so only outputs created
+// after the new binding are forwarded (never the old tail).
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { OutputForwarder } from '../src/runtime/channels/lib/output-forwarder.mjs';
+
+function jsonl(...entries) {
+  return entries.map((e) => JSON.stringify(e)).join('\n') + '\n';
+}
+
+const USER = { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } };
+const ASSISTANT = { type: 'assistant', message: { content: [{ type: 'text', text: 'old reply tail' }] } };
+
+function makeForwarder(persisted) {
+  // statusState stub: setContext only reads via this.statusState.read().
+  return new OutputForwarder(() => {}, { read: () => persisted });
+}
+
+test('rebind to a DIFFERENT transcript never recovers the old tail (cursor stays at EOF)', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'fwd-rebind-'));
+  try {
+    const bound = join(dir, 'new-session.jsonl');
+    const prior = join(dir, 'prior-session.jsonl');
+    writeFileSync(bound, jsonl(USER, ASSISTANT));
+    const size = statSync(bound).size;
+    // Persisted status points at a DIFFERENT (prior) transcript, no send evidence.
+    const fwd = makeForwarder({
+      transcriptPath: prior,
+      lastFileSize: 0,
+      sentCount: 0,
+      lastSentTime: 0,
+      lastSentHash: '',
+    });
+    fwd.setContext('chan-1', bound, { catchUpFromPersisted: true, recoverUnsyncedTail: true });
+    assert.equal(fwd.lastFileSize, size, 'cursor must be at EOF — old tail of a fresh binding is not forwarded');
+    assert.equal(fwd.readFileSize, size);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SAME-transcript unsynced tail (no send evidence) is still recovered', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'fwd-same-'));
+  try {
+    const bound = join(dir, 'session.jsonl');
+    writeFileSync(bound, jsonl(USER, ASSISTANT));
+    const size = statSync(bound).size;
+    // Persisted status is the SAME transcript, fully synced size, no send evidence.
+    const fwd = makeForwarder({
+      transcriptPath: bound,
+      lastFileSize: size,
+      sentCount: 0,
+      lastSentTime: 0,
+      lastSentHash: '',
+    });
+    fwd.setContext('chan-1', bound, { catchUpFromPersisted: true, recoverUnsyncedTail: true });
+    assert.ok(fwd.lastFileSize < size, 'same-session unsynced tail must be recovered (cursor before EOF)');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/live-worker-smoke.mjs

@@ -37,7 +37,7 @@ async function main() {
   const workflowRules = readFileSync('src/workflows/default/WORKFLOW.md', 'utf8');
   assert(/Use `agent` for scoped implementation/i.test(leadToolRules), 'lead rules must direct scoped work to agents');
   assert(/PARALLEL across independent scopes/i.test(workflowRules), 'workflow rules must keep independent work parallel');
-  assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
+  assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags?/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
 
   mkdirSync(dataDir, { recursive: true });
   await initProviders({ 'openai-oauth': { enabled: true } });

package/scripts/pending-completion-drop-test.mjs

@@ -1,7 +1,9 @@
-// Proves deferred agent/tool *completion* notifications are DROPPED on drain
-// (never replayed out-of-order on a later session resume) while genuine
-// user/steering messages in the same queue survive with order preserved.
-// Owner decision: out-of-order replay is worse than loss.
+// Deferred agent/tool *completion* notifications must:
+//   - SURVIVE a LIVE drain (they are the intended model-visible payload, e.g.
+//     the idle-resume kick delivering an async task body this process), and
+//   - be DROPPED on a RESUME drain (only the persisted copy remains after a
+//     restart, where replaying it would inject the body out-of-order).
+// Genuine user/steering messages survive with order preserved in both paths.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
@@ -18,47 +20,64 @@ const {
   drainPendingMessages,
   COMPLETION_NOTIFICATION_KIND,
   markCompletionEntry,
+  _dropPendingMessageState,
 } = await import('../src/runtime/agent/orchestrator/session/manager/pending-messages.mjs');
 
-function completionEntry(text) {
-  return { content: text, text, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Date.now() };
-}
+test('live drain delivers the completion notification and keeps user order', () => {
+  const sid = 'sess_live_1';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, 'user second');
+
+  // In-memory queue is populated (live, same process) → completion survives.
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  assert.ok(drained.includes('user first') && drained.includes('user second'), 'user messages kept');
+  assert.ok(drained.some((t) => /finished/.test(t)), 'live completion delivered, not dropped');
+  assert.ok(drained.indexOf('user first') < drained.indexOf('user second'), 'user order preserved');
+});
+
+test('live drain preserves interleaved [user, completion, user] order', () => {
+  // Buffered-persist copies of the live sends carry the same user texts but the
+  // completion is filtered out of the persisted path. The in-memory queue is
+  // authoritative, so the completion must stay BETWEEN the users and never be
+  // flattened to the tail as [user, user, completion].
+  const sid = 'sess_live_order';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task zzz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, 'user second');
+
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  const first = drained.indexOf('user first');
+  const second = drained.indexOf('user second');
+  const completion = drained.findIndex((t) => /finished/.test(t));
+  assert.ok(completion !== -1, 'completion present in live drain');
+  assert.ok(first < completion && completion < second, 'completion stays between the two users');
+});
 
-test('drain drops completion notifications, keeps user messages in order', async () => {
-  const sid = 'sess_drop_test_1';
+test('resume drain drops the completion notification, keeps user messages in order', async () => {
+  const sid = 'sess_resume_1';
   enqueuePendingMessage(sid, 'user first');
-  enqueuePendingMessage(sid, completionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
   enqueuePendingMessage(sid, 'user second');
 
-  // Let the buffered persist flush to disk so we also verify the on-disk marker
-  // (the shape a later resume would drain).
+  // Flush the buffered persist to disk, then drop the in-memory queue → mimic a
+  // restart where only the persisted copy survives (the resume path).
   await new Promise((r) => setImmediate(r));
   await new Promise((r) => setTimeout(r, 30));
   const store = JSON.parse(readFileSync(join(dataDir, 'session-pending-messages.json'), 'utf8'));
   const persistedQueue = store.sessions[sid] || [];
   const marked = persistedQueue.filter((e) => e && typeof e === 'object' && e.notificationKind === COMPLETION_NOTIFICATION_KIND);
   assert.equal(marked.length, 1, 'completion notification persisted as a marked object');
-  assert.ok(persistedQueue.includes('user first') && persistedQueue.includes('user second'), 'user messages persisted as plain strings');
+  _dropPendingMessageState(sid, { clearPersisted: false });
 
   const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
-  assert.deepEqual(drained, ['user first', 'user second'], 'completion dropped; user messages kept in order');
-  assert.ok(!drained.some((t) => /finished/.test(t)), 'no completion prose replayed');
+  assert.deepEqual(drained, ['user first', 'user second'], 'completion dropped on resume; user order kept');
+  assert.ok(!drained.some((t) => /finished/.test(t)), 'no completion prose replayed on resume');
 
-  // A second drain (post-resume) yields nothing — the completion was discarded,
-  // not deferred.
+  // A second drain yields nothing — the completion was discarded, not deferred.
   assert.deepEqual(drainPendingMessages(sid), []);
 });
 
 test.after(() => {
   try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
 });
-
-// Proves the shared tagger (used by notify.mjs, tool-exec.mjs, runtime-core.mjs)
-// yields entries drain drops, while a real user message survives in order.
-test('markCompletionEntry path is dropped on drain; user message survives', () => {
-  const sid = 'sess_drop_test_2';
-  enqueuePendingMessage(sid, 'real user question');
-  enqueuePendingMessage(sid, markCompletionEntry('Async agent task abc finished.\n\nResult:\n> ok'));
-  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
-  assert.deepEqual(drained, ['real user question']);
-});