mixdog 0.9.62 → 0.9.64

package/scripts/execution-resume-esc-integration-test.mjs

@@ -1,176 +0,0 @@
-// Production-path regression: runtime completion notification -> feed enqueue
-// -> session drain -> real runTurn -> Esc. This deliberately uses the real
-// feed, queue, API, and turn implementations rather than fabricating restore
-// state, so ownership survives the same path used by the TUI.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { createAgentJobFeed } from '../src/tui/engine/agent-job-feed.mjs';
-import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
-import { createRunTurn } from '../src/tui/engine/turn.mjs';
-import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
-import { _clearDeliveredCompletions } from '../src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
-
-const tick = () => new Promise((resolve) => setImmediate(resolve));
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-function completion(executionId, body) {
-  return {
-    content: `Async agent task ${executionId} completed finished.\n\nResult:\n> ${body}`,
-    meta: { type: 'agent_task_result', execution_id: executionId, status: 'completed' },
-  };
-}
-
-function makeHarness() {
-  let seq = 0;
-  let notify = null;
-  let activeAsk = null;
-  let feed = null;
-  const asks = [];
-  const pending = [];
-  const itemIndexById = new Map();
-  const state = {
-    items: [],
-    queued: [],
-    busy: false,
-    commandBusy: false,
-    spinner: null,
-    thinking: null,
-    lastTurn: null,
-    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
-  };
-  const runtime = {
-    id: null,
-    toolMode: 'auto',
-    onNotification: (fn) => { notify = fn; return () => {}; },
-    consumePendingSessionReset: () => null,
-    ask: async (text, options) => new Promise((resolve, reject) => {
-      activeAsk = { text, options, reject };
-      asks.push(activeAsk);
-    }),
-    abort: () => {
-      const error = new Error('interrupted');
-      error.name = 'SessionClosedError';
-      activeAsk?.reject(error);
-      return true;
-    },
-  };
-  const bag = {
-    runtime,
-    nextId: () => `id_${++seq}`,
-    tuiDebug: () => {},
-    LEAD_TURN_TIMEOUT_MS: 300_000,
-    flags: { leadTurnEpoch: 0, drainEpoch: 0, disposed: false, draining: false, activePromptRestore: null },
-    pending,
-    pendingNotificationKeys: new Set(),
-    displayedExecutionNotificationKeys: new Set(),
-    listeners: new Set(),
-    itemIndexById,
-    getState: () => state,
-    set: (patch) => Object.assign(state, patch),
-    pushItem: (item) => {
-      state.items = [...state.items, item];
-      if (item?.id != null) itemIndexById.set(item.id, state.items.length - 1);
-    },
-    patchItem: (id, patch) => {
-      const index = state.items.findIndex((item) => item.id === id);
-      if (index < 0) return false;
-      state.items = state.items.map((item, i) => i === index ? { ...item, ...patch } : item);
-      return true;
-    },
-    replaceItems: (items) => items,
-    pushNotice: () => {},
-    pushUserOrSyntheticItem: (text, id) => {
-      state.items = [...state.items, { kind: 'injected', id, text }];
-    },
-    autoClearState: () => ({ enabled: false }),
-    agentStatusState: () => ({}),
-    routeState: () => ({}),
-    syncContextStats: () => {},
-    denyAllToolApprovals: () => {},
-    requestToolApproval: async () => ({ approved: false }),
-    markToolCallActive: () => {},
-    markToolCallDone: () => {},
-    clearActiveToolSummary: () => {},
-    patchToolCardResult: () => {},
-    flushToolResults: () => {},
-    // session-flow captures this dependency before the feed is constructed;
-    // keep that production ordering while forwarding to the live feed.
-    flushDeferredExecutionPendingResumeKick: () => feed?.flushDeferredExecutionPendingResumeKick(),
-  };
-
-  Object.assign(bag, createSessionFlow(bag));
-  feed = createAgentJobFeed({
-    runtime,
-    getState: bag.getState,
-    set: bag.set,
-    nextId: bag.nextId,
-    getDisposed: () => bag.flags.disposed,
-    patchItem: bag.patchItem,
-    enqueue: (...args) => bag.enqueue(...args),
-    drain: (...args) => bag.drain(...args),
-    pushUserOrSyntheticItem: bag.pushUserOrSyntheticItem,
-    makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
-    getPending: () => pending,
-    agentStatusState: bag.agentStatusState,
-    displayedExecutionNotificationKeys: bag.displayedExecutionNotificationKeys,
-    pushNotice: bag.pushNotice,
-  });
-  Object.assign(bag, feed);
-  bag.runTurn = createRunTurn(bag);
-  const api = createEngineApiA(bag);
-  feed.subscribeRuntimeNotifications();
-
-  return {
-    api,
-    state,
-    asks,
-    deliver: (event) => notify(event),
-    activeAsk: () => activeAsk,
-  };
-}
-
-for (const phase of ['before first delta', 'after response progress']) {
-  test(`runtime completion Esc ${phase} does not restart it, while a new completion wakes`, async () => {
-    _clearDeliveredCompletions();
-    const harness = makeHarness();
-
-    const first = completion('execution_A', 'first result');
-    harness.deliver(first);
-    await tick();
-    assert.equal(harness.asks.length, 1, 'runtime notification drained into a real turn');
-    assert.match(harness.activeAsk().text, /first result/, 'completion body reached runtime.ask');
-    assert.equal(first.modelVisibleDelivered, true, 'notification was acknowledged on the TUI path');
-
-    if (phase === 'after response progress') {
-      harness.activeAsk().options.onTextDelta('partial response\n');
-      await wait(40);
-      assert.equal(
-        harness.state.streamingTail?.kind === 'assistant'
-          && /partial response/.test(harness.state.streamingTail.text),
-        true,
-        'response progress reached the dedicated live tail',
-      );
-    }
-
-    assert.equal(harness.api.abort().aborted, true, 'Esc aborts the active runTurn');
-    await tick();
-    assert.equal(harness.state.busy, false, 'busy clears after the real abort unwind');
-    assert.equal(harness.state.spinner, null, 'spinner clears after Esc');
-    assert.equal(harness.state.thinking, null, 'thinking clears after Esc');
-    assert.equal(harness.state.streamingTail == null, true, 'Esc leaves no orphaned streaming tail');
-
-    harness.deliver(completion('execution_A', 'duplicate retry'));
-    await tick();
-    assert.equal(harness.asks.length, 1, 'duplicate execution delivery cannot restart the aborted completion');
-
-    harness.deliver(completion('execution_B', 'later result'));
-    await tick();
-    assert.equal(harness.asks.length, 2, 'a genuinely new execution still wakes a turn');
-    assert.match(harness.activeAsk().text, /later result/);
-
-    // Finish the second intentionally-open mocked provider request.
-    harness.api.abort();
-    await tick();
-  });
-}

package/scripts/explore-bench-tmp.mjs

@@ -1,36 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { runExplore } from '../src/standalone/explore-tool.mjs';
-// Attribute LLM send time (not just wall) for this high-fanout batch.
-process.env.MIXDOG_AGENT_TRACE_TIMING = '1';
-const queries = [
-  'standalone explore tool implementation entry point',
-  'V4A patch format parsing/conversion implementation',
-  'recall memory entries persistent store (sqlite) read/query implementation',
-  'output styles: how style definitions are loaded and applied at session runtime',
-  'Discord backend outbound message send implementation',
-  'shell command destructive/danger policy scan before execution',
-  'where does mixdog store per-user data and sessions on this machine (out of repo)',
-  'channel runtime crash logging write path',
-];
-const t0 = Date.now();
-const res = await runExplore({ query: queries, cwd: 'C:/Project/mixdog' }, { callerCwd: 'C:/Project/mixdog' });
-console.log('BATCH_ELAPSED_MS', Date.now() - t0);
-const txt = res.content?.[0]?.text || '';
-console.log('FAILED_COUNT', (txt.match(/EXPLORATION_FAILED/g) || []).length);
-// Sum send_ms from loop rows emitted since t0 → LLM time vs the wall above.
-const tracePath = process.env.MIXDOG_AGENT_TRACE_PATH
-  || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
-let sendMs = 0, sends = 0; const sessions = new Set();
-if (existsSync(tracePath)) {
-  for (const line of readFileSync(tracePath, 'utf8').split('\n')) {
-    if (!line) continue;
-    try {
-      const r = JSON.parse(line);
-      if (r.ts >= t0 && r.kind === 'loop' && r.agent === 'explorer') { sendMs += Number(r.send_ms) || 0; sends++; sessions.add(r.session_id); }
-    } catch { /* skip */ }
-  }
-}
-console.log('LLM_SEND_MS_TOTAL', sendMs, 'sends', sends, 'sessions', sessions.size);
-process.exit(0);

package/scripts/explore-bench.mjs

@@ -1,248 +0,0 @@
-// Explore quality bench — round-based tuning harness.
-//
-// Runs a fixed query set through runExplore against this repo, then reads
-// agent-trace.jsonl to report per-session tool-call counts, wall time, and
-// anchor quality. Usage:
-//   node scripts/explore-bench.mjs [roundLabel]
-// Fresh process per run = no in-memory result cache carryover.
-import { readFileSync, existsSync } from 'node:fs';
-import { join, isAbsolute } from 'node:path';
-import { homedir } from 'node:os';
-import { runExplore } from '../src/standalone/explore-tool.mjs';
-
-const ROUND = process.argv[2] || 'r0';
-const CWD = 'C:/Project/mixdog';
-
-// Anchor helpers: an anchor line carries a `path:line`. Strict quality =
-// expected token must land ON such a line (not merely somewhere in the text),
-// and anchors===0 is always a miss (except expectFail). Spot-accuracy verifies
-// the referenced file exists and the line number is within the file length.
-function anchorLinesOf(text) {
-  return text.split('\n').filter((l) => /:\d+/.test(l));
-}
-// Variant-aware token matching for the fabricated-line guard. Split
-// camelCase and snake_case/kebab joins into atomic sub-tokens, then compare
-// on a light stem so plural/verb forms unify (importance/importanceScore/
-// chunk_importance -> {importance,score,chunk}; scoring~score, memories~memory).
-// Matching is exact stem-equality of sub-tokens (never substring), so it does
-// not loosen into generic-word overlap.
-function splitSubtokens(s) {
-  return String(s)
-    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // camelCase boundary
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2') // ACRONYMWord boundary
-    .split(/[^A-Za-z0-9]+/) // snake_case / kebab / punctuation
-    .map((t) => t.toLowerCase())
-    .filter(Boolean);
-}
-function stemToken(t) {
-  if (t.length <= 4) return t;
-  return t
-    .replace(/ies$/, 'y')
-    .replace(/(ings|ing|edly|ed|es|ly|s)$/, '')
-    .replace(/e$/, '');
-}
-function checkAnchorLine(line, ctxTokens = []) {
-  const m = line.match(/([A-Za-z0-9_.\/\\-]+):(\d+)/);
-  if (!m) return null; // no parseable path:line
-  const p = m[1];
-  const ln = Number(m[2]);
-  const full = isAbsolute(p) ? p : join(CWD, p);
-  if (!existsSync(full)) return false;
-  try {
-    const fileLines = readFileSync(full, 'utf8').split('\n');
-    if (!(ln >= 1 && ln <= fileLines.length)) return false;
-    // Fabricated-line guard: the cited line's ±2 window must contain a
-    // query/expected token, so a plausible-but-wrong line number fails.
-    if (ctxTokens.length) {
-      // ±2 lines around the 1-based cited line (indices ln-3 .. ln+1 inclusive).
-      const win = fileLines.slice(Math.max(0, ln - 3), ln + 2).join('\n');
-      const winStems = [...new Set(splitSubtokens(win).map(stemToken))];
-      const wantStems = ctxTokens.map((t) => stemToken(t.toLowerCase()));
-      // Exact stem-equality unifies plural/verb variants; a prefix relation
-      // additionally bridges derivational forms (compact/compaction) without
-      // matching generic filler. Guard the bridge so a short generic line
-      // token can't satisfy a longer wanted token (impl~implementation,
-      // clas~classifier): require the shorter stem >=5 chars AND a
-      // shorter/longer length ratio >=0.6.
-      const prefixBridge = (s, w) => {
-        if (!(s.startsWith(w) || w.startsWith(s))) return false;
-        const short = Math.min(s.length, w.length);
-        const long = Math.max(s.length, w.length);
-        return short >= 5 && short / long >= 0.6;
-      };
-      const hitStem = (w) => winStems.some((s) => s === w || prefixBridge(s, w));
-      if (!wantStems.some(hitStem)) return false;
-    }
-    return true;
-  } catch { return false; }
-}
-
-// High-fanout timing attribution: emit lightweight per-iteration send_ms
-// loop rows (no verbose payload estimate) so we can split LLM send time
-// from tool time under the parallel round below. Trace-only; no behavior
-// or provider change.
-if (!process.env.MIXDOG_AGENT_TRACE_TIMING) process.env.MIXDOG_AGENT_TRACE_TIMING = '1';
-
-// Representative locator queries with ground truth: expect = substrings, at
-// least one must appear in the anchor output (quality hit). expectFail = the
-// correct answer is EXPLORATION_FAILED (miss discipline).
-const QUERIES = [
-  {
-    q: 'where is the tool-call stall watchdog policy resolved and what defaults does it use',
-    expect: ['agent-progress-watchdog', 'stall-policy'],
-  },
-  {
-    q: 'session compact / smart compact trigger threshold logic',
-    expect: ['compact'],
-  },
-  {
-    q: 'where are hidden agent tool schema profiles defined (read / read-write-search)',
-    expect: ['agent-dispatch', 'agents.json', 'internal-agents'],
-  },
-  {
-    q: 'recall memory chunk importance scoring implementation',
-    expect: ['importance', 'memory'],
-  },
-  {
-    q: 'websocket reconnect backoff handling',
-    expect: ['openai-oauth-ws', 'retry-classifier'],
-  },
-  // ── extended set: symbol-exact, filename, error-string, korean, flow, config ──
-  {
-    q: 'buildExplorerPrompt definition', // exact known symbol
-    expect: ['explore-tool'],
-  },
-  {
-    q: 'where does the explore tool cache results and what is the TTL',
-    expect: ['explore-tool'],
-  },
-  {
-    q: 'error text "maintenance route unresolved for agent" — where is it thrown',
-    expect: ['agent-dispatch'],
-  },
-  {
-    q: '\uC5D0\uC774\uC804\uD2B8 \uC138\uC158\uC758 \uCD5C\uB300 \uB8E8\uD504 \uBC18\uBCF5 \uD69F\uC218\uB294 \uC5B4\uB514\uC11C \uC815\uD574\uC838?', // korean concept query
-    expect: ['agent-loop-policy'],
-  },
-  {
-    q: 'how does a fixed agent slot map to a workflow slot (explore/explorer)',
-    expect: ['session-runtime/workflow', 'FIXED_AGENT_SLOTS'],
-  },
-  {
-    q: 'where is the mixdog config json file path resolved (data dir)',
-    expect: ['config', 'plugin-paths'],
-  },
-  {
-    // path-only class: the correct answer is a verified file/dir location on
-    // disk; a bare path (no :line) is an allowed HIT for this query.
-    q: 'where does mixdog store background shell job stdout logs on disk',
-    expect: ['shell-jobs', 'shell-job-paths', 'getShellJobsDir', 'shellJobStdout'],
-    pathOnly: true,
-  },
-  {
-    q: 'GraphQL schema stitching resolver implementation', // not in this repo
-    expectFail: true,
-  },
-];
-
-function tracePath() {
-  return process.env.MIXDOG_AGENT_TRACE_PATH
-    || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
-}
-
-function readTraceSince(ts) {
-  const p = tracePath();
-  if (!existsSync(p)) return [];
-  const rows = [];
-  for (const line of readFileSync(p, 'utf8').split('\n')) {
-    if (!line) continue;
-    try {
-      const r = JSON.parse(line);
-      // Keep every row since ts; explorer-session attribution happens at
-      // aggregation time.
-      if (r.ts >= ts) rows.push(r);
-    } catch { /* skip */ }
-  }
-  return rows;
-}
-
-const t0 = Date.now();
-// Parallel round: all queries fire at once. Per-session trace attribution is
-// by session_id so counts stay correct; per-query ms includes queueing.
-const results = await Promise.all(QUERIES.map(async ({ q, expect, expectFail, pathOnly }) => {
-  const qt0 = Date.now();
-  const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
-  const text = res?.content?.[0]?.text || '';
-  const aLines = anchorLinesOf(text);
-  const anchors = aLines.length;
-  const failed = /EXPLORATION_FAILED/.test(text);
-  // Context tokens for the fabricated-line guard: expanded expected + query
-  // words, length>=4 to drop filler.
-  const ctxTokens = [
-    ...(expect || []).flatMap((e) => e.toLowerCase().split(/[^a-z0-9]+/)),
-    ...q.toLowerCase().split(/[^a-z0-9]+/),
-  ].filter((t) => t.length >= 4);
-  // Spot-check up to 2 anchors per query for file/line validity + line context.
-  let badAnchors = 0;
-  for (const l of aLines.slice(0, 2)) {
-    if (checkAnchorLine(l, ctxTokens) === false) badAnchors++;
-  }
-  const allLines = text.split('\n').filter((l) => l.trim());
-  // Strict hit: expected token must appear ON an anchor line (>=1 anchor). For
-  // the path-only class, an expected token on any verified path line HITs even
-  // without :line. expectFail wants EXPLORATION_FAILED with zero anchors.
-  const hit = expectFail
-    ? (failed && anchors === 0)
-    : pathOnly
-      ? (!failed && (expect || []).some(
-          (e) => allLines.some((l) => l.toLowerCase().includes(e.toLowerCase())),
-        ))
-      : (!failed && anchors > 0 && (expect || []).some(
-          (e) => aLines.some((l) => l.toLowerCase().includes(e.toLowerCase())),
-        ));
-  return { q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, badAnchors, bytes: text.length };
-}));
-
-// Identify explorer sessions from trace rows, then attribute both tool calls
-// and LLM send time per session.
-const rows = readTraceSince(t0);
-const explorerSessions = new Set(
-  rows.filter((r) => r.agent === 'explorer').map((r) => r.session_id)
-);
-const bySession = new Map();
-for (const r of rows) {
-  if (r.kind !== 'tool' || !explorerSessions.has(r.session_id)) continue;
-  const s = bySession.get(r.session_id) || { calls: 0, tools: [] };
-  s.calls++; s.tools.push(r.tool_name);
-  bySession.set(r.session_id, s);
-}
-const callCounts = [...bySession.values()].map((s) => s.calls).sort((a, b) => a - b);
-const p50 = callCounts[Math.floor(callCounts.length / 2)] ?? 0;
-
-// LLM send-time attribution from loop rows (kind='loop', send_ms), emitted
-// under MIXDOG_AGENT_TRACE_TIMING. Under the parallel round, sends overlap
-// wall time, so send/wall > 1 quantifies provider contention.
-const sendBySession = new Map();
-for (const r of rows) {
-  if (r.kind !== 'loop' || !explorerSessions.has(r.session_id)) continue;
-  const cur = sendBySession.get(r.session_id) || { sends: 0, ms: 0 };
-  cur.sends++; cur.ms += Number(r.send_ms) || 0;
-  sendBySession.set(r.session_id, cur);
-}
-const sendMsPer = [...sendBySession.values()].map((s) => s.ms).sort((a, b) => a - b);
-const sendTotal = sendMsPer.reduce((a, b) => a + b, 0);
-const sendP50 = sendMsPer[Math.floor(sendMsPer.length / 2)] ?? 0;
-const sendMax = sendMsPer[sendMsPer.length - 1] ?? 0;
-const sendCount = [...sendBySession.values()].reduce((a, s) => a + s.sends, 0);
-
-console.log(`\n=== explore-bench round=${ROUND} ===`);
-for (const r of results) {
-  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} bad=${r.badAnchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
-}
-const badTotal = results.reduce((a, r) => a + r.badAnchors, 0);
-console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits (strict)  bad-anchors=${badTotal}`);
-console.log(`  sessions=${bySession.size} toolcalls p50=${p50} max=${callCounts[callCounts.length - 1] ?? 0} total=${callCounts.reduce((a, b) => a + b, 0)}`);
-for (const [id, s] of bySession) console.log(`    ${id.slice(-8)}: ${s.tools.join(',')}`);
-const wallMs = Date.now() - t0;
-console.log(`  llm-send: sessions=${sendBySession.size} sends=${sendCount} ms/session p50=${sendP50} max=${sendMax} total=${sendTotal}`);
-console.log(`  wall total=${(wallMs / 1000).toFixed(1)}s  send/wall=${wallMs > 0 ? (sendTotal / wallMs).toFixed(2) : '0.00'}x`);