mixdog 0.9.30 → 0.9.32

package/package.json

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

package/scripts/arg-guard-test.mjs

@@ -28,6 +28,15 @@ test('grep head_limit/offset/-C as numeric strings coerce', () => {
     assert.equal(a['-C'], 2);
 });
 
+test('grep empty context strings are treated as omitted', () => {
+    const a = { pattern: 'x', output_mode: 'content_with_context', '-A': '', '-B': '', '-C': '', context: '' };
+    assert.equal(validateBuiltinArgs('grep', a), null);
+    assert.equal(Object.prototype.hasOwnProperty.call(a, '-A'), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(a, '-B'), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(a, '-C'), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(a, 'context'), false);
+});
+
 test('list/find/glob head_limit as numeric string coerces', () => {
     const l = { path: '.', head_limit: '5' };
     assert.equal(validateBuiltinArgs('list', l), null);

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/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -399,6 +399,10 @@ function guardGrep(a) {
         if (err) return err;
     }
     for (const k of ['-A', '-B', '-C', 'context']) {
+        if (hasOwn(a, k) && a[k] === '') {
+            delete a[k];
+            continue;
+        }
         const err = checkIntInRange(a, k, 0, GREP_CONTEXT_MAX, { clamp: true });
         if (err) return err;
     }

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/memory/lib/pg/process.mjs

@@ -290,12 +290,15 @@ export async function startPg({ runtimeDir, pgdataDir, port: preferredPort = 554
   // so we return the instant pg_isready succeeds rather than waiting on pg_ctl.
   // Only the long-lived child handle is unref'd; poll timers stay ref'd.
   async function startAndWaitReady() {
-    // detached on win32: give pg_ctl (and the postmaster it spawns) its own
-    // process group / console so an ancestor `taskkill /F /T` cannot enumerate
-    // it via the Node process tree. The orphaned postmaster survives and is
-    // re-adopted next boot via supervisor tryReusePgInstance (postmaster.pid).
-    const detached = process.platform === 'win32'
-    const child = spawn(pgctl, startArgs, { env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, detached })
+    // NEVER set `detached` on win32: DETACHED_PROCESS makes the OS ignore
+    // `windowsHide`, so pg_ctl + the postmaster it launches allocate a VISIBLE
+    // console (see shared/spawn-flags.mjs). Detachment gave no real isolation
+    // here anyway: `pg_ctl start` daemonizes the postmaster and exits at once,
+    // so the postmaster is already reparented OUT of the Node process tree —
+    // detached only isolated the short-lived pg_ctl. Shutdown/reuse target
+    // pgdata/postmaster.pid (pg_ctl stop -D, tryReusePgInstance), not a
+    // Node-tree taskkill, so `windowsHide` alone is correct on all platforms.
+    const child = spawn(pgctl, startArgs, { env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
     child.unref?.()
     let stdout = '', stderr = '', closed = false, exitCode = null
     child.stdout?.on('data', d => { stdout += d.toString() })

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;