mixdog 0.9.19 → 0.9.21

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tribgames
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,49 +1,110 @@
 # mixdog
 
-Standalone coding-agent CLI/TUI for running a multi-provider AI workspace from
-one terminal.
+[![npm](https://img.shields.io/npm/v/mixdog)](https://www.npmjs.com/package/mixdog)
+![node](https://img.shields.io/badge/node-%3E%3D22-brightgreen)
+![license](https://img.shields.io/badge/license-MIT-blue)
 
-Mixdog combines an Ink-based terminal UI, model/provider routing, workflow
-agents, MCP/plugin/skill loading, memory, web search, channel integrations, and
-repo-focused tools for reading, editing, testing, and reviewing code.
+Standalone coding-agent CLI/TUI that runs an orchestrated, multi-provider
+agent workflow from one terminal — built for maximum performance at minimum
+cost.
 
-## Highlights
+Mixdog combines an Ink-based terminal UI, per-role model routing across
+providers, workflow agents, MCP/plugin/skill/hook support, lightweight
+memory, web search, channel integrations, and repo-native tools for reading,
+editing, testing, and reviewing code.
 
-- **Multi-provider model picker** for Anthropic, OpenAI, Google/Gemini, xAI/Grok,
-  DeepSeek, OpenCode Go, OAuth-backed providers, OpenAI-compatible APIs, Ollama,
-  and LM Studio/local endpoints.
-- **Live model catalog** from provider `/models` endpoints, enriched with
-  LiteLLM/models.dev metadata for context windows, output limits, pricing, tool
-  support, reasoning, web search, and recency.
-- **Full-screen TUI** with slash commands, provider setup, model/workflow
-  pickers, usage dashboards, statusline integration, resumable sessions, and
-  detailed tool cards.
-- **Workflow delegation** through `/agent` and the `agent` tool, including
-  worker, heavy-worker, reviewer, debugger, maintainer, and explorer roles.
-- **Repo-native tools** for `read`, `grep`, `glob`, `list`, `code_graph`,
-  `apply_patch`, `shell`, `cwd`, `explore`, web search, and memory recall.
-- **Remote/event workflows** via optional Discord channel, webhook, schedule,
-  and channel-management integrations.
+## Quick start
 
-## Requirements
-
-- Node.js >= 22
-
-## Install
+Requires Node.js >= 22.
 
 ```bash
 npm install -g mixdog
-mixdog --help
+mixdog
 ```
 
+First run walks you through onboarding: provider auth, model pick, and
+workflow setup. Re-run it anytime with `mixdog --onboarding`.
+
+## Terminal-Bench 2.1 — 89.9% (self-reported)
+
+![Terminal-Bench 2.1 leaderboard with mixdog](https://raw.githubusercontent.com/tribgames/mixdog/main/benchmarks/terminal-bench-2.1/tb21-leaderboard.svg)
+
+Single-run score of **80/89 = 89.9%** (k=1) on
+`terminal-bench/terminal-bench-2-1`, using a cost-reduced per-role routing
+config:
+
+| Role                | Model           | Effort      |
+|---------------------|-----------------|-------------|
+| Lead (orchestrator) | Claude Fable 5  | high        |
+| Explorer            | Claude Haiku 4.5| default     |
+| Worker              | Claude Opus 4.8 | medium      |
+| Heavy worker        | Claude Opus 4.8 | high        |
+| Reviewer            | GPT-5.5         | high (fast) |
+
+Against published model scores this places second overall — behind GPT-5.6
+Sol Ultra (91.9%), ahead of GPT-5.6 Sol (88.8%) and Claude Mythos 5 (88%),
+and well above the same primary model run standalone (Claude Fable 5,
+84.3%). Measured once (k=1) due to cost, so treat it as indicative — a
+max-effort k=5 run is planned and is expected to land higher. Per-task
+results, raw Harbor jobs, and the harness adapter live in
+`benchmarks/terminal-bench-2.1/`.
+
+Full transparency: 4 tasks refused by the primary model's safety layer were
+re-run routed to Claude Opus 4.8 (effort xhigh) and passed; timeouts and
+task resources were left unmodified. Raw Harbor `result.json`/`config.json`
+for every constituent run are included.
+
+## Why mixdog
+
+**Maximum performance at minimum cost**
+
+- Orchestrated agent workflow that mixes providers and models per role, so
+  each step runs on the cheapest model that can do the job well.
+- Cache-aware prompt layout and aggressive context savings across turns.
+- Lean output policy plus fine-grained session management: compaction,
+  resumable sessions, and usage dashboards.
+- A custom harness with tool-call routing tuned for the fewest, most
+  effective calls (`code_graph`, batched `read`/`grep`, windowed reads).
+
+**Any provider**
+
+- Anthropic, OpenAI, Google/Gemini, xAI/Grok, DeepSeek, OpenCode Go,
+  OAuth-backed providers, OpenAI-compatible APIs, Ollama, and LM Studio/local
+  endpoints.
+- Live model catalog from provider `/models` endpoints, enriched with
+  LiteLLM/models.dev metadata for context windows, output limits, pricing,
+  tool support, reasoning, and recency.
+- Customizable web search and repo exploration tools.
+
+**Any environment**
+
+- Full-screen TUI with slash commands, provider setup, model/workflow
+  pickers, statusline integration, and detailed tool cards — plus headless
+  role mode for scripting.
+- Optional Discord/Telegram channels, webhook endpoints, cron schedules, and
+  voice-message transcription for remote/event-driven workflows.
+
+**Memory**
+
+- Lightweight memory restores prior work context across sessions.
+- Important memories are automatically promoted — and demoted when stale.
+
+**Agent-ecosystem compatible**
+
+- Skills, MCP servers, hooks, and plugins load through standard-compatible
+  interfaces.
+- Workflow delegation through the `agent` tool and `/agents`: worker,
+  heavy-worker, reviewer, debugger, maintainer, and explorer roles.
+
+## Run
+
 For local development from this checkout:
 
 ```bash
 npm install
+npm start
 ```
 
-## Run
-
 ```bash
 # Start the TUI in the current project
 mixdog
@@ -73,13 +134,14 @@ mixdog reviewer "review the current diff"
 Common slash commands:
 
 ```text
-/help              show help
 /providers         configure provider auth and local endpoints
-/model             choose provider/model, effort, and fast mode
+/model             choose the main provider/model (/effort, /fast tune it)
 /workflow          choose the active workflow
-/agents            show available workflow agents
-/agent             manage active agent tasks
-/mode              switch tool surface: full | readonly
+/agents            show workflow agents and per-agent model overrides
+/setting           open the runtime settings hub
+/mcp               manage MCP servers and tools
+/skills            choose a skill for the next request
+/channels          manage Discord/Telegram, schedules, webhooks, voice
 /compact           compact older conversation context
 /clear             reset the conversation and screen
 /OutputStyle       show or switch Lead output style
@@ -156,3 +218,7 @@ vendor/
 
 `docs/` is not included in the published package unless `package.json#files` is
 changed.
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -35,7 +35,7 @@
     "prepack": "npm run build:tui",
     "start": "node src/cli.mjs",
     "smoke": "node scripts/smoke.mjs",
-    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars",
+    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard",
     "smoke:boot": "node scripts/boot-smoke.mjs",
     "smoke:compact": "node scripts/compact-smoke.mjs",
     "smoke:loop": "node scripts/smoke-loop.mjs",
@@ -45,6 +45,7 @@
     "smoke:output": "node scripts/output-style-smoke.mjs",
     "smoke:tui": "node scripts/tui-render-smoke.mjs",
     "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:providers": "node --test scripts/provider-toolcall-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",

package/scripts/build-tui.mjs

@@ -44,6 +44,12 @@ await build({
   // Only `ink` is redirected to Mixdog's checked-in renderer instead of
   // node_modules/ink.
   packages: 'external',
+  // Bundled CJS helpers (e.g. src/lib/mixdog-debug.cjs) compile to esbuild's
+  // __require shim, which throws "Dynamic require of ..." in plain ESM.
+  // Provide a real module-scope require so those requires resolve at runtime.
+  banner: {
+    js: "import { createRequire as __mixdogCreateRequire } from 'node:module';\nconst require = __mixdogCreateRequire(import.meta.url);",
+  },
   external: [
     '../vendor/*',
     '../../vendor/*',

package/scripts/hook-bus-test.mjs

@@ -142,6 +142,14 @@ console.log(JSON.stringify({ hookSpecificOutput: {
     },
   });
 
+  // Untrusted project: executable project hooks must be neutered (security gate).
+  const busUntrusted = createStandaloneHookBus({ dataDir: join(root, 'data-untrusted') });
+  const blocked = await busUntrusted.beforeTool({ sessionId: 'sess_test', cwd: root, name: 'shell', args: { command: 'echo ok' } });
+  assert.equal(blocked, null);
+
+  // Trusted project: user-level trustedProjects list re-enables project command hooks.
+  mkdirSync(join(root, 'data-mixdog'), { recursive: true });
+  writeJson(join(root, 'data-mixdog', 'config.json'), { trustedProjects: [root] });
   const busWithMixdog = createStandaloneHookBus({ dataDir: join(root, 'data-mixdog') });
   const denied = await busWithMixdog.beforeTool({ sessionId: 'sess_test', cwd: root, name: 'shell', args: { command: 'echo ok' } });
   assert.equal(denied.action, 'deny');

package/scripts/log-writer-guard-smoke.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * scripts/log-writer-guard-smoke.mjs — unbounded `.log` writer regression gate.
+ *
+ * A new `.log` file name that lands in src/ without being covered by one of the
+ * bounded-writer contracts is an unbounded-growth footgun: the sibling-GC in
+ * mixdog-debug.cjs only prunes names it knows (canonical set + stale-sibling
+ * regexes), and the worker-boot rotation loop only rotates its explicit list.
+ * Any other steady `.log` append grows without limit.
+ *
+ * This scans src/ for string-literal `.log` file names (the targets that feed
+ * appendFile/appendFileSync/createWriteStream) and fails when a name is not:
+ *   - in the canonical set (parsed live from mixdog-debug.cjs), or
+ *   - in the worker-boot rotation list (parsed live from worker-bootstrap.mjs), or
+ *   - matched by the dynamic / per-PID sibling patterns, or
+ *   - in the explicit in-script allowlist below.
+ *
+ * Run:  node scripts/log-writer-guard-smoke.mjs   (or `npm run smoke:logguard`)
+ * Exit: 0 = every writer covered, 1 = uncovered `.log` name(s) found.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const SRC = join(ROOT, 'src');
+// `dist` = built TUI bundle (generated from src/tui/*); vendor is third-party.
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'vendor']);
+const SCAN_EXT = /\.(mjs|cjs|js|jsx)$/;
+
+// `.log` file-name targets. Two shapes, both bounded to real string content:
+//   STATIC   — a quoted/backtick literal (`'boot.log'`, `"logs\\a.log"`). The
+//              `+` stem keeps us off the bare `.endsWith('.log')` guards.
+//   TEMPLATE — a `${...}` interpolation immediately followed by a static `.log`
+//              tail (`${jobId}.stdout.log`, `${root}.log`). The dynamic prefix
+//              is unverifiable, so the trailing literal (down to bare `.log`)
+//              must be covered/allowlisted or it fails.
+// Separators (`/` and `\`) are captured; basename() reduces to the file name.
+const STATIC_RE = /['"`]([\w.\-/\\]+\.log)\b/g;
+const TEMPLATE_RE = /\$\{[^}]*\}([\w.\-/\\]*\.log)\b/g;
+
+/** Last path segment, splitting on both POSIX and Windows separators. */
+function basename(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1];
+}
+
+/** Parse a `new Set([...])` / array of quoted `.log` names out of a source file. */
+function parseLogNames(file, anchor) {
+  let src;
+  try { src = readFileSync(file, 'utf8'); } catch { return []; }
+  const at = src.indexOf(anchor);
+  if (at === -1) return [];
+  const tail = src.slice(at, at + 2000);
+  const end = tail.indexOf(']');
+  const block = end === -1 ? tail : tail.slice(0, end);
+  return [...block.matchAll(/['"]([\w.\-]+\.log)['"]/g)].map((m) => m[1]);
+}
+
+// ── Covered names ────────────────────────────────────────────────────
+// Parsed live so a name added to either contract auto-covers here.
+const canonical = new Set(
+  parseLogNames(join(SRC, 'lib/mixdog-debug.cjs'), 'CANONICAL_PLUGIN_LOG_NAMES'),
+);
+const rotation = new Set(
+  parseLogNames(join(SRC, 'runtime/channels/lib/worker-bootstrap.mjs'), '_rotLog of ['),
+);
+
+// Explicitly bounded / non-plugin-dir writers that live outside the sibling-GC
+// contract by design (size-rotated in place, per-job spill, one-shot probes).
+const ALLOWLIST = new Set([
+  'session-start-critical.log',      // size-bounded via rotateBoundedLog()
+  'mixdog-ws-upgrade-probe.log',     // one-shot WS upgrade probe dump
+  '.stdout.log',                     // shell-jobs per-jobId spill (`${jobId}.stdout.log`)
+  '.stderr.log',                     // shell-jobs per-jobId spill (`${jobId}.stderr.log`)
+]);
+
+// Dynamic / per-PID sibling names (never literal, but keep the contract explicit).
+const DYNAMIC_RE = [
+  /^(channels|memory)-worker\.\d+\.\d+\.log$/,
+  /-worker\.\d+\.\d+\.log$/,
+  /^mcp-debug\.\d+\.\d+\.log$/,
+  /^supervisor\.\d+\.log$/,
+];
+
+function isCovered(name) {
+  return (
+    canonical.has(name) ||
+    rotation.has(name) ||
+    ALLOWLIST.has(name) ||
+    DYNAMIC_RE.some((re) => re.test(name))
+  );
+}
+
+function* walk(dir) {
+  let entries;
+  try { entries = readdirSync(dir); } catch { return; }
+  for (const name of entries) {
+    if (SKIP_DIRS.has(name)) continue;
+    const p = join(dir, name);
+    if (statSync(p).isDirectory()) yield* walk(p);
+    else if (SCAN_EXT.test(name)) yield p;
+  }
+}
+
+const offenders = [];
+let scanned = 0;
+for (const file of walk(SRC)) {
+  scanned++;
+  const lines = readFileSync(file, 'utf8').split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    for (const re of [STATIC_RE, TEMPLATE_RE]) {
+      for (const m of lines[i].matchAll(re)) {
+        const name = basename(m[1]);
+        if (isCovered(name)) continue;
+        offenders.push(`${relative(ROOT, file)}:${i + 1} — uncovered \`.log\` writer target \`${name}\``);
+      }
+    }
+  }
+}
+
+if (offenders.length > 0) {
+  console.error('log-writer-guard: FAIL — uncovered unbounded `.log` writer(s):');
+  for (const line of offenders) console.error(`  ${line}`);
+  console.error(
+    `log-writer-guard: ${offenders.length} offender(s). Add the name to CANONICAL_PLUGIN_LOG_NAMES ` +
+    '(mixdog-debug.cjs), the worker-boot rotation list, or the ALLOWLIST in this script.',
+  );
+  process.exit(1);
+}
+console.log(`log-writer-guard: ok — ${scanned} files scanned, every \`.log\` writer covered`);

package/scripts/reactive-compact-persist-smoke.mjs

@@ -102,23 +102,39 @@ try {
   thrownCode = err?.code || null;
 }
 
+// Non-agent sessions hard-lock to recall-fasttrack (7/3 commit). This smoke has
+// no memory subsystem registered, so ingest_session + search both fail — the
+// exact "memory pipeline broken" condition the fail-safe must cover. Assert the
+// fail-safe: recall-fasttrack aborts rather than dropping head behind a false
+// "Full history is in memory" notice, so no context is silently lost and the
+// overflow is surfaced instead of being masked by an empty summary shell.
 assert(threw, 'askSession should surface overflow error');
 assert(thrownCode === 'AGENT_CONTEXT_OVERFLOW', `expected AGENT_CONTEXT_OVERFLOW, got ${thrownCode}`);
-assert(mainSendCount === 2, `expected 2 main sends after reactive retry, got ${mainSendCount}`);
-assert(compactSendCount === 1, `expected 1 compact send, got ${compactSendCount}`);
+// Recall-fasttrack aborted (memory failed), so the reactive retry never produced
+// a smaller transcript to re-send: exactly one failing main send, no LLM compact.
+assert(mainSendCount === 1, `expected 1 main send (reactive retry aborted by fail-safe), got ${mainSendCount}`);
+assert(compactSendCount === 0, `expected 0 compact sends on recall-fasttrack path, got ${compactSendCount}`);
 
 const reloaded = loadSession(sessionId);
 assert(reloaded, 'session should reload from store after overflow');
-assert((reloaded.messages || []).length < beforeCount + 1, 'persisted transcript should reflect compaction shrink');
+// Fail-safe keeps full history for the cycle: current turn appended, nothing dropped.
+assert(
+  (reloaded.messages || []).length === beforeCount + 1,
+  `full history should be preserved on fail-safe abort (expected ${beforeCount + 1}, got ${(reloaded.messages || []).length})`,
+);
 const summary = (reloaded.messages || []).find(
   (m) => m?.role === 'user' && typeof m.content === 'string' && m.content.startsWith(SUMMARY_PREFIX),
 );
-assert(summary, 'compacted transcript with SUMMARY_PREFIX should persist after overflow error');
+assert(!summary, 'no empty summary shell should be injected when the memory pipeline fails');
+assert(
+  !(reloaded.messages || []).some((m) => typeof m?.content === 'string' && m.content.includes('Full history is in memory')),
+  'no false "Full history is in memory" recall notice should be injected on fail-safe abort',
+);
 assert(
   (reloaded.messages || []).some((m) => m?.role === 'user' && String(m.content).includes('current overflow task must stay verbatim')),
   'current user turn should remain in persisted transcript',
 );
-assert(reloaded.compaction?.lastStage !== 'compacting', 'compaction lastStage should not remain stuck on compacting');
-assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact persist');
+assert(reloaded.compaction?.lastStage === 'overflow_failed', `compaction lastStage should be overflow_failed, got ${reloaded.compaction?.lastStage}`);
+assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact abort');
 
 process.stdout.write('reactive-compact-persist smoke passed ✓\n');

package/scripts/recall-bench-cases.json

@@ -6,6 +6,5 @@
   { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "드라이런 델타 합산", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["드라이런"], "topN": 5 } },
   { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote 싱글톤 좌석", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["싱글톤"], "topN": 5 } },
   { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "오늘 진행한 작업", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
-  { "id": "negative-projectaa", "label": "negative: every row must literally mention the term (no filler)", "args": { "query": "ProjectAA 밸런스", "limit": 10 }, "expect": { "kind": "allContain", "allContain": ["projectaa"] } },
   { "id": "xlang-embedding-crash", "label": "cross-language: embedding worker crash (strict topN)", "args": { "query": "embedding worker crash", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["embedding"], "topN": 3 } }
 ]

package/scripts/recall-quality-cases.json

@@ -5,8 +5,7 @@
   { "id": "q-recall-general", "label": "bare recall keyword", "args": { "query": "recall" }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } },
   { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
   { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "캐시 개선" }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-battle-balance", "label": "ProjectAA topic", "args": { "query": "ProjectAA" }, "expect": { "kind": "results", "topNContains": ["ProjectAA"], "topN": 5 } },
-  { "id": "q-fanout-recall-battle", "label": "fan-out array query cache+ProjectAA", "args": { "query": ["캐시 개선", "ProjectAA"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "ProjectAA"], "topN": 10 } },
+  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["캐시 개선", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "recall"], "topN": 10 } },
   { "id": "q-short-2tok-cycle", "label": "short 2-token cycle1 query", "args": { "query": "cycle1 drain", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["cycle1"], "topN": 3 } },
   { "id": "q-recall-scope-project", "label": "project-scoped recall query", "args": { "query": "recall", "cwd": "C:\\Project\\mixdog" , "limit": 10 }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } }
 ]