mixdog 0.9.29 → 0.9.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.29",
+  "version": "0.9.31",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/execution-pending-resume-kick-test.mjs

@@ -0,0 +1,96 @@
+// Regression for the execution-pending-resume kick (engine/agent-job-feed.mjs).
+// Guards two coupled defects:
+//   A (body loss): parallel completions deferred while busy must each surface
+//     their model-visible body on resume — the old single string slot dropped
+//     all but the last.
+//   B (missed resume): a deferred kick left after a busy->false transition that
+//     did NOT go through drain-finally / normal-turn-end (watchdog force-release
+//     or stale-unwind) must still fire when flushDeferred is called.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createAgentJobFeed } from '../src/tui/engine/agent-job-feed.mjs';
+
+// Minimal harness: a mutable busy flag, a pending queue, and a synchronous
+// drain stub that "resumes" by surfacing every pending-resume entry's body.
+function makeHarness() {
+  const pending = [];
+  const surfaced = [];
+  const state = { busy: false };
+  let draining = false;
+
+  function drain() {
+    if (draining) return Promise.resolve();
+    draining = true;
+    try {
+      for (let i = 0; i < pending.length;) {
+        const entry = pending[i];
+        if (entry.mode === 'pending-resume') {
+          surfaced.push(entry.text);
+          pending.splice(i, 1);
+        } else {
+          i += 1;
+        }
+      }
+    } finally {
+      draining = false;
+    }
+    return Promise.resolve();
+  }
+
+  const feed = createAgentJobFeed({
+    runtime: {},
+    getState: () => state,
+    set: () => {},
+    nextId: () => 'id',
+    getDisposed: () => false,
+    patchItem: () => {},
+    enqueue: () => {},
+    drain,
+    pushUserOrSyntheticItem: () => {},
+    makeQueueEntry: (text, opts = {}) => ({ text, mode: opts.mode, priority: opts.priority }),
+    getPending: () => pending,
+    agentStatusState: () => ({}),
+    displayedExecutionNotificationKeys: new Set(),
+    pushNotice: () => {},
+  });
+
+  return { feed, pending, surfaced, state };
+}
+
+const microtasks = () => new Promise((r) => setImmediate(r));
+
+test('A: two completions deferred while busy both surface their bodies on resume', async () => {
+  const { feed, surfaced, state } = makeHarness();
+  state.busy = true;
+  feed.scheduleExecutionPendingResumeKick('body A');
+  feed.scheduleExecutionPendingResumeKick('body B');
+  await microtasks();
+  // Both kicks deferred while busy; nothing surfaced yet.
+  assert.deepEqual(surfaced, []);
+
+  // Turn settles normally -> busy false -> flush re-arms the kick.
+  state.busy = false;
+  feed.flushDeferredExecutionPendingResumeKick();
+  assert.equal(surfaced.length, 1, 'a single merged resume entry surfaced');
+  assert.match(surfaced[0], /body A/, 'first body preserved');
+  assert.match(surfaced[0], /body B/, 'second body preserved (not dropped)');
+});
+
+test('B: deferred kick after a non-drain busy->false transition still fires', async () => {
+  const { feed, surfaced, state } = makeHarness();
+  state.busy = true;
+  feed.scheduleExecutionPendingResumeKick('only body');
+  await microtasks();
+  assert.deepEqual(surfaced, [], 'deferred while busy');
+
+  // Simulate watchdog force-release / stale-unwind: busy flips to false WITHOUT
+  // drain-finally, then flushDeferred runs on that transition.
+  state.busy = false;
+  feed.flushDeferredExecutionPendingResumeKick();
+  assert.deepEqual(surfaced, ['only body'], 'resume fired on the non-drain transition');
+
+  // Idempotent: a second flush with nothing deferred is a no-op.
+  feed.flushDeferredExecutionPendingResumeKick();
+  assert.deepEqual(surfaced, ['only body']);
+});

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

@@ -0,0 +1,64 @@
+// 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.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Redirect the pending-message spool to a throwaway dir before import so the
+// real ~/.mixdog/data spool is never touched.
+const dataDir = mkdtempSync(join(tmpdir(), 'mixpend-'));
+process.env.MIXDOG_DATA_DIR = dataDir;
+
+const {
+  enqueuePendingMessage,
+  drainPendingMessages,
+  COMPLETION_NOTIFICATION_KIND,
+  markCompletionEntry,
+} = 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('drain drops completion notifications, keeps user messages in order', async () => {
+  const sid = 'sess_drop_test_1';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, completionEntry('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).
+  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');
+
+  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');
+
+  // A second drain (post-resume) 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']);
+});

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -9,7 +9,7 @@ import { executeBashSessionTool } from '../../tools/bash-session.mjs';
 import { executePatchTool } from '../../tools/patch.mjs';
 import { executeInternalTool, isInternalTool } from '../../internal-tools.mjs';
 import { normalizeToolEnvelope, makeToolEnvelope } from '../tool-envelope.mjs';
-import { getSessionAbortSignal, enqueuePendingMessage } from '../manager.mjs';
+import { getSessionAbortSignal, enqueuePendingMessage, markCompletionEntry } from '../manager.mjs';
 import { createScopedCacheOutcome } from '../cache/scoped-cache-outcome.mjs';
 import { modelVisibleToolCompletionMessage } from '../../../../shared/tool-execution-contract.mjs';
 import { _isScopedCacheableTool } from './tool-classify.mjs';
@@ -68,7 +68,9 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
             if (!notificationSessionId) return;
             try {
                 const visible = modelVisibleToolCompletionMessage(text, meta);
-                if (visible) enqueuePendingMessage(notificationSessionId, visible);
+                // Inherently a tool-completion notification → tag so a later
+                // resume drops it instead of replaying it as user text.
+                if (visible) enqueuePendingMessage(notificationSessionId, markCompletionEntry(visible));
             } catch { /* best effort */ }
         };
     const completionToolOpts = {

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -11,9 +11,31 @@ const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
 const PENDING_ORPHAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PENDING_ORPHAN_GRACE_MS = 60 * 60 * 1000;
+// Marker for deferred agent/tool *completion* notifications. Such entries must
+// never be replayed into a later turn on session resume (out-of-order delivery
+// is worse than loss — owner decision), so drain discards them. Genuine
+// user/steering messages carry no marker and keep full queue + replay behavior.
+export const COMPLETION_NOTIFICATION_KIND = 'completion_notification';
 const _pendingPersistBuffers = new Map();
 let _pendingPersistImmediate = null;
 
+function isCompletionNotificationEntry(entry) {
+    return Boolean(entry) && typeof entry === 'object'
+        && entry.notificationKind === COMPLETION_NOTIFICATION_KIND;
+}
+
+// Canonical completion-enqueue tagger. Every deferred tool/agent completion
+// notification MUST be enqueued through this so drain can discard it on resume
+// (never replay out-of-order). Pass the model-visible completion text (or an
+// existing entry); genuine user/steering messages must NOT be tagged.
+export function markCompletionEntry(text) {
+    const value = typeof text === 'string'
+        ? text
+        : (text && typeof text === 'object' ? (text.text || text.content || '') : '');
+    const content = String(value ?? '');
+    return { content, text: content, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Date.now() };
+}
+
 function pendingMessagesPath() {
     return join(resolvePluginData(), PENDING_MESSAGES_FILE);
 }
@@ -53,13 +75,7 @@ function normalizePendingStore(raw) {
         if (!isValidPendingSessionId(sid) || !Array.isArray(value)) continue;
         const q = isTuiSteeringPendingKey(sid)
             ? value.map(normalizeTuiSteeringQueueEntry).filter(Boolean)
-            : value
-                .map((entry) => {
-                    if (typeof entry === 'string') return entry;
-                    if (entry && typeof entry === 'object' && typeof entry.message === 'string') return entry.message;
-                    return '';
-                })
-                .filter(Boolean);
+            : value.map(normalizePersistedEntry).filter(Boolean);
         if (q.length > 0) {
             out.sessions[sid] = q;
             const touched = Number(touchedRaw[sid]);
@@ -85,16 +101,22 @@ function normalizePendingMessageEntry(entry) {
         return { content: entry, text };
     }
     if (!entry || typeof entry !== 'object') return null;
+    const marker = entry.notificationKind === COMPLETION_NOTIFICATION_KIND
+        ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Number(entry.enqueuedAt) || Date.now() }
+        : null;
     const content = Object.prototype.hasOwnProperty.call(entry, 'content') ? entry.content : null;
     if (content == null) return null;
     const text = typeof entry.text === 'string' ? entry.text.trim() : promptContentText(content).trim();
-    if (Array.isArray(content)) return content.length > 0 ? { content, text } : null;
-    if (typeof content === 'string') {
+    let out = null;
+    if (Array.isArray(content)) out = content.length > 0 ? { content, text } : null;
+    else if (typeof content === 'string') {
         const value = content.trim();
-        return value ? { content: value, text: text || value } : null;
+        out = value ? { content: value, text: text || value } : null;
+    } else {
+        const fallback = promptContentText(content).trim();
+        out = fallback ? { content: fallback, text: text || fallback } : null;
     }
-    const fallback = promptContentText(content).trim();
-    return fallback ? { content: fallback, text: text || fallback } : null;
+    return out && marker ? { ...out, ...marker } : out;
 }
 
 function pendingMessageText(entry) {
@@ -105,14 +127,39 @@ function pendingMessageText(entry) {
 function pendingMessageQueueEntry(entry) {
     const normalized = normalizePendingMessageEntry(entry);
     if (!normalized) return null;
-    if (typeof normalized.content === 'string' && normalized.content === normalized.text) return normalized.content;
-    return { content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+    const marker = isCompletionNotificationEntry(normalized)
+        ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: normalized.enqueuedAt }
+        : null;
+    if (typeof normalized.content === 'string' && normalized.content === normalized.text && !marker) return normalized.content;
+    const base = { content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+    return marker ? { ...base, ...marker } : base;
+}
+
+// Canonical persisted-queue entry: a plain string for user/steering messages,
+// or a { message, notificationKind, enqueuedAt } object for completion/task
+// notifications so the marker survives an on-disk round trip. Accepts either an
+// in-memory queue entry (content/text) or an already-persisted entry
+// (string | { message } legacy | marked object); back-compatible with both.
+function normalizePersistedEntry(entry) {
+    if (typeof entry === 'string') { const t = entry.trim(); return t || null; }
+    if (!entry || typeof entry !== 'object') return null;
+    if (isCompletionNotificationEntry(entry)) {
+        const message = (typeof entry.message === 'string' && entry.message.trim())
+            ? entry.message.trim()
+            : pendingMessageText(entry);
+        return message
+            ? { message, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Number(entry.enqueuedAt) || Date.now() }
+            : null;
+    }
+    if (typeof entry.message === 'string') { const t = entry.message.trim(); return t || null; }
+    const t = pendingMessageText(entry);
+    return t || null;
 }
 
 function persistPendingMessages(sessionId, messages) {
     if (!isValidPendingSessionId(sessionId)) return 0;
     const persistedMessages = (Array.isArray(messages) ? messages : [messages])
-        .map(pendingMessageText)
+        .map(normalizePersistedEntry)
         .filter(Boolean);
     if (persistedMessages.length === 0) return 0;
     // Async lock wait: this runs on the lead/TUI main process (tool-exec +
@@ -159,7 +206,7 @@ function flushPendingMessagePersistsSync() {
 
 function schedulePendingMessagePersist(sessionId, message) {
     if (!isValidPendingSessionId(sessionId)) return 0;
-    const persistedMessage = pendingMessageText(message);
+    const persistedMessage = normalizePersistedEntry(message);
     if (!persistedMessage) return 0;
     const q = _pendingPersistBuffers.get(sessionId) || [];
     q.push(persistedMessage);
@@ -192,7 +239,7 @@ function drainPersistedPendingMessages(sessionId) {
         updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
             const next = normalizePendingStore(raw);
             const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-            drained = q.filter((m) => typeof m === 'string' && m.length > 0);
+            drained = q.filter((m) => (typeof m === 'string' && m.length > 0) || isCompletionNotificationEntry(m));
             if (drained.length === 0) return undefined;
             delete next.sessions[sessionId];
             if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
@@ -335,8 +382,13 @@ export function drainPendingMessages(sessionId) {
     // first. Reversing this order (buffer before disk) delivered newer
     // buffered sends ahead of older persisted ones after a restart.
     const persisted = [...drainPersistedPendingMessages(sessionId), ...takeBufferedPendingMessages(sessionId)];
-    const memoryVisible = modelVisiblePendingMessages(memory);
-    const persistedVisible = modelVisiblePendingMessages(persisted);
+    // Discard deferred completion/task notifications instead of injecting them
+    // out-of-order into a future turn on resume. Genuine user/steering messages
+    // (plain strings / content entries) carry no marker and are kept in order.
+    const memoryKept = memory.filter((m) => !isCompletionNotificationEntry(m));
+    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m));
+    const memoryVisible = modelVisiblePendingMessages(memoryKept);
+    const persistedVisible = modelVisiblePendingMessages(persistedKept);
     if (memoryVisible.length === 0) return persistedVisible;
     if (persistedVisible.length === 0) return memoryVisible;
     const persistedTexts = persistedVisible.map(pendingMessageText);

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

@@ -63,6 +63,8 @@ export {
     _mergePendingMessageEntries,
     enqueuePendingMessage,
     drainPendingMessages,
+    markCompletionEntry,
+    COMPLETION_NOTIFICATION_KIND,
 } from './manager/pending-messages.mjs';
 export { isInternalRuntimeNotificationText as _isInternalRuntimeNotificationText } from './manager/prompt-utils.mjs';
 

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

@@ -212,10 +212,10 @@ export async function addCore(dataDir, { element, summary, category }, projectId
   const sm = trimOrNull(summary) ?? el
   if (!el || !sm) throw new Error('add requires element and summary')
   if (el.length > CORE_ELEMENT_MAX) {
-    throw new Error(`core element too long (${el.length} chars, max ${CORE_ELEMENT_MAX}) — element is a short key/title, not content.`)
+    throw new Error(`core element too long (${el.length}/${CORE_ELEMENT_MAX} chars, remove ${el.length - CORE_ELEMENT_MAX}) — element is a short key/title, not content.`)
   }
   if (sm.length > CORE_SUMMARY_MAX) {
-    throw new Error(`core summary too long (${sm.length} chars, max ${CORE_SUMMARY_MAX}) — core memory must be 1 fact in 1-2 sentences; procedures, multi-step, or code belong in recap or docs. Compress and retry.`)
+    throw new Error(`core summary too long (${sm.length}/${CORE_SUMMARY_MAX} chars, remove ${sm.length - CORE_SUMMARY_MAX}) — 1 fact in 1-2 sentences; move procedures/multi-step/code to recap or docs.`)
   }
   const cat = (trimOrNull(category) ?? 'fact').toLowerCase()
   if (!VALID_CAT.has(cat)) {
@@ -310,7 +310,7 @@ export async function editCore(dataDir, id, patch) {
     throw new Error('no change')
   }
   if (newSummary && newSummary.length > CORE_SUMMARY_MAX) {
-    throw new Error(`core summary too long (${newSummary.length} chars, max ${CORE_SUMMARY_MAX}) — core memory must be 1 fact in 1-2 sentences; procedures, multi-step, or code belong in recap or docs. Compress and retry.`)
+    throw new Error(`core summary too long (${newSummary.length}/${CORE_SUMMARY_MAX} chars, remove ${newSummary.length - CORE_SUMMARY_MAX}) — 1 fact in 1-2 sentences; move procedures/multi-step/code to recap or docs.`)
   }
   const now = Date.now()
   const textChanged = newElement !== cur.element || newSummary !== cur.summary

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

@@ -1,6 +1,6 @@
 'use strict';
 
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { detachedSpawnOpts } from './spawn-flags.mjs';
 
 function positiveInt(value) {
@@ -8,64 +8,12 @@ function positiveInt(value) {
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
-// On Windows a windowless, orphaned pwsh->cli chain keeps the immediate parent
-// PID alive after its terminal window is closed, so parent-liveness alone never
-// releases the worker. When the session is genuinely interactive (a TTY), the
-// controlling console window is owned by a host process (conhost.exe) that dies
-// with the terminal — monitoring that PID turns "terminal closed" into a fatal
-// orphan signal. Returns null for non-interactive/service/hidden-console starts
-// (no TTY, or no console window) so those are never treated as terminal loss.
-function detectControllingTerminalPid() {
-  if (process.platform !== 'win32') return null;
-  // Gate on a real TTY: a service/pipe/hidden launch has no controlling
-  // terminal, and probing one there would spawn a transient console whose host
-  // dies immediately — a false "terminal lost" that would kill a healthy worker.
-  const interactive = Boolean(
-    (process.stdin && process.stdin.isTTY) || (process.stdout && process.stdout.isTTY),
-  );
-  if (!interactive) return null;
-  try {
-    const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
-    const powershell = systemRoot + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
-    const script = [
-      'Add-Type @"',
-      'using System;',
-      'using System.Runtime.InteropServices;',
-      'public class MixdogTerm {',
-      '  [DllImport("kernel32.dll")] public static extern IntPtr GetConsoleWindow();',
-      '  [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr h, out int pid);',
-      '}',
-      '"@',
-      '$h=[MixdogTerm]::GetConsoleWindow()',
-      'if($h -eq [IntPtr]::Zero){ Write-Output 0 } else { $p=0; [void][MixdogTerm]::GetWindowThreadProcessId($h,[ref]$p); Write-Output $p }',
-    ].join('\n');
-    // NO windowsHide: CREATE_NO_WINDOW gives the probe its own/absent console so
-    // GetConsoleWindow() returns 0 or a foreign hwnd. A plain console app spawned
-    // from a console-attached parent (this runs at the guardian start site, in the
-    // guarded parent) inherits that console with no window flash. Under Windows
-    // Terminal/ConPTY the owner is the tab's conhost (dies on tab close), which is
-    // exactly the pid we want to monitor.
-    const res = spawnSync(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], {
-      timeout: 4000,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const pid = positiveInt(String((res && res.stdout) || '').trim());
-    // Ignore our own PID: that would make the guardian its own kill trigger.
-    if (pid && pid !== process.pid) return pid;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-function guardianScript({ parentPid, childPid, childGroupPid, terminalPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
+function guardianScript({ parentPid, childPid, childGroupPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
   return `
 const { spawnSync } = require('node:child_process');
 const parentPid = ${JSON.stringify(parentPid)};
 const childPid = ${JSON.stringify(childPid)};
 const childGroupPid = ${JSON.stringify(childGroupPid || childPid)};
-const terminalPid = ${JSON.stringify(terminalPid || 0)};
 const platform = ${JSON.stringify(platform)};
 const pollMs = ${JSON.stringify(pollMs)};
 const orphanGraceMs = ${JSON.stringify(orphanGraceMs)};
@@ -95,12 +43,10 @@ let killing = false;
 let orphanedAt = 0;
 const timer = setInterval(() => {
   if (!alive(childPid)) process.exit(0);
-  // Orphaned when the parent PID dies OR (interactive only) the controlling
-  // terminal's console host dies — the latter catches a windowless pwsh->cli
-  // chain that outlives its closed terminal window. terminalPid is 0 for
-  // non-interactive starts, so those fall back to pure parent-liveness.
-  const terminalLost = terminalPid > 0 && !alive(terminalPid);
-  if (alive(parentPid) && !terminalLost) {
+  // Orphaned when the parent PID dies. Matches Claude Code / pi: no console
+  // probe — a hidden shell spawn (windowsHide) plus tree-kill on cleanup, so
+  // orphan detection is pure parent-liveness.
+  if (alive(parentPid)) {
     orphanedAt = 0;
     return;
   }
@@ -135,7 +81,6 @@ export function startChildGuardian({
         parentPid: parent,
         childPid: child,
         childGroupPid: positiveInt(childGroupPid) || child,
-        terminalPid: detectControllingTerminalPid() || 0,
         platform: process.platform,
         pollMs: Math.max(100, Math.floor(Number(pollMs) || 750)),
         orphanGraceMs: Math.max(100, Math.floor(Number(orphanGraceMs) || Number(graceMs) || 3000)),

package/src/session-runtime/runtime-core.mjs

@@ -31,6 +31,7 @@ import {
 } from '../runtime/shared/markdown-frontmatter.mjs';
 import { setConfiguredShell } from '../runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs';
 import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { markCompletionEntry } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import {
   beginOAuthProviderLogin,
   forgetProviderAuth,
@@ -773,7 +774,9 @@ export async function createMixdogSessionRuntime({
         && shouldPersistModelVisibleToolCompletion(text, meta)) {
         try {
           const visible = modelVisibleToolCompletionMessage(text, meta);
-          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+          // Terminal completion (gated by shouldPersistModelVisibleToolCompletion)
+          // → tag so drain discards it on resume rather than replaying out-of-order.
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, markCompletionEntry(visible)) > 0;
         } catch {}
       }
       // Headless/API listeners may exist but not consume the event; preserve
@@ -782,7 +785,10 @@ export async function createMixdogSessionRuntime({
         && typeof mgr.enqueuePendingMessage === 'function') {
         try {
           const visible = modelVisibleToolCompletionMessage(text, meta);
-          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+          // modelVisibleToolCompletionMessage only returns non-empty for a
+          // persistable terminal completion, so this fallback is a completion
+          // too → tag it (genuine non-completion notifications yield '' above).
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, markCompletionEntry(visible)) > 0;
         } catch {}
       }
       return enqueued || handledByRuntimeListener;

package/src/standalone/agent-tool/notify.mjs

@@ -3,6 +3,7 @@
 // Behavior-preserving: bodies identical to the originals; deps injected.
 import { modelVisibleToolCompletionMessage } from '../../runtime/shared/tool-execution-contract.mjs';
 import { renderBackgroundTask, sanitizeTaskMeta, setBackgroundTaskEnqueueFallback } from '../../runtime/shared/background-tasks.mjs';
+import { markCompletionEntry } from '../../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import { clean } from './helpers.mjs';
 
 export function createNotify(mgr) {
@@ -11,7 +12,10 @@ export function createNotify(mgr) {
     if (!target || typeof mgr.enqueuePendingMessage !== 'function') return false;
     try {
       const visible = modelVisibleToolCompletionMessage(text, meta);
-      return Boolean(visible && mgr.enqueuePendingMessage(target, visible) > 0);
+      if (!visible) return false;
+      // Mark this as a deferred completion/task notification so a later session
+      // resume drops it rather than replaying it out-of-order (owner decision).
+      return Boolean(mgr.enqueuePendingMessage(target, markCompletionEntry(visible)) > 0);
     } catch {
       return false;
     }

package/src/tui/dist/index.mjs

@@ -23060,7 +23060,9 @@ function createAgentJobFeed({
   pushNotice
 }) {
   let executionResumeKickDeferred = false;
-  function kickExecutionPendingResume() {
+  const executionResumeKickBodies = [];
+  function kickExecutionPendingResume(body = "") {
+    if (body) executionResumeKickBodies.push(body);
     if (getDisposed()) return;
     if (getState().busy) {
       executionResumeKickDeferred = true;
@@ -23072,15 +23074,16 @@ function createAgentJobFeed({
       return;
     }
     executionResumeKickDeferred = false;
-    pending.push(makeQueueEntry("", { mode: "pending-resume", priority: "next" }));
+    const resumeBody = executionResumeKickBodies.splice(0).filter(Boolean).join("\n\n");
+    pending.push(makeQueueEntry(resumeBody, { mode: "pending-resume", priority: "next" }));
     void drain();
   }
   function flushDeferredExecutionPendingResumeKick() {
     if (!executionResumeKickDeferred || getDisposed() || getState().busy) return;
     kickExecutionPendingResume();
   }
-  function scheduleExecutionPendingResumeKick() {
-    queueMicrotask(() => kickExecutionPendingResume());
+  function scheduleExecutionPendingResumeKick(body = "") {
+    queueMicrotask(() => kickExecutionPendingResume(body));
   }
   function updateAgentJobCard(itemId, text, isError = false) {
     const parsed = parseAgentJob(text);
@@ -23120,8 +23123,9 @@ function createAgentJobFeed({
           pushUserOrSyntheticItem(delivery.displayText, nextId2());
         }
         if (parsed?.taskId) set(agentStatusState({ force: true }));
-        if (String(delivery.modelContent || "").trim()) {
-          scheduleExecutionPendingResumeKick();
+        const resumeBody = String(delivery.modelContent || "").trim();
+        if (resumeBody) {
+          scheduleExecutionPendingResumeKick(resumeBody);
         }
         return true;
       }
@@ -23994,6 +23998,7 @@ function createRunTurn(bag) {
         flags.activePromptRestore = null;
         if (flags.draining) flags.draining = false;
         if (pending.length > 0) void drain();
+        flushDeferredExecutionPendingResumeKick();
       }, 5e3);
       watchdogGraceTimer.unref?.();
     }, LEAD_TURN_TIMEOUT_MS2);
@@ -24697,6 +24702,7 @@ function createRunTurn(bag) {
       if (isStaleUnwind) {
         if (closingItems.length) appendItemsBatch(closingItems);
         tuiDebug2(`runTurn STALE UNWIND turn=${turnIndex} \u2014 force-released; skipping shared-getState() writes`);
+        flushDeferredExecutionPendingResumeKick();
       } else {
         if (!isNoOpTurn) {
           getState().stats.turns = (getState().stats.turns || 0) + 1;

package/src/tui/engine/agent-job-feed.mjs

@@ -56,7 +56,14 @@ export function createAgentJobFeed({
 }) {
   let executionResumeKickDeferred = false;
 
-  function kickExecutionPendingResume() {
+  // FIFO accumulation of model-visible bodies from completions that arrived
+  // while busy (or while a pending-resume entry was already queued). A single
+  // string slot dropped all-but-the-last body when parallel completions landed;
+  // the queue preserves every body and merges them into the resume turn.
+  const executionResumeKickBodies = [];
+
+  function kickExecutionPendingResume(body = '') {
+    if (body) executionResumeKickBodies.push(body);
     if (getDisposed()) return;
     if (getState().busy) {
       executionResumeKickDeferred = true;
@@ -68,7 +75,10 @@ export function createAgentJobFeed({
       return;
     }
     executionResumeKickDeferred = false;
-    pending.push(makeQueueEntry('', { mode: 'pending-resume', priority: 'next' }));
+    // Drain every accumulated body into ONE resume turn so no completion body
+    // is lost when several deferred while busy.
+    const resumeBody = executionResumeKickBodies.splice(0).filter(Boolean).join('\n\n');
+    pending.push(makeQueueEntry(resumeBody, { mode: 'pending-resume', priority: 'next' }));
     void drain();
   }
 
@@ -77,10 +87,11 @@ export function createAgentJobFeed({
     kickExecutionPendingResume();
   }
 
-  function scheduleExecutionPendingResumeKick() {
-    // notifyFnForSession enqueues the model-visible body after onNotification
-    // returns; defer the kick so askSession pre-drain sees session pending.
-    queueMicrotask(() => kickExecutionPendingResume());
+  function scheduleExecutionPendingResumeKick(body = '') {
+    // Carry the model-visible body directly into the pending-resume entry so
+    // the resumed turn sends it, instead of relying on the session-pending
+    // completion marker (dropped by askSession pre-drain).
+    queueMicrotask(() => kickExecutionPendingResume(body));
   }
 
   function updateAgentJobCard(itemId, text, isError = false) {
@@ -122,8 +133,9 @@ export function createAgentJobFeed({
           pushUserOrSyntheticItem(delivery.displayText, nextId());
         }
         if (parsed?.taskId) set(agentStatusState({ force: true }));
-        if (String(delivery.modelContent || '').trim()) {
-          scheduleExecutionPendingResumeKick();
+        const resumeBody = String(delivery.modelContent || '').trim();
+        if (resumeBody) {
+          scheduleExecutionPendingResumeKick(resumeBody);
         }
         return true;
       }

package/src/tui/engine/turn.mjs

@@ -84,6 +84,10 @@ export function createRunTurn(bag) {
         flags.activePromptRestore = null;
         if (flags.draining) flags.draining = false;
         if (pending.length > 0) void drain();
+        // busy→false here bypasses both the normal turn-end flush and the
+        // drain-finally flush, so a deferred completion kick would never re-arm.
+        // Fire it explicitly (idempotent: guarded by deferred flag + !busy).
+        flushDeferredExecutionPendingResumeKick();
       }, 5_000);
       watchdogGraceTimer.unref?.();
     }, LEAD_TURN_TIMEOUT_MS);
@@ -1048,6 +1052,10 @@ export function createRunTurn(bag) {
         // deferred cards (turn-local teardown) but writes no other shared getState().
         if (closingItems.length) appendItemsBatch(closingItems);
         tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared-getState() writes`);
+        // A stale unwind settles busy→false (via the watchdog release) without
+        // the normal turn-end flush, so re-arm any deferred completion kick here
+        // too (idempotent: no-ops unless a kick is deferred and nothing is busy).
+        flushDeferredExecutionPendingResumeKick();
       } else {
       if (!isNoOpTurn) {
         getState().stats.turns = (getState().stats.turns || 0) + 1;