mixdog 0.9.47 → 0.9.50

package/scripts/smoke.mjs

@@ -19,120 +19,19 @@ function runNode(args, label, options = {}) {
   return child;
 }
 
-const child = runNode(['src/cli.mjs', '--help'], 'help smoke');
-const isolatedStatuslineEnv = {
-  MIXDOG_DATA_DIR: resolve(root, '.mixdog-smoke-data-empty'),
-  MIXDOG_HOME: resolve(root, '.mixdog-smoke-home-empty'),
-  MIXDOG_CONFIG_DIR: resolve(root, '.mixdog-smoke-config-empty'),
-};
-
-if (!child.stdout.includes('standalone mixdog CLI/TUI coding agent')) {
-  process.stderr.write(`unexpected help output:\n${child.stdout}`);
-  process.exit(1);
-}
+runNode(['src/cli.mjs', '--help'], 'help smoke');
 
 runNode(['--input-type=module', '-e', `
   const mod = await import('./src/tui/dist/index.mjs');
   if (typeof mod.runTui !== 'function') throw new Error('runTui export missing');
 `], 'tui bundle import smoke');
 
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 1000000,
-    stats: { currentContextTokens: 999 },
-  });
-  if (/▓/.test(line) || !line.includes('░') || !line.includes('0.1%')) throw new Error('sub-1% context bar should stay empty: ' + JSON.stringify(line));
-`], 'statusline sub-percent context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    rawContextWindow: 1000000,
-    stats: { currentContextTokens: 900000 },
-  });
-  if (!line.includes('94%') || line.includes('100%')) throw new Error('statusline context% should use effective compact capacity, not the 90% auto-compact trigger: ' + JSON.stringify(line));
-`], 'statusline compact-capacity context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 350000, currentContextSource: 'estimated' },
-  });
-  if (line.includes('37%') || !line.includes('0%')) throw new Error('statusline must not show local estimated context as session usage: ' + JSON.stringify(line));
-`], 'statusline estimated-context isolation smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 360000, currentContextSource: 'post_compact_estimate' },
-  });
-  if (!line.includes('37%')) throw new Error('statusline must show post-compact estimated context after stale API usage: ' + JSON.stringify(line));
-`], 'statusline post-compact context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 0 },
-    agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
-  });
-  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
-`], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  const { mkdtempSync, mkdirSync, writeFileSync } = await import('node:fs');
-  const { tmpdir } = await import('node:os');
-  const { join } = await import('node:path');
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-status-smoke-'));
-  mkdirSync(join(root, 'runtime'), { recursive: true });
-  writeFileSync(join(root, 'runtime', 'active-instance.json'), JSON.stringify({
-    gateway_port: 3468,
-    gateway_server_pid: process.pid,
-    gateway_provider: 'openai',
-    gateway_model: 'gpt-5.5',
-    gateway_context_window: 950000,
-    gateway_raw_context_window: 1000000,
-    gateway_auto_compact_token_limit: 950000,
-    gateway_context_used_pct: 37,
-    gateway_cc_session_id: 'other-session',
-    gateway_updated_at: Date.now()
-  }));
-  process.env.MIXDOG_RUNTIME_ROOT = join(root, 'runtime');
-  const { loadGatewayStatus } = await import('./src/vendor/statusline/bin/statusline-route.mjs');
-  const status = loadGatewayStatus({ sessionId: 'fresh-session', clientHostPid: process.pid, activeContextTokens: 0 });
-  if (status?.contextUsedPct === 37) throw new Error('statusline leaked active-instance context from another session');
-`], 'statusline session metrics isolation smoke', { env: isolatedStatuslineEnv });
-
-const boot = spawnSync(process.execPath, ['src/cli.mjs', '--help'], {
-  cwd: root,
-  env: { ...process.env, MIXDOG_BOOT_PROFILE: '1' },
-  encoding: 'utf8',
-  stdio: ['ignore', 'pipe', 'pipe'],
-  timeout: 10000,
+const boot = runNode(['src/cli.mjs', '--help'], 'boot profile smoke', {
+  env: { MIXDOG_BOOT_PROFILE: '1' },
 });
-
-if (boot.status !== 0 || !boot.stderr.includes('[mixdog-boot]') || !boot.stderr.includes('app:run:start')) {
+if (!boot.stderr.includes('[mixdog-boot]')) {
   process.stderr.write(boot.stderr || boot.stdout || 'boot profile smoke failed\n');
-  process.exit(boot.status || 1);
+  process.exit(1);
 }
 
 process.stdout.write('smoke passed ✓\n');

package/scripts/statusline-quota-hysteresis-test.mjs

@@ -1,6 +1,10 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { acceptQuotaSnapshot } from '../src/ui/statusline.mjs';
+import {
+  acceptQuotaSnapshot,
+  fallbackStatusline,
+  resolveContextUsedPct,
+} from '../src/ui/statusline.mjs';
 
 // Monotonic hysteresis for the 5H/7D usage segment: once a value has rendered,
 // an OLDER shared-cache snapshot (written by another mixdog instance) must not
@@ -35,3 +39,24 @@ test('own-instance live data always wins; empty timestamps preserve prior behavi
   // Shared→shared same asOf → accept (idempotent refresh).
   assert.equal(acceptQuotaSnapshot({ asOf: 2000, owned: false }, { asOf: 2000, owned: false }), true);
 });
+
+test('context percentage uses compaction pressure over trigger and ignores gateway boundary percent', () => {
+  const args = {
+    stats: {
+      currentEstimatedContextTokens: 75_000,
+      currentContextSource: 'estimated',
+    },
+    contextWindow: 100_000,
+    compactBoundaryTokens: 100_000,
+    autoCompactTokenLimit: 75_000,
+  };
+  assert.equal(resolveContextUsedPct({
+    ...args,
+    gatewayStatus: { contextUsedPct: 75 },
+  }), 100);
+  assert.match(
+    fallbackStatusline({ provider: 'openai', model: 'test', ...args })
+      .replace(/\x1b\[[0-9;]*m/g, ''),
+    /\b100%/,
+  );
+});

package/scripts/streaming-tail-window-test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  windowPlainStreamingText,
+} from '../src/tui/markdown/streaming-markdown.mjs';
+import {
+  measureStreamingMarkdownRenderedRows,
+} from '../src/tui/markdown/measure-rendered-rows.mjs';
+
+test('bottom-pinned plain streaming text keeps only the visible suffix', () => {
+  const lines = Array.from({ length: 100 }, (_, index) => `plain line ${index}`);
+  const full = lines.join('\n');
+  const windowed = windowPlainStreamingText(full, 80, 12);
+
+  assert.equal(windowed, lines.slice(-12).join('\n'));
+  assert.ok(measureStreamingMarkdownRenderedRows(full, 83, 'plain-window-full') > 12);
+});
+
+test('markdown streaming text is never internally windowed', () => {
+  const markdown = `${'plain history\n'.repeat(100)}**live markdown**`;
+  assert.equal(windowPlainStreamingText(markdown, 80, 12), markdown.trim());
+});
+
+test('wrapped plain lines consume the streaming row budget', () => {
+  const lines = ['old', 'x'.repeat(160), 'new'];
+  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 2), lines.slice(-1).join('\n'));
+  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 3), lines.slice(-2).join('\n'));
+});

package/scripts/tool-failures.mjs

@@ -94,20 +94,33 @@ const rows = files.flatMap(readRows)
   .filter((row) => !agentFilter || String(row.agent || '-') === agentFilter)
   .filter((row) => !categoryFilter || rowCategory(row) === categoryFilter)
   .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
-const recent = rows.slice(-limit);
+const isCommandExit = (row) => rowCategory(row) === 'command-exit';
+const actionableRows = rows.filter((row) => !isCommandExit(row));
+const commandExitRows = rows.filter(isCommandExit);
+// Limit each partition independently so a burst of ordinary command exits
+// cannot crowd runtime/actionable failures out of the displayed report.
+const actionableRecent = actionableRows.slice(-limit);
+const commandExitRecent = commandExitRows.slice(-limit);
+const recent = [...actionableRecent, ...commandExitRecent]
+  .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
 const byTool = new Map();
 const byCategory = new Map();
+const actionableByTool = new Map();
+const commandExitByTool = new Map();
 for (const row of recent) {
   const tool = rowTool(row);
   const category = rowCategory(row);
   inc(byTool, tool);
   inc(byCategory, `${tool} / ${category}`);
+  inc(isCommandExit(row) ? commandExitByTool : actionableByTool, tool);
 }
 
 if (jsonMode) {
   console.log(JSON.stringify({
     shown: recent.length,
     matched: rows.length,
+    actionable_failures: { shown: actionableRecent.length, matched: actionableRows.length },
+    command_exits: { shown: commandExitRecent.length, matched: commandExitRows.length },
     since: sinceTs ? new Date(sinceTs).toISOString() : null,
     filters: {
       tool: toolFilter,
@@ -116,13 +129,17 @@ if (jsonMode) {
     },
     sources: files.filter(existsSync),
     tools: Object.fromEntries([...byTool.entries()].sort((a, b) => b[1] - a[1])),
+    actionable_tools: Object.fromEntries([...actionableByTool.entries()].sort((a, b) => b[1] - a[1])),
+    command_exit_tools: Object.fromEntries([...commandExitByTool.entries()].sort((a, b) => b[1] - a[1])),
     categories: Object.fromEntries([...byCategory.entries()].sort((a, b) => b[1] - a[1])),
     rows: recent,
   }, null, 2));
   process.exit(0);
 }
 
-console.log(`tool failures: ${recent.length}/${rows.length} shown`);
+console.log(`actionable failures: ${actionableRecent.length}/${actionableRows.length} shown`);
+console.log(`command exits: ${commandExitRecent.length}/${commandExitRows.length} shown (retained)`);
+console.log(`rows: ${recent.length}/${rows.length} shown`);
 if (sinceTs) console.log(`since: ${new Date(sinceTs).toISOString()}`);
 const filterParts = [
   toolFilter ? `tool=${toolFilter}` : '',
@@ -131,7 +148,8 @@ const filterParts = [
 ].filter(Boolean);
 if (filterParts.length) console.log(`filters: ${filterParts.join(', ')}`);
 if (files.length > 0) console.log(`sources: ${files.filter(existsSync).join(', ') || '(none)'}`);
-console.log(`tools: ${[...byTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`actionable tools: ${[...actionableByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`command-exit tools: ${[...commandExitByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
 console.log(`categories: ${[...byCategory.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
 for (const row of recent) {
   const tool = rowTool(row);