mixdog 0.9.26 → 0.9.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.26",
+  "version": "0.9.28",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -29,6 +29,7 @@
     "!scripts/bench/",
     "!scripts/recall-bench-*.txt",
     "src/",
+    "!src/tui/dev",
     "vendor/"
   ],
   "scripts": {
@@ -48,6 +49,7 @@
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "smoke:logguard": "node scripts/log-writer-guard-smoke.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
+    "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
@@ -61,7 +63,10 @@
     "bench:recall": "node scripts/recall-bench.mjs",
     "audit:models": "node scripts/model-catalog-audit.mjs",
     "patch:replay": "node scripts/patch-replay.mjs",
-    "build:tui": "node scripts/build-tui.mjs"
+    "build:tui": "node scripts/build-tui.mjs",
+    "release:patch": "npm run smoke && npm version patch -m \"mixdog v%s\" && git push --follow-tags origin main",
+    "release:minor": "npm run smoke && npm version minor -m \"mixdog v%s\" && git push --follow-tags origin main",
+    "release:major": "npm run smoke && npm version major -m \"mixdog v%s\" && git push --follow-tags origin main"
   },
   "engines": {
     "node": ">=22.0.0"

package/scripts/arg-guard-test.mjs

@@ -0,0 +1,68 @@
+// Regression tests for validateBuiltinArgs numeric coercion + over-max clamp:
+// - integer-shaped strings ("5") coerce to numbers instead of erroring
+// - over-max integers clamp to the cap instead of erroring
+// - truly non-numeric / below-min input keeps the existing error
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
+
+test('read offset/limit as numeric strings coerce to numbers', () => {
+    const a = { path: 'x.mjs', offset: '5', limit: '40' };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.offset, 5);
+    assert.equal(a.limit, 40);
+});
+
+test('read line/context as numeric strings coerce and window', () => {
+    const a = { path: 'x.mjs', line: '100', context: '5' };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.offset, 94);
+    assert.equal(a.limit, 11);
+});
+
+test('grep head_limit/offset/-C as numeric strings coerce', () => {
+    const a = { pattern: 'x', head_limit: '3', offset: '10', '-C': '2' };
+    assert.equal(validateBuiltinArgs('grep', a), null);
+    assert.equal(a.head_limit, 3);
+    assert.equal(a.offset, 10);
+    assert.equal(a['-C'], 2);
+});
+
+test('list/find/glob head_limit as numeric string coerces', () => {
+    const l = { path: '.', head_limit: '5' };
+    assert.equal(validateBuiltinArgs('list', l), null);
+    assert.equal(l.head_limit, 5);
+    const f = { query: 'x', head_limit: '5' };
+    assert.equal(validateBuiltinArgs('find', f), null);
+    assert.equal(f.head_limit, 5);
+    const g = { pattern: '*.mjs', head_limit: '5' };
+    assert.equal(validateBuiltinArgs('glob', g), null);
+    assert.equal(g.head_limit, 5);
+});
+
+test('over-max integer clamps to the cap instead of erroring', () => {
+    // read n cap is 0..10000; a huge value clamps down instead of erroring.
+    const a = { path: 'x.mjs', n: 999999999 };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.n, 10000);
+});
+
+test('over-max numeric-string clamps too', () => {
+    const a = { path: 'x.mjs', n: '999999999' };
+    assert.equal(validateBuiltinArgs('read', a), null);
+    assert.equal(a.n, 10000);
+});
+
+test('non-numeric string still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: 'soon' }), /must be an integer/);
+    assert.match(validateBuiltinArgs('list', { path: '.', head_limit: 'soon' }), /finite integer/);
+});
+
+test('below-min (negative) still errors', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', offset: -1 }), /must be >= 0/);
+    assert.match(validateBuiltinArgs('list', { path: '.', head_limit: '-2' }), /must be >= 0/);
+});
+
+test('fractional numeric string is not coerced (still errors)', () => {
+    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: '3.5' }), /must be an integer/);
+});

package/scripts/compacted-placeholder-scrub-test.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Regression test for the pre-send compacted-placeholder invariant: no
+// provider-visible assistant toolCall may ship a `[mixdog compacted …]`
+// placeholder body that the model could copy back as apply_patch input.
+// scrubCompactedPlaceholderToolCalls is the single enforcement point invoked
+// by repairTranscriptBeforeProviderSend right before provider.send.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    compactToolCallsForHistory,
+    scrubCompactedPlaceholderToolCalls,
+} from '../src/runtime/agent/orchestrator/session/loop/stored-tool-args.mjs';
+import { repairTranscriptBeforeProviderSend } from '../src/runtime/agent/orchestrator/session/loop/transcript-repair.mjs';
+
+// A patch body longer than the body limit compacts to a marker-alone string.
+const BIG_PATCH = '*** Begin Patch\n' + '+x\n'.repeat(2000) + '*** End Patch';
+
+function assistantWithCompactedPatch(id = 'call_1') {
+    const calls = [{ id, name: 'apply_patch', arguments: { patch: BIG_PATCH, base_path: '/repo' } }];
+    return { role: 'assistant', content: '', toolCalls: compactToolCallsForHistory(calls) };
+}
+
+test('compact leaves a placeholder patch body (precondition)', () => {
+    const msg = assistantWithCompactedPatch();
+    assert.match(msg.toolCalls[0].arguments.patch, /^\[mixdog compacted /);
+    assert.equal(msg.toolCalls[0].arguments.base_path, '/repo');
+});
+
+test('scrub drops the placeholder patch key, keeps other args', () => {
+    const msg = assistantWithCompactedPatch();
+    scrubCompactedPlaceholderToolCalls([msg]);
+    assert.equal('patch' in msg.toolCalls[0].arguments, false);
+    assert.equal(msg.toolCalls[0].arguments.base_path, '/repo');
+});
+
+test('scrub is recursive across nested batch body args', () => {
+    const calls = [{
+        id: 'call_2', name: 'edit',
+        arguments: { edits: [{ path: 'a.js', old_string: BIG_PATCH, new_string: 'ok' }] },
+    }];
+    const msg = { role: 'assistant', content: '', toolCalls: compactToolCallsForHistory(calls) };
+    assert.match(msg.toolCalls[0].arguments.edits[0].old_string, /^\[mixdog compacted /);
+    scrubCompactedPlaceholderToolCalls([msg]);
+    const edit = msg.toolCalls[0].arguments.edits[0];
+    assert.equal('old_string' in edit, false);
+    assert.equal(edit.path, 'a.js');
+    assert.equal(edit.new_string, 'ok');
+});
+
+test('scrub leaves real (restored) patch bodies untouched', () => {
+    const real = '*** Begin Patch\n@@\n-a\n+b\n*** End Patch';
+    const msg = { role: 'assistant', content: '', toolCalls: [
+        { id: 'call_3', name: 'apply_patch', arguments: { patch: real } },
+    ] };
+    scrubCompactedPlaceholderToolCalls([msg]);
+    assert.equal(msg.toolCalls[0].arguments.patch, real);
+});
+
+test('scrub ignores non-assistant / non-toolCall messages', () => {
+    const msgs = [
+        { role: 'user', content: 'hi' },
+        { role: 'tool', content: 'x', toolCallId: 'call_1' },
+        { role: 'assistant', content: 'text only' },
+    ];
+    assert.doesNotThrow(() => scrubCompactedPlaceholderToolCalls(msgs));
+});
+
+test('repairTranscriptBeforeProviderSend enforces the invariant end-to-end', () => {
+    const msgs = [
+        { role: 'user', content: 'do it' },
+        assistantWithCompactedPatch('call_9'),
+        { role: 'tool', content: 'applied', toolCallId: 'call_9' },
+    ];
+    repairTranscriptBeforeProviderSend(msgs, null);
+    const asst = msgs.find((m) => m.role === 'assistant');
+    assert.equal('patch' in asst.toolCalls[0].arguments, false);
+});

package/src/app.mjs

@@ -166,6 +166,20 @@ export async function run(argv = []) {
   }
 
   // Default: the canonical React/Ink TUI over the mixdog session runtime.
+  // DEV convenience (opt-in via MIXDOG_TUI_DEV): rebuild the JSX bundle from
+  // source before launch so local edits reflect without a manual build. The
+  // dev module is excluded from the published package ("files" negation) and
+  // esbuild is a devDependency, so this is a no-op fallback on any install.
+  if (process.env.MIXDOG_TUI_DEV) {
+    try {
+      const { rebuildTuiFromSource } = await import('./tui/dev/jit-rebuild.mjs');
+      await rebuildTuiFromSource();
+    } catch (err) {
+      if (process.env.MIXDOG_TUI_DEV_VERBOSE) {
+        process.stderr.write(`mixdog[tui-dev]: rebuild skipped — ${err?.message ?? err}\n`);
+      }
+    }
+  }
   const bundle = join(__dirname, 'tui', 'dist', 'index.mjs');
   if (!existsSync(bundle)) {
     process.stderr.write(

package/src/cli.mjs

@@ -1,10 +1,46 @@
 #!/usr/bin/env node
 
-import { run } from './app.mjs';
+import { fileURLToPath } from 'node:url';
+import { performPendingSwap, registerLiveSession } from './runtime/shared/staged-update.mjs';
 
-run(process.argv.slice(2)).then((code) => {
-  const exitCode = Number.isInteger(code) ? code : 0;
-  process.exit(exitCode);
+const argv = process.argv.slice(2);
+
+// Pre-import self-update swap: BEFORE any runtime module is imported, if a
+// completed staged newer version exists and no other mixdog session is live,
+// atomically swap the global package dir into place. Doing it here (and only
+// here) means the process goes on to load the NEW files, and a live session
+// never has its files overwritten mid-run. Any obstacle → false, run current.
+let swapped = false;
+try { swapped = performPendingSwap(); } catch { swapped = false; }
+
+// Register this process in the live-session refcount BEFORE any runtime module
+// loads, so a concurrently-launching mixdog's liveness check can see us and
+// defer its own swap. Unregister is hooked on process 'exit' (and on graceful
+// close). Harmless for the swap decision above — our own pid is excluded.
+try { registerLiveSession(); } catch { /* advisory refcount only */ }
+
+async function main() {
+  // If we actually swapped, re-exec a fresh node process so the new package
+  // loads with a clean module cache (no stale pre-swap modules mixed in). The
+  // env guard prevents re-swap / relaunch loops. Foreground + inherited stdio
+  // keeps the interactive TUI intact. Best-effort: if the re-exec spawn fails,
+  // fall through and run in-place.
+  if (swapped && !process.env.MIXDOG_SWAP_REEXEC) {
+    try {
+      const { spawnSync } = await import('node:child_process');
+      const r = spawnSync(process.execPath, [fileURLToPath(import.meta.url), ...argv], {
+        stdio: 'inherit',
+        env: { ...process.env, MIXDOG_SWAP_REEXEC: '1' },
+      });
+      if (!r.error) return Number.isInteger(r.status) ? r.status : 0;
+    } catch { /* fall through to in-place run */ }
+  }
+  const { run } = await import('./app.mjs');
+  return await run(argv);
+}
+
+main().then((code) => {
+  process.exit(Number.isInteger(code) ? code : 0);
 }).catch((error) => {
   process.stderr.write(`${error?.stack || error?.message || String(error)}\n`);
   process.exit(1);

package/src/rules/shared/01-tool.md

@@ -36,3 +36,6 @@
 - Don't mix `apply_patch` with shell or other state-changing calls in one
   turn; batch independent-file patches in one turn, then verify them all in
   ONE shell call the next.
+- Consecutive single `shell` or `apply_patch` turns are a batching miss
+  unless output-dependent: chain shell commands with `;`/`&&` or call in
+  parallel; put all known edits in ONE patch.

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -349,7 +349,9 @@ export function traceAgentBatch({ sessionId, toolCallCount }) {
     appendAgentTrace({
         sessionId,
         kind: 'batch',
-        tool_call_count: toolCallCount,
+        // trace_events has no tool_call_count column — top-level unknown
+        // fields are dropped at insert time, so carry it in payload (jsonb).
+        payload: { tool_call_count: toolCallCount },
     });
 }
 

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

@@ -151,3 +151,33 @@ export function dropCompactedBodyArgsForId(assistantMsg, callId) {
     if (!tc || !tc.arguments || typeof tc.arguments !== 'object') return;
     tc.arguments = _dropCompactedPlaceholders(tc.arguments);
 }
+
+// PRE-SEND INVARIANT. The per-call paths above run during tool-batch
+// processing: a SUCCESS drops its placeholder body (dropCompactedBodyArgsForId),
+// a FAILURE restores the full original (restoreToolCallBodyForId). But those are
+// gated per call id and several loop paths never reach them — dedup /
+// repeat-failure early-continue, the iteration-cap refusal stub, or a call whose
+// id never matched. Any of those can leave a `[mixdog compacted …]` placeholder
+// sitting in a provider-visible assistant toolCall, which the model then copies
+// back verbatim as new apply_patch input. Enforce the invariant once, right
+// before provider.send: sweep EVERY assistant toolCall arguments tree and drop
+// any placeholder-valued key at any depth (batch shapes like edits[].old_string
+// carry nested compacted bodies too).
+//
+// This does NOT re-inline full bodies, so it never raises history token cost. A
+// failed call whose body was restored upstream holds real patch content (it no
+// longer starts with the compacted marker), so the sweep leaves it untouched —
+// the full body stays available exactly where the failed call needs it. The
+// downstream apply_patch guard (isCompactedPlaceholderPatch) remains as a
+// backstop for any placeholder a model synthesizes from prose.
+export function scrubCompactedPlaceholderToolCalls(messages) {
+    if (!Array.isArray(messages)) return messages;
+    for (const msg of messages) {
+        if (!msg || msg.role !== 'assistant' || !Array.isArray(msg.toolCalls)) continue;
+        for (const tc of msg.toolCalls) {
+            if (!tc || !tc.arguments || typeof tc.arguments !== 'object') continue;
+            tc.arguments = _dropCompactedPlaceholders(tc.arguments);
+        }
+    }
+    return messages;
+}

package/src/runtime/agent/orchestrator/session/loop/transcript-repair.mjs

@@ -5,6 +5,7 @@
 // strip any trailing/orphaned tool_use|tool_result so provider.send sees a
 // valid transcript instead of leaking the 400 to the user.
 import { sanitizeToolPairs } from '../context-utils.mjs';
+import { scrubCompactedPlaceholderToolCalls } from './stored-tool-args.mjs';
 
 // Transcript pairing guard. Anthropic 400-rejects when an assistant message
 // ends with tool_use blocks and the next message isn't tool results for
@@ -97,5 +98,9 @@ export function repairTranscriptBeforeProviderSend(messages, sessionId = null) {
         messages.push(...sanitized);
     }
     _ensureTranscriptPairing(messages, sessionId);
+    // Pre-send invariant: no provider-visible assistant toolCall may carry a
+    // compacted `[mixdog compacted …]` placeholder body that looks like
+    // submittable patch input. Runs after pairing repair, still before send.
+    scrubCompactedPlaceholderToolCalls(messages);
     return messages;
 }

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -278,9 +278,16 @@ function checkIntInRange(a, field, min, max, opts = {}) {
     if (value < min) {
         return `Error: builtin arg "${field}" must be >= ${min} (got ${value})`;
     }
+    // Over-max is clamped to the cap instead of erroring: an over-large
+    // integer is an unambiguous "as much as allowed" request, not a shape
+    // violation worth a retry turn (mirrors the soft-cap clamp above).
+    // Under-min still errors — a negative where >=0 is required is a real
+    // mistake, not a saturating intent.
     if (value > max) {
-        return `Error: builtin arg "${field}" must be <= ${max} (got ${value})`;
+        a[field] = max;
+        return null;
     }
+    a[field] = value;
     return null;
 }
 
@@ -670,6 +677,8 @@ function guardList(a) {
         return `Error: list arg "pattern" must be string or string[] (got ${describeType(a.pattern)})`;
     }
     if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
+        const coerced = coerceIntegerString(a.head_limit);
+        if (coerced !== null) a.head_limit = coerced;
         if (!isFiniteInt(a.head_limit)) {
             return `Error: list arg "head_limit" must be a finite integer (got ${describeType(a.head_limit)})`;
         }
@@ -695,6 +704,8 @@ function guardFind(a) {
         return `Error: find arg "path" must be a string (got ${describeType(a.path)})`;
     }
     if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
+        const coerced = coerceIntegerString(a.head_limit);
+        if (coerced !== null) a.head_limit = coerced;
         if (!isFiniteInt(a.head_limit)) {
             return `Error: find arg "head_limit" must be a finite integer (got ${describeType(a.head_limit)})`;
         }
@@ -734,6 +745,8 @@ function guardGlob(a) {
         }
     }
     if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
+        const coerced = coerceIntegerString(a.head_limit);
+        if (coerced !== null) a.head_limit = coerced;
         if (!isFiniteInt(a.head_limit)) {
             return `Error: glob arg "head_limit" must be a finite integer (got ${describeType(a.head_limit)})`;
         }

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -67,7 +67,7 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run programs or change system state. Set shell: powershell or bash. Not for reading, listing, or searching files. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: `Run programs or change system state. Set shell: powershell or bash. Not for reading, listing, or searching files. Batch independent commands: ;/&& in one call, or parallel calls in the same turn. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -9,7 +9,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
       properties: {
         mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local graph operation.' },
         files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file(s); array fans out per file. `file` alias too.' },
-        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s); array batches in one call. `symbol` alias too.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s); array batches in one call. `symbol` alias too. Required for callers/callees/references/find_symbol/symbol_search.' },
         symbol: { type: 'string', description: 'Singular alias for symbols.' },
         file: { type: 'string', description: 'Singular alias for files.' },
         body: { type: 'boolean', description: 'Include body.' },

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -26,7 +26,7 @@ export const PATCH_TOOL_DEFS = [
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Apply file patches. Prefer V4A envelope with exact current context.',
+    description: 'Apply file patches. Prefer V4A envelope with exact current context. Batch independent edits into ONE patch (multiple file blocks).',
     freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',

package/src/runtime/memory/tool-defs.mjs

@@ -15,8 +15,8 @@ export const TOOL_DEFS = [
         action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
         op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
         id: { type: 'number', description: 'Exact memory id.' },
-        element: { type: 'string', description: 'Memory key/title.' },
-        summary: { type: 'string', description: 'Memory content.' },
+        element: { type: 'string', description: 'Memory key/title. Max 40 chars.' },
+        summary: { type: 'string', description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
         category: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'], description: 'Category.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
@@ -30,7 +30,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history. Use only to check prior conversation or past events: resumes, prior work, earlier decisions or messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" for previous conversation; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history. Call when a task ties to prior work — resumes, continuations, or references to earlier decisions/messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" for previous conversation; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {

package/src/runtime/shared/staged-install-worker.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * staged-install-worker.mjs — detached background entry for staging a mixdog
+ * self-update. Spawned (shell-less, hidden) by spawnStagedInstall() so the
+ * npm install + relocate + verify + marker-write survive the launching session
+ * quitting mid-install. Does its work and exits; the swap happens on a later
+ * clean launch via performPendingSwap().
+ */
+import { runStagedInstall } from './staged-update.mjs';
+
+const version = process.argv[2] || process.env.MIXDOG_STAGE_VERSION || '';
+runStagedInstall(version)
+  .then((r) => process.exit(r?.ok || r?.alreadyStaged || r?.inProgress ? 0 : 1))
+  .catch(() => process.exit(1));