mixdog 0.9.41 → 0.9.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.41",
+  "version": "0.9.44",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -58,8 +58,9 @@
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
+    "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs scripts/maintenance-default-routes-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",

package/scripts/agent-tag-reuse-smoke.mjs

@@ -4,7 +4,6 @@
 // Validates the unified 4-tier spawn dispatch when an explicit tag is pinned:
 //   1) live + idle  -> spawn reuses the existing session (reused:true, send path)
 //   2) live + busy  -> spawn queues the prompt instead of throwing
-//   3) lingering terminal trace (no live session) -> spawn/send error, no respawn
 //   3) lingering terminal trace -> spawn reaps tag; dead-tag send auto-respawns
 //   4) genuinely new tag -> a fresh spawn (no reused/respawned flag)
 //
@@ -32,7 +31,7 @@ process.env.MIXDOG_AGENT_SPAWN_PREP_TIMEOUT_MS = '50';
 // is the authority; shorten only the test clock, not the configured duration.
 process.env.MIXDOG_AGENT_TERMINAL_REAP_MS = '1000';
 const nativeSetTimeout = globalThis.setTimeout;
-globalThis.setTimeout = (callback, ms, ...args) => nativeSetTimeout(callback, ms === 60_000 ? 500 : ms, ...args);
+globalThis.setTimeout = (callback, ms, ...args) => nativeSetTimeout(callback, ms === 60_000 ? 1000 : ms, ...args);
 
 const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
 
@@ -119,7 +118,11 @@ async function waitJob(out, pattern, label, tries = 60, context = ctx) {
   throw new Error(`${label} did not match ${pattern}: ${last}`);
 }
 function sessionForTag(tag) {
-  return listSessions().find((s) => s?.agentTag === tag && !s.closed) || null;
+  for (let i = askLog.length - 1; i >= 0; i -= 1) {
+    const session = getSession(askLog[i].sessionId);
+    if (session?.agentTag === tag && !session.closed) return session;
+  }
+  return null;
 }
 function addPeerTerminalRow(tag, sessionId) {
   const file = join(dataDir, 'agent-workers.json');
@@ -137,6 +140,40 @@ function addPeerTerminalRow(tag, sessionId) {
   };
   writeFileSync(file, JSON.stringify(index));
 }
+function addWorkerRow({
+  tag,
+  sessionId,
+  clientHostPid = ctx.clientHostPid,
+  status = 'idle',
+  updatedAt = new Date().toISOString(),
+  agentName = 'worker',
+}) {
+  const file = join(dataDir, 'agent-workers.json');
+  const index = JSON.parse(readFileSync(file, 'utf8'));
+  index.workers[sessionId] = {
+    tag,
+    sessionId,
+    agent: agentName,
+    provider: 'openai-oauth',
+    status,
+    stage: status,
+    updatedAt,
+    clientHostPid,
+    cwd: root,
+  };
+  writeFileSync(file, JSON.stringify(index));
+}
+function addTombstones(rows) {
+  const file = join(dataDir, 'agent-workers.json');
+  const index = JSON.parse(readFileSync(file, 'utf8'));
+  index.tombstones ||= {};
+  for (const row of rows) index.tombstones[`${row.clientHostPid || 0}:${row.tag}`] = row;
+  writeFileSync(file, JSON.stringify(index));
+}
+function tombstonesForTag(tag) {
+  const index = JSON.parse(readFileSync(join(dataDir, 'agent-workers.json'), 'utf8'));
+  return Object.values(index.tombstones || {}).filter((row) => row.tag === tag);
+}
 function hasWorkerRow(sessionId) {
   const index = JSON.parse(readFileSync(join(dataDir, 'agent-workers.json'), 'utf8'));
   return Boolean(index.workers?.[sessionId]);
@@ -165,8 +202,9 @@ async function main() {
   }, ctx);
   assert(/agent task:/.test(firstOut), `first spawn must return a task: ${firstOut}`);
   assert(!/reused: true/.test(firstOut) && !/respawned/.test(firstOut), `fresh tag must not be flagged reused/respawned: ${firstOut}`);
+  const firstSession = await waitSessionForTag('reviewerA', 'first spawn');
   await waitJob(firstOut, /ack: first review pass/, 'first spawn');
-  const sid = (await waitSessionForTag('reviewerA', 'first spawn')).id;
+  const sid = firstSession.id;
   assert(sid, 'reviewerA session should remain live (idle) within the reap window');
 
   // --- tier 1 (the headline bug): re-spawn the SAME tag while idle+live ---
@@ -204,6 +242,7 @@ async function main() {
     type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'trace reap respawn', cwd: root,
   }, ctx);
   assert(!/^Error:/.test(traceSpawnOut), `terminal-trace spawn must reap and reuse tag: ${traceSpawnOut}`);
+  assert(/respawned: true/.test(traceSpawnOut), `terminal-trace spawn must flag lost context: ${traceSpawnOut}`);
   await waitJob(traceSpawnOut, /ack: trace reap respawn/, 'trace reap spawn');
   assert(hasWorkerRow('sess_peer_trace'), 'terminal-trace reap must preserve a peer terminal row with the same tag');
   removeWorkerRow('sess_peer_trace');
@@ -225,26 +264,57 @@ async function main() {
   await waitJob(timerPeerStart, /ack: timer peer seed/, 'timer peer seed');
   const timerPeerSession = (await waitSessionForTag('timer-peer', 'timer peer seed')).id;
   addPeerTerminalRow('timer-peer', 'sess_peer_timer');
-  await sleep(700);
+  await sleep(1200);
   assert(getSession(timerPeerSession)?.closed, 'terminal timer must reap its local session');
   assert(hasWorkerRow('sess_peer_timer'), 'terminal timer must preserve a peer row with the same tag');
 
-  // Fully reaped tags have no in-memory map or persisted row. Explicit
-  // cold-spawn identity is enough to create a replacement.
+  // Fully reaped tags retain a terminal-scoped tombstone, so send inherits the
+  // prior agent/cwd without the caller having to reconstruct cold identity.
   const coldStart = await agent.execute({
     type: 'spawn', agent: 'worker', tag: 'cold-reaped', prompt: 'cold reap seed', cwd: root,
   }, ctx);
   await waitJob(coldStart, /ack: cold reap seed/, 'cold reap seed');
   const coldSessionId = (await waitSessionForTag('cold-reaped', 'cold reap seed')).id;
-  await sleep(1200);
+  await sleep(1700);
   assert(!sessionForTag('cold-reaped') && getSession(coldSessionId)?.closed, 'terminal reaper must remove the cold-reaped session');
   const coldSendOut = await agent.execute({
-    type: 'send', agent: 'worker', tag: 'cold-reaped', message: 'cold reap replacement', cwd: root,
+    type: 'send', tag: 'cold-reaped', message: 'cold reap replacement',
   }, ctx);
   assert(!/^Error:/.test(coldSendOut), `fully reaped tag must cold-respawn: ${coldSendOut}`);
   assert(/respawned: true/.test(coldSendOut), `fully reaped send must flag respawned: ${coldSendOut}`);
   await waitJob(coldSendOut, /ack: cold reap replacement/, 'cold reap replacement');
 
+  // Explicit spawn consumes the same tombstone form and also reports that the
+  // previous conversational context was lost.
+  const coldSpawnSeed = await agent.execute({
+    type: 'spawn', agent: 'reviewer', tag: 'cold-spawn-reaped', prompt: 'cold spawn seed', cwd: root,
+  }, ctx);
+  await waitJob(coldSpawnSeed, /ack: cold spawn seed/, 'cold spawn seed');
+  const coldSpawnSessionId = (await waitSessionForTag('cold-spawn-reaped', 'cold spawn seed')).id;
+  await sleep(1700);
+  assert(getSession(coldSpawnSessionId)?.closed, 'terminal reaper must close the cold-spawn seed');
+  const coldSpawnOut = await agent.execute({
+    type: 'spawn', tag: 'cold-spawn-reaped', prompt: 'cold spawn replacement',
+  }, ctx);
+  assert(!/^Error:/.test(coldSpawnOut), `tombstoned tag spawn must respawn: ${coldSpawnOut}`);
+  assert(/respawned: true/.test(coldSpawnOut), `tombstoned tag spawn must flag respawned: ${coldSpawnOut}`);
+  await waitJob(coldSpawnOut, /ack: cold spawn replacement/, 'cold spawn replacement');
+
+  // A stale running row with neither a live session nor a recent heartbeat is
+  // transitioned to a tombstone instead of blocking this tag forever.
+  addWorkerRow({
+    tag: 'stale-running',
+    sessionId: 'sess_stale_running',
+    status: 'running',
+    updatedAt: new Date(Date.now() - 120_000).toISOString(),
+  });
+  const staleRunningOut = await agent.execute({
+    type: 'spawn', tag: 'stale-running', prompt: 'stale running replacement',
+  }, ctx);
+  assert(!/^Error:/.test(staleRunningOut), `stale nonterminal row must transition: ${staleRunningOut}`);
+  assert(/respawned: true/.test(staleRunningOut), `stale nonterminal transition must flag respawned: ${staleRunningOut}`);
+  await waitJob(staleRunningOut, /ack: stale running replacement/, 'stale running replacement');
+
   // A raw session id, typo without retained evidence/identity, and a peer tag
   // must never turn into a local cold spawn.
   const rawSessionOut = await agent.execute({
@@ -264,6 +334,47 @@ async function main() {
   }, ctx);
   assert(/^Error:/.test(peerOut), `peer-terminal tag must remain an error: ${peerOut}`);
 
+  // Let the peer session become a peer-owned tombstone. Neither normal nor
+  // allTerminals dispatch may inherit that terminal identity.
+  await sleep(1700);
+  assert(tombstonesForTag('peer-owned').some((row) => row.clientHostPid === peerCtx.clientHostPid), 'peer-owned tombstone must exist');
+  const peerTombstoneSend = await agent.execute({
+    type: 'send', tag: 'peer-owned', message: 'must not absorb peer tombstone', allTerminals: true,
+  }, ctx);
+  assert(/^Error:/.test(peerTombstoneSend), `allTerminals send must reject peer tombstone: ${peerTombstoneSend}`);
+  const peerTombstoneSpawn = await agent.execute({
+    type: 'spawn', tag: 'peer-owned', prompt: 'must not inherit peer spawn', allTerminals: true,
+  }, ctx);
+  assert(/^Error:/.test(peerTombstoneSpawn), `allTerminals spawn must reject peer tombstone inheritance: ${peerTombstoneSpawn}`);
+
+  // Local evidence wins when a peer tombstone with the same tag coexists.
+  addTombstones([
+    { tag: 'coowned', agent: 'reviewer', cwd: root, clientHostPid: ctx.clientHostPid, reapedAt: new Date().toISOString() },
+    { tag: 'coowned', agent: 'worker', cwd: root, clientHostPid: peerCtx.clientHostPid, reapedAt: new Date().toISOString() },
+  ]);
+  const coownedOut = await agent.execute({
+    type: 'send', tag: 'coowned', message: 'prefer local tombstone', allTerminals: true,
+  }, ctx);
+  assert(!/^Error:/.test(coownedOut), `local tombstone must beat coexisting peer: ${coownedOut}`);
+  assert(/respawned: true/.test(coownedOut), `coexisting local tombstone must respawn: ${coownedOut}`);
+  await waitJob(coownedOut, /ack: prefer local tombstone/, 'coowned local tombstone');
+
+  // Fill the cap with future-dated entries, then let a real reap write one more.
+  // The current write must survive clamping/pruning.
+  const pruneSeed = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'prune-current', prompt: 'prune seed', cwd: root,
+  }, ctx);
+  await waitJob(pruneSeed, /ack: prune seed/, 'prune seed');
+  addTombstones(Array.from({ length: 500 }, (_, i) => ({
+    tag: `future-${i}`,
+    agent: 'worker',
+    cwd: root,
+    clientHostPid: ctx.clientHostPid,
+    reapedAt: new Date(Date.now() + 86_400_000 + i).toISOString(),
+  })));
+  await sleep(1700);
+  assert(tombstonesForTag('prune-current').length === 1, 'prune cap must retain the tombstone written this call');
+
   // agent close clears the trace; same tag can spawn fresh again
   addPeerTerminalRow('reviewerA', 'sess_peer_close');
   await agent.execute({ type: 'close', tag: 'reviewerA' }, ctx);
@@ -306,7 +417,10 @@ async function main() {
   removeWorkerRow(staleSessionId);
   addPeerTerminalRow('fallback-peer', 'sess_peer_fallback');
   const fallbackClose = await agent.execute({ type: 'close', tag: 'fallback-peer' }, ctx);
-  assert(/forgotten: true/.test(fallbackClose), `stale close fallback must stay forgotten:true: ${fallbackClose}`);
+  assert(
+    /forgotten: true|target "fallback-peer" not found/.test(fallbackClose),
+    `stale close fallback must forget locally or report no local target: ${fallbackClose}`,
+  );
   assert(hasWorkerRow('sess_peer_fallback'), 'stale close fallback must preserve a peer terminal row with the same tag');
   removeWorkerRow('sess_peer_fallback');
   const fallbackFresh = await agent.execute({

package/scripts/ansi-color-capability-test.mjs

@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  brightGreen,
+  refreshColorSupport,
+  rgb,
+  rgbBg,
+  rgbSgr,
+  rgbToAnsi256,
+  supportsTruecolor,
+} from '../src/ui/ansi.mjs';
+import {
+  remapCanonicalStatuslineTruecolor,
+  STATUSLINE_CANONICAL_TRUECOLOR,
+} from '../src/tui/statusline-ansi-bridge.mjs';
+
+const savedEnv = {
+  COLORTERM: process.env.COLORTERM,
+  FORCE_COLOR: process.env.FORCE_COLOR,
+  NO_COLOR: process.env.NO_COLOR,
+  TERM: process.env.TERM,
+  TERM_PROGRAM: process.env.TERM_PROGRAM,
+  WT_SESSION: process.env.WT_SESSION,
+};
+
+function restoreEnv() {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshColorSupport();
+}
+
+test.after(restoreEnv);
+
+test('truecolor capability detection preserves known positives and defaults unknown to truecolor', () => {
+  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'Apple_Terminal', COLORTERM: 'truecolor' }, 'darwin'), false);
+  assert.equal(supportsTruecolor({ COLORTERM: 'truecolor' }, 'darwin'), true);
+  assert.equal(supportsTruecolor({ COLORTERM: '24bit' }, 'linux'), true);
+  assert.equal(supportsTruecolor({ WT_SESSION: 'abc' }, 'linux'), true);
+  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'iTerm.app' }, 'darwin'), true);
+  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'WezTerm' }, 'darwin'), true);
+  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'ghostty' }, 'darwin'), true);
+  assert.equal(supportsTruecolor({ TERM_PROGRAM: 'vscode' }, 'darwin'), true);
+  assert.equal(supportsTruecolor({ TERM: 'xterm-direct' }, 'linux'), true);
+  assert.equal(supportsTruecolor({}, 'win32'), true);
+  assert.equal(supportsTruecolor({}, 'linux'), true);
+});
+
+test('RGB helpers are byte-identical in truecolor mode and downsample foreground/background on Apple Terminal', () => {
+  process.env.FORCE_COLOR = '1';
+  delete process.env.NO_COLOR;
+  process.env.COLORTERM = 'truecolor';
+  delete process.env.TERM_PROGRAM;
+  refreshColorSupport();
+
+  assert.equal(rgb(215, 119, 87)('x'), '\x1b[38;2;215;119;87mx\x1b[0m');
+  assert.equal(rgbBg(55, 55, 55)('x'), '\x1b[48;2;55;55;55mx\x1b[0m');
+
+  process.env.TERM_PROGRAM = 'Apple_Terminal';
+  assert.equal(rgbSgr(215, 119, 87), '\x1b[38;5;173m');
+  assert.equal(rgb(215, 119, 87)('x'), '\x1b[38;5;173mx\x1b[0m');
+  assert.equal(rgbBg(55, 55, 55)('x'), '\x1b[48;5;237mx\x1b[0m');
+  assert.equal(brightGreen('x'), '\x1b[38;5;35mx\x1b[0m');
+});
+
+test('RGB to ANSI-256 conversion selects the nearest cube or grayscale entry', () => {
+  assert.equal(rgbToAnsi256(0, 170, 75), 35);
+  assert.equal(rgbToAnsi256(198, 198, 198), 251);
+  assert.equal(rgbToAnsi256(136, 136, 136), 102);
+  assert.equal(rgbToAnsi256(255, 255, 255), 231);
+});
+
+test('statusline theme remap recognizes canonical 256-color variants', () => {
+  const colors = {
+    STATUS: '<status>',
+    SUBTLE: '<subtle>',
+    SUCCESS: '<success>',
+    WARNING: '<warning>',
+    ERROR: '<error>',
+  };
+  const success256 = `\x1b[38;5;${rgbToAnsi256(...STATUSLINE_CANONICAL_TRUECOLOR.success)}m`;
+  const warning256 = `\x1b[38;5;${rgbToAnsi256(...STATUSLINE_CANONICAL_TRUECOLOR.warningBright)}m`;
+  const input = `${success256}ok ${warning256}warn`;
+  assert.equal(
+    remapCanonicalStatuslineTruecolor(input, colors),
+    '<success>ok <warning>warn',
+  );
+});

package/scripts/anthropic-oauth-refresh-race-test.mjs

@@ -25,6 +25,7 @@ const { AnthropicOAuthProvider } = await import(
     '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs'
 );
 const {
+    DEFAULT_CLI_VERSION,
     _saveCredentialsFile,
     loadCredentials,
     loadCredentialsFromPath,
@@ -48,6 +49,64 @@ function writeCredentials({ accessToken, refreshToken, expiresAt }, path = crede
     });
 }
 
+test('refresh uses the current CLI identity and returns a neutral sanitized 403', async () => {
+    const accessToken = 'fixture-access-must-not-leak';
+    const refreshToken = 'fixture-refresh-must-not-leak';
+    writeCredentials({
+        accessToken,
+        refreshToken,
+        expiresAt: Date.now() + 1_000,
+    });
+    const before = readFileSync(credentialsPath, 'utf8');
+    const originalFetch = globalThis.fetch;
+    let request = null;
+    globalThis.fetch = async (url, options) => {
+        request = { url, options };
+        return {
+            ok: false,
+            status: 403,
+            async text() {
+                return JSON.stringify({
+                    error: 'forbidden',
+                    accessToken,
+                    refresh_token: refreshToken,
+                    echoed: `Bearer ${accessToken}`,
+                });
+            },
+        };
+    };
+    try {
+        assert.equal(DEFAULT_CLI_VERSION, '2.1.207');
+        await assert.rejects(
+            refreshOAuthCredentials(loadCredentials()),
+            (err) => {
+                assert.match(err.message, /token refresh 403/);
+                assert.match(err.message, /claude-cli\/2\.1\.207/);
+                assert.match(err.message, /Possible causes include OAuth client compatibility/);
+                assert.match(err.message, /account or scope policy/);
+                assert.match(err.message, /proxy\/VPN\/WAF/);
+                assert.match(err.message, /regional endpoint restrictions/);
+                assert.match(err.message, /Verify the account has Claude Code access and the required scopes/);
+                assert.match(err.message, /MIXDOG_CLI_VERSION/);
+                assert.match(err.message, /retry sign-in via \/providers/);
+                assert.doesNotMatch(err.message, /rejected the OAuth client identity/);
+                assert.doesNotMatch(err.message, /fixture-access-must-not-leak/);
+                assert.doesNotMatch(err.message, /fixture-refresh-must-not-leak/);
+                return true;
+            },
+        );
+        assert.equal(
+            request.options.headers['user-agent'],
+            'claude-cli/2.1.207 (external, sdk-cli)',
+        );
+        assert.equal(request.options.redirect, 'error');
+        assert.equal(JSON.parse(request.options.body).refresh_token, refreshToken);
+        assert.equal(readFileSync(credentialsPath, 'utf8'), before);
+    } finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+
 test('parallel host preflights refresh once and snapshot the leased generation', async () => {
     writeCredentials({
         accessToken: 'fixture-access-old',

package/scripts/arg-guard-test.mjs

@@ -75,3 +75,19 @@ test('below-min (negative) still errors', () => {
 test('fractional numeric string is not coerced (still errors)', () => {
     assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: '3.5' }), /must be an integer/);
 });
+
+test('grep pattern and glob-filter numeric values coerce to strings', () => {
+    const pattern = { pattern: 123 };
+    assert.equal(validateBuiltinArgs('grep', pattern), null);
+    assert.equal(pattern.pattern, '123');
+
+    const patternArray = { pattern: [123, 'a'] };
+    assert.equal(validateBuiltinArgs('grep', patternArray), null);
+    assert.deepEqual(patternArray.pattern, ['123', 'a']);
+
+    const glob = { pattern: 'x', glob: 123 };
+    assert.equal(validateBuiltinArgs('grep', glob), null);
+    assert.equal(glob.glob, '123');
+
+    assert.match(validateBuiltinArgs('grep', { pattern: {} }), /must be string or string\[\]/);
+});