mixdog 0.9.63 → 0.9.65

package/src/ui/ansi.mjs

@@ -151,18 +151,9 @@ export const gray = sgr('38;2;198;198;198');
 export const grey = gray;
 
 // Bright variants (used sparingly for headings / accents).
-export const brightRed = sgr('38;2;220;70;88');
 export const brightGreen = sgr('38;2;0;185;88');
-export const brightYellow = sgr('38;2;255;210;80');
-export const brightBlue = sgr('38;2;93;173;255');
-export const brightMagenta = sgr('38;2;190;150;230');
-export const brightCyan = sgr('38;2;168;168;168');
-export const brightWhite = sgr('38;2;220;220;220');
 
 // --- Background colors ------------------------------------------------------
-export const bgGray = sgr('100');
-export const bgBlack = sgr('40');
-export const bgBlue = sgr('44');
 
 // --- RGB colors --------------------------------------------------------------
 // Emit 24-bit SGR where supported, otherwise use the nearest 256-color entry.

package/src/ui/statusline-format.mjs

@@ -15,7 +15,6 @@ import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/mo
 export const FALLBACK_CONTEXT_WINDOW = 200000;
 export const statusText = rgb(198, 198, 198);
 export const statusSubtle = rgb(136, 136, 136);
-export const statusAccent = rgb(215, 119, 87);
 
 function sgr(code) {
   return colorEnabled() ? `\x1b[${code}m` : '';
@@ -27,7 +26,6 @@ export const D = colorEnabled() ? rgbSgr(136, 136, 136) : '';
 export const GRN = colorEnabled() ? rgbSgr(0, 170, 75) : '';
 export const YLW = colorEnabled() ? rgbSgr(255, 193, 7) : '';
 export const RED = colorEnabled() ? rgbSgr(220, 70, 88) : '';
-export const CYN = colorEnabled() ? rgbSgr(136, 136, 136) : '';
 export const GREY = colorEnabled() ? rgbSgr(136, 136, 136) : '';
 
 export function terminalColumns() {
@@ -80,7 +78,7 @@ export function formatContextSegment(ctxPct, cols) {
   return `${fill}${filled}${R}${D}${empty}${R} ${label}%`;
 }
 
-export function makeBar(pct, cells) {
+function makeBar(pct, cells) {
   let filled = Math.floor((Number(pct) || 0) * cells / 100);
   if (filled < 0) filled = 0;
   if (filled > cells) filled = cells;
@@ -105,7 +103,7 @@ export function num(v) {
   return Number.isFinite(n) ? n : 0;
 }
 
-export function clampPct(v) {
+function clampPct(v) {
   const n = Number(v);
   if (!Number.isFinite(n)) return 0;
   return Math.max(0, Math.min(100, n));

package/scripts/_bench-cwc.json

@@ -1,20 +0,0 @@
-[
-  {
-    "id": "cwc-hookflow",
-    "agent": "worker",
-    "prompt": "In this repo (mixdog), what happens to a tool call when no hooks are configured? Verify the default observer/bypass path: where beforeTool() is invoked, what it returns with no configured rules, and where a configured custom hook rule could instead deny the call. Give file paths and function names. Do not modify anything.",
-    "cwd": "."
-  },
-  {
-    "id": "cwc-cacheusage",
-    "agent": "worker",
-    "prompt": "In this repo (mixdog), how are cached token counts recorded and surfaced in usage metrics? Find where cached_tokens comes from and how it flows into the usage record. Give file paths and function names. Do not modify anything.",
-    "cwd": "."
-  },
-  {
-    "id": "cwc-compacttrigger",
-    "agent": "worker",
-    "prompt": "In this repo (mixdog), what triggers a context compaction and where is that threshold decided? Trace the trigger condition to the compaction entry point. Give file paths and function names. Do not modify anything.",
-    "cwd": "."
-  }
-]

package/scripts/_jitter-fuzz.jsx

@@ -1,42 +0,0 @@
-import React from 'react';
-import { Box, renderToString } from 'ink';
-import { ToolExecution } from '../src/tui/components/ToolExecution.jsx';
-import { estimateTranscriptItemRowsCached } from '../src/tui/app/transcript-window.mjs';
-function renderRows(item,COLUMNS){
-  const node=React.createElement(Box,{flexDirection:'column',flexShrink:0,width:COLUMNS},
-    React.createElement(ToolExecution,{name:item.name,args:item.args,result:item.result,rawResult:item.rawResult,isError:item.isError,errorCount:item.errorCount,expanded:!!item.expanded,columns:COLUMNS,attached:false,count:item.count,completedCount:item.completedCount,startedAt:item.startedAt,completedAt:item.completedAt,aggregate:item.aggregate,categories:item.categories,doneCategories:item.doneCategories,headerFinalized:item.headerFinalized,deferredDisplayReady:item.deferredDisplayReady}));
-  const out=renderToString(node,{columns:COLUMNS});
-  return out===''?0:out.split('\n').length;
-}
-const now=Date.now();
-const longLine='x'.repeat(200);
-const items=[];
-const names=['read','grep','glob','shell','code_graph','explore','search','web_fetch','agent','Skill','view_image','recall','remember','task','list'];
-const results=[null,'','ok','No matches','line1\nline2','line1\nline2\nline3',longLine, longLine+'\n'+longLine, '[status: cancelled]\nbody', 'Error: boom'];
-let id=0;
-for(const name of names){
- for(const result of results){
-  for(const completed of [0,1]){
-   for(const isError of [false,true]){
-    for(const expanded of [false,true]){
-     items.push({name,args:{path:'a/b/c.js',pattern:'foo',command:'ls -la',mode:'search',symbols:'X',action:'spawn',status: completed?'completed':'',name:'setup'},result,count:1,completedCount:completed,isError,expanded,startedAt:now-2000,completedAt:completed?now:0,headerFinalized:completed===1,deferredDisplayReady:true,rawResult: expanded?(result||'raw body\nl2'):null,__id:id++});
-    }
-   }
-  }
- }
-}
-const COLS=[40,60,80,100,120];
-let bad=0,total=0;
-const seen=new Set();
-for(const COLUMNS of COLS){
- for(const it of items){
-  total++;
-  const est=estimateTranscriptItemRowsCached({kind:'tool',...it},COLUMNS,false);
-  let ren; try{ren=renderRows(it,COLUMNS);}catch(e){ren='ERR:'+e.message;}
-  if(est!==ren){bad++;
-   const key=`${it.name}|res=${JSON.stringify(it.result)}|c=${it.completedCount}|e=${it.isError}|x=${it.expanded}|col=${COLUMNS}`;
-   if(bad<=40) console.log(`DIFF est=${est} ren=${ren}  ${key}`);
-  }
- }
-}
-console.log('total',total,'mismatches',bad);

package/scripts/_jitter-fuzz2.jsx

@@ -1,30 +0,0 @@
-import React from 'react';
-import { Box, renderToString } from 'ink';
-import { ToolExecution } from '../src/tui/components/ToolExecution.jsx';
-import { estimateTranscriptItemRowsCached } from '../src/tui/app/transcript-window.mjs';
-import { shouldSuppressFullyFailedToolItem } from '../src/tui/transcript-tool-failures.mjs';
-function renderRows(item,COLUMNS){
-  const node=React.createElement(Box,{flexDirection:'column',flexShrink:0,width:COLUMNS},
-    React.createElement(ToolExecution,{name:item.name,args:item.args,result:item.result,rawResult:item.rawResult,isError:item.isError,errorCount:item.errorCount,expanded:!!item.expanded,columns:COLUMNS,attached:false,count:item.count,completedCount:item.completedCount,startedAt:item.startedAt,completedAt:item.completedAt,aggregate:item.aggregate,categories:item.categories,doneCategories:item.doneCategories,headerFinalized:item.headerFinalized,deferredDisplayReady:item.deferredDisplayReady}));
-  const out=renderToString(node,{columns:COLUMNS});
-  return out===''?0:out.split('\n').length;
-}
-const now=Date.now();
-const names=['read','grep','glob','shell','code_graph','explore','search','web_fetch','agent','Skill','view_image','recall','list','fetch','load_tool'];
-const results=['ok','No matches','line1\nline2','line1\nline2\nline3','done · 3 items','Failed', 'Read 40 lines'];
-const cases=[];
-let id=0;
-for(const name of names) for(const result of results) for(const completed of [0,1]) for(const isError of [false,true]){
-  cases.push({name,args:{path:'a/b/c.js',pattern:'foo',command:'ls -la',mode:'search',symbols:'X',action:'response',status: completed?'completed':'',name:'setup'},result: completed?result:null,count:1,completedCount:completed,isError,expanded:false,startedAt:now-2000,completedAt:completed?now:0,headerFinalized:completed===1,deferredDisplayReady:true,rawResult:null,__id:id++});
-}
-const COLS=[60,80,100,120];
-let bad=0,total=0;
-for(const COLUMNS of COLS) for(const it of cases){
-  const full={kind:'tool',...it};
-  if(shouldSuppressFullyFailedToolItem(full)) continue; // real app renders nothing
-  total++;
-  const est=estimateTranscriptItemRowsCached(full,COLUMNS,false);
-  let ren; try{ren=renderRows(it,COLUMNS);}catch(e){ren='ERR:'+e.message;}
-  if(est!==ren){bad++; if(bad<=60) console.log(`DIFF est=${est} ren=${ren}  ${it.name}|res=${JSON.stringify(it.result)}|c=${it.completedCount}|e=${it.isError}|col=${COLUMNS}`);}
-}
-console.log('total',total,'mismatches',bad);

package/scripts/_jitter-probe.jsx

@@ -1,35 +0,0 @@
-import React from 'react';
-import { Box, renderToString } from 'ink';
-import { ToolExecution } from '../src/tui/components/ToolExecution.jsx';
-import { estimateTranscriptItemRowsCached } from '../src/tui/app/transcript-window.mjs';
-const COLUMNS=80;
-function renderRows(item){
-  const node=React.createElement(Box,{flexDirection:'column',flexShrink:0,width:COLUMNS},
-    React.createElement(ToolExecution,{name:item.name,args:item.args,result:item.result,rawResult:item.rawResult,isError:item.isError,errorCount:item.errorCount,expanded:!!item.expanded,columns:COLUMNS,attached:false,count:item.count,completedCount:item.completedCount,startedAt:item.startedAt,completedAt:item.completedAt,aggregate:item.aggregate,categories:item.categories,doneCategories:item.doneCategories,headerFinalized:item.headerFinalized,deferredDisplayReady:item.deferredDisplayReady}));
-  const out=renderToString(node,{columns:COLUMNS});
-  return out===''?0:out.split('\n').length;
-}
-const now=Date.now();
-const F=[
- ['read pending',{name:'read',args:{path:'a.js'},result:null,count:1,completedCount:0,startedAt:now-2000,deferredDisplayReady:true,headerFinalized:false}],
- ['read settled',{name:'read',args:{path:'a.js'},result:'Read 40 lines',count:1,completedCount:1,startedAt:now-2000,completedAt:now,deferredDisplayReady:true,headerFinalized:true}],
- ['grep settled 0',{name:'grep',args:{pattern:'foo'},result:'No matches',count:1,completedCount:1,startedAt:now-1000,completedAt:now,headerFinalized:true}],
- ['shell pending',{name:'shell',args:{command:'ls'},result:null,count:1,completedCount:0,startedAt:now-2000,deferredDisplayReady:true}],
- ['shell settled',{name:'shell',args:{command:'ls'},result:'file1\nfile2',count:1,completedCount:1,startedAt:now-2000,completedAt:now,headerFinalized:true}],
- ['shell settled empty',{name:'shell',args:{command:'ls'},result:'',count:1,completedCount:1,startedAt:now,completedAt:now,headerFinalized:true}],
- ['agent pending',{name:'agent',args:{action:'spawn'},result:null,count:1,completedCount:0,startedAt:now-2000,deferredDisplayReady:true}],
- ['agent settled resp',{name:'agent',args:{action:'response',status:'completed'},result:'Agent reply body here',count:1,completedCount:1,startedAt:now,completedAt:now,headerFinalized:true}],
- ['skill settled',{name:'Skill',args:{name:'setup'},result:'loaded body\nmore',count:1,completedCount:1,startedAt:now,completedAt:now,headerFinalized:true}],
- ['code_graph settled',{name:'code_graph',args:{mode:'search',symbols:'x'},result:'3 results',count:1,completedCount:1,startedAt:now,completedAt:now,headerFinalized:true}],
- ['aggregate pending',{name:'read',args:{categoryOrder:['read']},aggregate:true,result:null,count:3,completedCount:0,startedAt:now-2000,categories:{read:{count:3}},deferredDisplayReady:true}],
- ['aggregate settled',{name:'read',args:{categoryOrder:['read']},aggregate:true,result:'Read 3 files',count:3,completedCount:3,startedAt:now-2000,completedAt:now,categories:{read:{count:3}},doneCategories:{read:{count:3}},headerFinalized:true}],
-];
-let bad=0;
-for(const [label,item] of F){
-  const est=estimateTranscriptItemRowsCached({kind:'tool',...item},COLUMNS,false);
-  const ren=renderRows(item);
-  const m=est===ren?'ok  ':'DIFF';
-  if(est!==ren)bad++;
-  console.log(`${m} est=${est} render=${ren}  ${label}`);
-}
-console.log('mismatches:',bad);

package/scripts/_jp2.jsx

@@ -1,16 +0,0 @@
-import React from 'react';
-import { Box } from 'ink';
-import { render } from 'ink';
-import stripAnsi from 'strip-ansi';
-import { ToolExecution } from '../src/tui/components/ToolExecution.jsx';
-const COLUMNS=80;
-let buf='';
-const stdout={columns:COLUMNS,rows:200,write:(s)=>{buf+=s;return true;},on(){},off(){},removeListener(){}};
-const item={ name:'read', args:{path:'a.js'}, result:'Read 40 lines', count:1, completedCount:1, startedAt:Date.now()-2000, completedAt:Date.now(), deferredDisplayReady:true, headerFinalized:true };
-const node=React.createElement(Box,{flexDirection:'column',flexShrink:0,width:COLUMNS},React.createElement(ToolExecution,{name:item.name,args:item.args,result:item.result,columns:COLUMNS,count:1,completedCount:1,startedAt:item.startedAt,completedAt:item.completedAt,headerFinalized:true,deferredDisplayReady:true}));
-const inst=render(node,{stdout,patchConsole:false});
-await new Promise(r=>setTimeout(r,60));
-console.log('RAW len',buf.length);
-console.log(JSON.stringify(buf));
-inst.unmount();
-process.exit(0);

package/scripts/_smoke_wd.mjs

@@ -1,7 +0,0 @@
-const wd = setTimeout(() => {
-  console.error('=== WATCHDOG 45s: active resources:', JSON.stringify(process.getActiveResourcesInfo()));
-  process.exit(99);
-}, 45000);
-await import('./compact-smoke.mjs');
-clearTimeout(wd);
-console.error('=== script import completed normally');

package/scripts/abort-recovery-test.mjs

@@ -1,175 +0,0 @@
-#!/usr/bin/env node
-// Regression: bounded manual-abort recovery. Esc calls runtime.abort(), which
-// normally rejects the in-flight runtime.ask() so the turn's finally clears
-// busy. If that unwind is STARVED (provider abort never settles after a
-// post-tool fetch stall), busy must not stay true forever — a short grace timer
-// hard-releases the store and re-kicks drain. A normal abort that settles in
-// time must NOT be masked by the recovery.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
-import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
-
-const wait = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// Minimal engine bag exercising only the abort() recovery path. `abortSettles`
-// models whether runtime.abort() actually unwinds the turn (clears busy) — the
-// starved case leaves busy=true so the recovery timer must fire.
-function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
-  let seq = 0;
-  const notices = [];
-  const requeued = [];
-  const discardedCompletionKeys = [];
-  const abortReasons = [];
-  let drainCount = 0;
-  let state = { items: [], queued: [], busy: false, commandBusy: false, spinner: null, thinking: null, lastTurn: null };
-  const bag = {
-    runtime: {
-      id: null,
-      consumePendingSessionReset: () => null,
-      abort: (reason) => {
-        abortReasons.push(reason);
-        if (abortSettles) bag.set({ busy: false, spinner: null, thinking: null, lastTurn: null });
-        return true;
-      },
-    },
-    nextId: () => `id_${++seq}`,
-    tuiDebug: () => {},
-    flags: { leadTurnEpoch: 1, disposed: false, draining: false, activePromptRestore: null, manualAbortRecoveryMs: recoveryMs },
-    pending: [],
-    listeners: new Set(),
-    getState: () => state,
-    set: (patch) => {
-      if (!patch || typeof patch !== 'object') return false;
-      state = { ...state, ...patch };
-      return true;
-    },
-    pushItem: () => {},
-    patchItem: () => {},
-    replaceItems: (x) => x,
-    pushNotice: (text, level) => { notices.push({ text, level }); },
-    pushUserOrSyntheticItem: () => {},
-    autoClearState: () => ({ enabled: false }),
-    agentStatusState: () => ({}),
-    routeState: () => ({}),
-    syncContextStats: () => {},
-    denyAllToolApprovals: () => {},
-    updateAgentJobCard: () => {},
-    requeueEntriesFront: (entries) => { requeued.push(...entries); },
-    resetStatsAndSyncContext: () => {},
-    flushDeferredExecutionPendingResumeKick: () => {},
-    discardExecutionPendingResume: (keys) => { discardedCompletionKeys.push(...keys); },
-    drain: async () => { drainCount += 1; },
-    runTurn: async () => 'ok',
-  };
-  Object.assign(bag, createSessionFlow(bag));
-  bag.drain = async () => { drainCount += 1; };
-  const api = createEngineApiA(bag);
-  return {
-    api,
-    bag,
-    getNotices: () => notices,
-    getDrainCount: () => drainCount,
-    getRequeued: () => requeued,
-    getDiscardedCompletionKeys: () => discardedCompletionKeys,
-    getAbortReasons: () => abortReasons,
-  };
-}
-
-test('Esc uses Claude-compatible user-cancel and queued interrupt reasons', () => {
-  const normal = makeEngine({ abortSettles: true });
-  normal.bag.set({ busy: true });
-  normal.api.abort();
-  assert.deepEqual(normal.getAbortReasons(), ['user-cancel']);
-
-  const queued = makeEngine({ abortSettles: true });
-  queued.bag.set({ busy: true });
-  queued.bag.pending.push({ kind: 'prompt', text: 'queued redirect' });
-  queued.api.abort();
-  assert.deepEqual(queued.getAbortReasons(), ['interrupt']);
-});
-
-test('starved abort → bounded recovery hard-releases busy and re-kicks drain', async () => {
-  const { api, bag, getNotices, getDrainCount } = makeEngine({ abortSettles: false, recoveryMs: 25 });
-  bag.set({ busy: true, spinner: { active: true } });
-  bag.pending.push({ kind: 'prompt', text: 'queued next' });
-  const res = api.abort();
-  assert.equal(res.aborted, true, 'abort dispatched to runtime');
-  assert.equal(bag.getState().busy, true, 'still busy immediately after abort (unwind pending)');
-  await wait(60);
-  assert.equal(bag.getState().busy, false, 'recovery timer force-releases busy');
-  assert.equal(bag.getState().spinner, null, 'spinner cleared on recovery');
-  assert.equal(bag.flags.leadTurnEpoch, 2, 'epoch bumped so stuck turn finally becomes a no-op');
-  assert.equal(getDrainCount() >= 1, true, 'drain re-kicked so queued prompt runs');
-  assert.equal(getNotices().some((n) => /did not settle/i.test(n.text)), true, 'user told input was restored');
-});
-
-test('starved abort abandons old drain owner before re-kicking drain', async () => {
-  const { api, bag, getDrainCount } = makeEngine({ abortSettles: false, recoveryMs: 25 });
-  bag.flags.draining = true;
-  bag.flags.drainEpoch = 10;
-  bag.set({ busy: true, spinner: { active: true } });
-  bag.pending.push({ kind: 'prompt', text: 'queued next' });
-
-  api.abort();
-  await wait(60);
-
-  assert.equal(bag.getState().busy, false);
-  assert.equal(bag.flags.draining, false, 'stuck drain lock was released only after epoch abandonment');
-  assert.equal(bag.flags.drainEpoch > 10, true, 'old drain owner invalidated');
-  assert.equal(getDrainCount() >= 1, true, 'new drain kick requested for pending work');
-});
-
-test('abort that settles in time is NOT masked by recovery', async () => {
-  const { api, bag, getNotices } = makeEngine({ abortSettles: true, recoveryMs: 25 });
-  bag.set({ busy: true, spinner: { active: true } });
-  const res = api.abort();
-  assert.equal(res.aborted, true);
-  assert.equal(bag.getState().busy, false, 'settled abort cleared busy synchronously');
-  const epochAfter = bag.flags.leadTurnEpoch;
-  await wait(60);
-  assert.equal(bag.flags.leadTurnEpoch, epochAfter, 'recovery no-ops (no epoch bump) when busy already cleared');
-  assert.equal(getNotices().some((n) => /did not settle/i.test(n.text)), false, 'no spurious recovery notice');
-});
-
-test('recovery no-ops if a newer turn already owns the store', async () => {
-  const { api, bag } = makeEngine({ abortSettles: false, recoveryMs: 25 });
-  bag.set({ busy: true });
-  api.abort();
-  bag.flags.leadTurnEpoch = 5;
-  bag.set({ busy: true, spinner: { active: true, verb: 'new turn' } });
-  await wait(60);
-  assert.equal(bag.flags.leadTurnEpoch, 5, 'recovery must not touch a newer turn epoch');
-  assert.equal(bag.getState().busy, true, 'newer turn stays busy — not force-released');
-});
-
-for (const phase of ['before first delta', 'after response progress']) {
-  test(`Esc ${phase} abandons the active completion resume`, () => {
-    const {
-      api, bag, getRequeued, getDiscardedCompletionKeys,
-    } = makeEngine({ abortSettles: true });
-    bag.flags.activePromptRestore = {
-      text: 'completion response',
-      restorable: false,
-      committed: false,
-      requeueEntries: [{
-        mode: 'pending-resume',
-        text: 'completion response',
-        abortDiscardOnAbort: true,
-      }],
-      discardExecutionPendingResumeKeys: ['execution_A'],
-    };
-    bag.set({
-      busy: true,
-      spinner: { active: true, responseLength: phase === 'after response progress' ? 24 : 0 },
-      thinking: phase === 'after response progress' ? { text: 'working' } : null,
-    });
-
-    assert.equal(api.abort().aborted, true);
-    assert.equal(bag.getState().busy, false, 'Esc releases the active completion turn');
-    assert.equal(bag.getState().spinner, null, 'spinner is cleared');
-    assert.equal(bag.getState().thinking, null, 'thinking is cleared');
-    assert.deepEqual(getRequeued(), [], 'the completion resume is not requeued');
-    assert.deepEqual(getDiscardedCompletionKeys(), ['execution_A'], 'its completion ownership is retired');
-  });
-}

package/scripts/agent-dispatch-abort-compose-test.mjs

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { composeAgentDispatchAbortSignal } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
-
-test('explore cancellation survives an active idle watchdog composite link', () => {
-    const factory = new AbortController();
-    const explore = new AbortController();
-    const idleWatchdog = new AbortController();
-    const linked = composeAgentDispatchAbortSignal([
-        factory.signal,
-        explore.signal,
-        idleWatchdog.signal,
-    ]);
-    const reason = new Error('explore ESC');
-    explore.abort(reason);
-    assert.equal(linked.signal.aborted, true);
-    assert.equal(linked.signal.reason, reason, 'per-call explore reason reaches the one session link');
-    assert.equal(idleWatchdog.signal.aborted, false, 'watchdog remains independently active');
-    linked.dispose();
-});
-
-test('an already-aborted parent reason is retained before the askSession controller swap', () => {
-    const factory = new AbortController();
-    const reason = new Error('factory canceled first');
-    factory.abort(reason);
-    const linked = composeAgentDispatchAbortSignal([factory.signal, new AbortController().signal]);
-    assert.equal(linked.signal.aborted, true);
-    assert.equal(linked.signal.reason, reason);
-    linked.dispose();
-});

package/scripts/agent-live-arg-guard-smoke.mjs

@@ -1,20 +0,0 @@
-// Standalone regression smoke for validateBuiltinArgs guard behavior.
-// Mirrors arg-guard-test.mjs style; runs with `node --test`.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
-
-test('smoke: valid read args pass and numeric strings coerce', () => {
-    const a = { path: 'x.mjs', offset: '2', limit: '10' };
-    assert.equal(validateBuiltinArgs('read', a), null);
-    assert.equal(a.offset, 2);
-    assert.equal(a.limit, 10);
-});
-
-test('smoke: non-numeric arg still errors', () => {
-    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', limit: 'nope' }), /must be an integer/);
-});
-
-test('smoke: below-min arg still errors', () => {
-    assert.match(validateBuiltinArgs('read', { path: 'x.mjs', offset: -1 }), /must be >= 0/);
-});

package/scripts/agent-live-path-suffix-smoke.mjs

@@ -1,34 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { findBySuffixStrip } from '../src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs';
-
-function makeRepo() {
-    const root = mkdtempSync(join(tmpdir(), 'mixdog-suffix-smoke-'));
-    mkdirSync(join(root, 'src', 'tui'), { recursive: true });
-    writeFileSync(join(root, 'src', 'tui', 'input-editing.mjs'), '// real file\n');
-    return root;
-}
-
-test('smoke: hallucinated absolute prefix resolves to the real repo-relative file', () => {
-    const root = makeRepo();
-    try {
-        const hallucinated = '/Users/nobody/Elsewhere/Project/ink/src/tui/input-editing.mjs';
-        const hit = findBySuffixStrip(root, hallucinated);
-        assert.equal(hit, 'src/tui/input-editing.mjs');
-    } finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-
-test('smoke: a non-existent tail resolves to null', () => {
-    const root = makeRepo();
-    try {
-        const hit = findBySuffixStrip(root, '/Users/nobody/Elsewhere/Project/does/not/here.mjs');
-        assert.equal(hit, null);
-    } finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/scripts/agent-live-toolcall-args-smoke.mjs

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-// Standalone regression smoke pinning the tool_call arguments contract used by
-// the native providers (see scripts/toolcall-args-test.mjs for the full suite).
-// Same unit-test style: synthetic inputs fed to the exported parser, asserting
-// the outcome — no network, no model. Kept minimal so it can run in isolation
-// via `node --test scripts/agent-live-toolcall-args-smoke.mjs`.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-    parseCompletedToolCallArgumentsJson,
-    isInvalidToolArgsMarker,
-    formatInvalidToolArgsResult,
-} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
-
-test('smoke: valid arguments JSON parses to the intended object', () => {
-    const out = parseCompletedToolCallArgumentsJson(
-        '{"pattern":"x","path":"src"}', 'smoke', { finishReason: 'stop' });
-    assert.deepEqual(out, { pattern: 'x', path: 'src' });
-});
-
-test('smoke: empty/missing arguments default to {}', () => {
-    assert.deepEqual(parseCompletedToolCallArgumentsJson('', 'smoke', { finishReason: 'stop' }), {});
-    assert.deepEqual(parseCompletedToolCallArgumentsJson(undefined, 'smoke'), {});
-});
-
-test('smoke: malformed args with finishReason → invalid-args marker (no throw)', () => {
-    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
-    const out = parseCompletedToolCallArgumentsJson(bareword, 'smoke', { finishReason: 'stop' });
-    assert.equal(isInvalidToolArgsMarker(out), true);
-    assert.equal(out.__rawArguments, bareword);
-    const msg = formatInvalidToolArgsResult({ name: 'grep', arguments: out });
-    assert.match(msg, /Re-issue this tool call with valid JSON arguments/);
-});
-
-test('smoke: malformed args without finishReason → retryable TruncatedStreamError', () => {
-    let threw;
-    try {
-        parseCompletedToolCallArgumentsJson('{', 'smoke');
-    } catch (err) {
-        threw = err;
-    }
-    assert.ok(threw instanceof Error, 'must throw on mid-stream truncation');
-    assert.equal(threw.code, 'TRUNCATED_STREAM');
-    assert.equal(threw.truncatedStream, true);
-});

package/scripts/agent-loop-policy-test.mjs

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-    resolveSessionMaxLoopIterations,
-    LEAD_MAX_LOOP_ITERATIONS,
-} from '../src/runtime/agent/orchestrator/agent-runtime/agent-loop-policy.mjs';
-
-// No low per-agent caps: every public/delegated agent shares the single high
-// runaway guard (LEAD_MAX_LOOP_ITERATIONS) unless a session pins its own value.
-test('agent owner session falls through to the shared runaway guard when unset', () => {
-    const cap = resolveSessionMaxLoopIterations({
-        owner: 'agent',
-        agent: 'heavy-worker',
-        permission: 'read-write',
-        maxLoopIterations: null,
-    });
-    assert.equal(cap, LEAD_MAX_LOOP_ITERATIONS);
-});
-
-test('lead session keeps the same shared ceiling when unset', () => {
-    assert.equal(resolveSessionMaxLoopIterations({ owner: 'user', agent: null }), LEAD_MAX_LOOP_ITERATIONS);
-});
-
-test('a session-pinned maxLoopIterations is honored', () => {
-    assert.equal(
-        resolveSessionMaxLoopIterations({ owner: 'agent', agent: 'heavy-worker', maxLoopIterations: 4 }),
-        4,
-    );
-});
-
-test('explicit override wins over everything', () => {
-    assert.equal(
-        resolveSessionMaxLoopIterations({ owner: 'agent', agent: 'heavy-worker', maxLoopIterations: 4 }, 50),
-        50,
-    );
-});