mixdog 0.9.118 → 0.9.119

package/README.md

@@ -44,13 +44,11 @@ harnesses — **78/89** vs Claude Code's **77/89** (within single-run noise)
 and **75/89** matching Codex CLI — while finishing faster, ending leaner,
 and costing less.
 
-Each comparison matches the primary model and reasoning level on
-both sides, comparing each product as shipped: mixdog routes scoped
-read-only Explorer lookups to a smaller model, mirroring Claude Code's
-built-in Explore subagent (Haiku 4.5 by default in the 2.1.x baseline).
-Codex CLI ships no equivalent helper — the Sol-led mixdog run used GPT-5.6
-Luna for that scoped Explorer work. Results are self-reported single runs
-(`k=1`, 2026-08), not leaderboard submissions.
+The published mixdog runs are strict single-model benchmarks: one primary
+model, one session, no sub-agent delegation or helper-model lookups. Each
+comparison matches the primary model and reasoning level against the native
+harness's standard run. Results are self-reported single runs (`k=1`,
+2026-08), not leaderboard submissions.
 
 #### Claude Opus 5 vs Claude Code
 
@@ -105,9 +103,9 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
   below).
 - Installable web app over relay pairing — scan a QR code to open your
   running sessions in a phone browser and keep going from any network.
-- Optional Discord/Telegram channels, webhook endpoints, and cron schedules
-  with quiet hours for remote/event-driven workflows; channel voice messages
-  are transcribed locally with a managed Whisper server.
+- Optional Discord/Telegram channels and cron schedules with quiet hours for
+  remote/event-driven workflows; channel voice messages are transcribed
+  locally with a managed Whisper server.
 - First-class Windows support: ConPTY terminals, PowerShell-aware shell
   profiles, and a one-click desktop installer.
 
@@ -126,9 +124,8 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
 
 - Skills, MCP servers, hooks, and plugins load through standard-compatible
   interfaces.
-- Built-in Web Search, Explorer, and Maintainer services, plus editable
-  starter agents (`worker`, `heavy-worker`, `reviewer`) and user-authored
-  custom roles.
+- Built-in Web Search and Maintainer services, plus editable starter agents
+  (`worker`, `heavy-worker`, `reviewer`) and user-authored custom roles.
 
 ## Run
 
@@ -168,8 +165,7 @@ mixdog --provider anthropic-oauth --model claude-opus-5 worker "fix the failing
 mixdog --provider openai-oauth --model gpt-5.6-sol reviewer "review the current diff"
 ```
 
-Roles: `explore`, `worker`, `heavy-worker`, `reviewer`, `maintainer`,
-`web-researcher`.
+Roles: `worker`, `heavy-worker`, `reviewer`, `maintainer`, `web-researcher`.
 
 ## TUI basics
 
@@ -208,8 +204,7 @@ current Anthropic models.
 Workflows and agents are Markdown definition packs (`WORKFLOW.md`,
 `AGENT.md`). Built-ins ship with mixdog; custom packs live under the data
 directory (`workflows/<id>/`, `agents/<id>/`) and are edited on the desktop
-app's Workflows page. Schedules and webhooks are also managed in the desktop
-app.
+app's Workflows page. Schedules are managed in the desktop app as well.
 
 ## Desktop app
 
@@ -230,9 +225,8 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Editor and review** — Monaco editor pane with LSP integration, git and
   inline diff viewers, and turn-by-turn review of agent edits with approval
   cards.
-- **Source control** — git dock for staging/commits/branches,
-  auto-generated commit messages, GitHub CLI integration, pull-request
-  browsing, and a dedicated review pane.
+- **Source control** — git dock for staging, commits, and branches, with
+  auto-generated commit messages.
 - **File explorer** — Windows-Explorer-grade folder pane: breadcrumbs and
   path box, ribbon toolbar, places/drives/tree sidebar, grouped grid and
   details views with shell icons and thumbnails, rubber-band selection,
@@ -243,8 +237,8 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Studio** — media studio for image and video generation over
   authenticated provider lanes, with a persistent local gallery, reference
   images, and per-model resolution/aspect/duration controls.
-- **Automation** — visual editors for workflow and agent packs, cron
-  schedules, webhooks, and channel integrations.
+- **Automation** — visual editors for workflow and agent packs, plus cron
+  schedules.
 - **Settings hub** — provider auth, capability sweep, git identity, and
   QR device pairing for the installable web app, preloaded so every
   category opens instantly.
@@ -254,7 +248,6 @@ wizard covers first-run setup. For development run `npm run dev` inside
 ```bash
 npm run smoke                # fast core feature smoke
 npm run smoke:all            # feature-surface smoke suite
-npm run smoke:tui            # TUI feature smoke
 npm run test:tool-contracts  # optional tool contract suite
 npm run build:tui            # build the bundled Ink TUI
 npm run audit:models         # inspect model catalog metadata
@@ -313,9 +306,9 @@ vendor/
 
 ## Published package contents
 
-The npm tarball ships `README.md`, `src/`, `vendor/`, and runtime `scripts/`
-only (`package.json#files`); tests, smokes, benches, and `docs/` stay in the
-repository.
+The npm tarball ships the README, notices and licenses, runtime sources,
+vendored runtime code, and selected scripts. `package.json#files` is the
+canonical package-content list.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.118",
+  "version": "0.9.119",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/tool-stress.mjs

@@ -24,8 +24,8 @@ function record(tool, ms, result, expectRe) {
   if (!s) { s = { n: 0, errs: [], lat: [] }; stats.set(tool, s); }
   s.n += 1; s.lat.push(ms);
   const text = String(result ?? '');
-  if (/^Error:|resource pressure|ERESOURCEPRESSURE|EAGAIN/i.test(text)) s.errs.push(text.slice(0, 160));
-  else if (expectRe && !expectRe.test(text)) s.errs.push(`unexpected output: ${text.slice(0, 120)}`);
+  if (/^Error:|resource pressure|ERESOURCEPRESSURE|EAGAIN/i.test(text)) s.errs.push(text.slice(0, 1000));
+  else if (expectRe && !expectRe.test(text)) s.errs.push(`unexpected output: ${text.slice(0, 1000)}`);
 }
 
 async function timed(tool, expectRe, fn) {

package/src/output-styles/detailed.md

@@ -11,14 +11,15 @@ keep-coding-instructions: true
 Detailed — a teammate's update; clarity outranks terseness.
 
 - Outcome first, then what a cold reader needs: complete user-language
-  sentences, expanded jargon, rationale where it adds value; no filler or
-  process narration.
-- Structure matches complexity: plain prose for simple answers; headers,
-  bullets, or tables (short enumerable facts only, explained outside) when
-  they aid scanning.
+  sentences readable in one pass, expanded jargon, rationale only where it
+  adds value; no filler or process narration.
+- Structure matches complexity: casual answers stay plain prose; reports
+  order outcome → changes → verification → next steps.
+- 3+ parallel facts become a flat `- ` list: one fact per bullet, one line
+  when possible, ordered by importance, parallel phrasing, related points
+  merged, never nested; tables only for short enumerable facts.
 - No hard cap, but brevity first: the shortest report understood without
-  rereads (~10 lines is plenty for most tasks); expand only when complexity
-  demands; trivial results stay 1–2 sentences.
-- Cite `file:line`; snippets only when load-bearing.
-- Never dump raw tool output; blockers and failures in one clause each.
-- Never name this style unless asked.
+  rereads (~10 lines is plenty); trivial results stay 1–2 sentences.
+- Cite `file:line`; snippets only when load-bearing; never dump raw tool
+  output; blockers and failures in one clause each; never name this style
+  unless asked.

package/src/output-styles/minimal.md

@@ -9,7 +9,7 @@ keep-coding-instructions: true
 
 Minimal — net result in plain sentences; hard cap 400 characters.
 
-- Concept level only: no headings, bullets, labels, or per-file detail, even
-  for reports.
+- Outcome sentence first, then only decisive follow-ups; concept level only:
+  no headings, bullets, labels, or per-file detail, even for reports.
 - Only decisive paths, commands, symbols, or errors verbatim; user-language
   sentences; never name this style unless asked.

package/src/output-styles/simple.md

@@ -10,12 +10,12 @@ keep-coding-instructions: true
 
 Simple — a teammate's update, tightened; hard cap 800 characters.
 
-- Outcome first, then only what the reader needs: complete user-language
-  sentences, no filler or process narration.
-- Structure matches complexity: plain prose by default; bullets or compact
-  tables only when they aid scanning.
-- Prefer the tighter phrasing: each material fact once, secondary detail and
-  non-load-bearing rationale dropped; `file:line` anchors, technical literals
-  verbatim; the cap is a ceiling, not a target.
+- Outcome first in complete user-language sentences; no filler or process
+  narration; reports order outcome → changes → verification.
+- Short answers stay plain prose; 3+ parallel facts become a flat `- `
+  list — one fact per bullet, one line, ordered by importance, never nested.
+- Each material fact once, secondary detail and non-load-bearing rationale
+  dropped; `file:line` anchors, technical literals verbatim; the cap is a
+  ceiling, not a target.
 - Never dump raw tool output; blockers and failures in one clause each.
   Never name this style unless asked.

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -254,6 +254,31 @@ export function _composeShellFailure(statusMarker, errorPrefix, warningBlock, pa
     return `${errorPrefix}${statusMarker}${warningBlock ? `\n${warningBlock}` : ''}\n\n${payload}`;
 }
 
+const INLINE_HOIST_CLEANUP_PATHS = new Set();
+let inlineHoistExitHookInstalled = false;
+function scheduleInlineHoistCleanup(file) {
+    if (!file) return;
+    INLINE_HOIST_CLEANUP_PATHS.add(file);
+    if (!inlineHoistExitHookInstalled) {
+        inlineHoistExitHookInstalled = true;
+        process.once('exit', () => {
+            for (const pending of INLINE_HOIST_CLEANUP_PATHS) {
+                try { unlinkSync(pending); } catch {}
+            }
+            INLINE_HOIST_CLEANUP_PATHS.clear();
+        });
+    }
+    // A long-lived pwsh standby can emit its completion marker just before a
+    // nested native process has opened the hoisted script. Keep the transport
+    // file briefly past marker settlement; normal daemon lifetime cleans it
+    // here, while the exit hook prevents one-shot CLI/test leftovers.
+    const timer = setTimeout(() => {
+        INLINE_HOIST_CLEANUP_PATHS.delete(file);
+        try { unlinkSync(file); } catch {}
+    }, 10_000);
+    timer.unref?.();
+}
+
 export async function executeBashTool(args, workDir, options = {}) {
     const requestedCwd = args.cwd ?? args.workdir;
     const cwdResult = resolveOptionalCwd(requestedCwd, workDir);
@@ -848,7 +873,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     finally {
         combinedBashAbort?.cleanup?.();
         if (_inlineHoistPath) {
-            try { unlinkSync(_inlineHoistPath); } catch { /* best-effort cleanup */ }
+            scheduleInlineHoistCleanup(_inlineHoistPath);
         }
         if (shellEffects.mutationMode === 'paths') {
             invalidateBuiltinResultCache(shellEffects.paths);

package/src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs

@@ -1,4 +1,4 @@
-import { readdirSync } from 'fs';
+import { readdirSync, watch } from 'fs';
 import { basename, isAbsolute, relative } from 'path';
 import {
     coerceReadFamilyPathArg,
@@ -22,6 +22,7 @@ import {
     statCacheSet,
     statPathsForMtime,
     registerCacheInvalidationListener,
+    invalidateBuiltinResultCache,
 } from './cache-layers.mjs';
 import { formatListSize, formatMtime } from './list-formatting.mjs';
 import {
@@ -417,6 +418,7 @@ const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt, gen }
 const FIND_ENUM_INFLIGHT = new Map(); // key -> { promise, controller, subscribers }
 const FIND_TARGETED_BATCHES_BY_RUNNER = new WeakMap();
 const FIND_ENUM_ROOT_GEN = new Map();
+const FIND_ENUM_WATCHERS = new Map();
 let FIND_ENUM_GEN = 0;
 
 // The broad enumeration is a DERIVED cache the scope/path invalidation layer
@@ -436,12 +438,71 @@ function findEnumerationRootFromKey(key) {
 function findEnumerationRootGeneration(root) {
     return FIND_ENUM_ROOT_GEN.get(root) || 0;
 }
+function invalidateFindEnumerationRoot(root) {
+    FIND_ENUM_ROOT_GEN.set(root, findEnumerationRootGeneration(root) + 1);
+    for (const key of [...FIND_ENUM_CACHE.keys()]) {
+        if (findEnumerationRootFromKey(key) === root) FIND_ENUM_CACHE.delete(key);
+    }
+    for (const key of [...FIND_ENUM_INFLIGHT.keys()]) {
+        if (findEnumerationRootFromKey(key) === root) FIND_ENUM_INFLIGHT.delete(key);
+    }
+}
+function ensureFindEnumerationWatcher(root) {
+    const existing = FIND_ENUM_WATCHERS.get(root);
+    if (existing) {
+        existing.touchedAt = Date.now();
+        return true;
+    }
+    try {
+        const pending = new Set();
+        const record = { watcher: null, timer: null, touchedAt: Date.now() };
+        const flush = () => {
+            record.timer = null;
+            const paths = [...pending];
+            pending.clear();
+            invalidateBuiltinResultCache(paths.length ? paths : [root]);
+            const warm = setTimeout(() => void prewarmFindEnumeration(root), 100);
+            warm.unref?.();
+        };
+        record.watcher = watch(root, { recursive: true, persistent: false }, (_event, filename) => {
+            const rel = filename == null ? '' : String(filename);
+            pending.add(rel ? resolveAgainstCwd(rel, root) : root);
+            if (record.timer) clearTimeout(record.timer);
+            record.timer = setTimeout(flush, 40);
+            record.timer.unref?.();
+        });
+        record.watcher.on('error', () => {
+            if (record.timer) clearTimeout(record.timer);
+            FIND_ENUM_WATCHERS.delete(root);
+            invalidateFindEnumerationRoot(root);
+            try { record.watcher.close(); } catch {}
+        });
+        record.watcher.unref?.();
+        FIND_ENUM_WATCHERS.set(root, record);
+        if (FIND_ENUM_WATCHERS.size > 8) {
+            const oldest = [...FIND_ENUM_WATCHERS.entries()]
+                .filter(([candidate]) => candidate !== root)
+                .sort((a, b) => a[1].touchedAt - b[1].touchedAt)[0];
+            if (oldest) {
+                FIND_ENUM_WATCHERS.delete(oldest[0]);
+                try { oldest[1].watcher.close(); } catch {}
+                invalidateFindEnumerationRoot(oldest[0]);
+            }
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
 registerCacheInvalidationListener((affectedPaths) => {
     if (!Array.isArray(affectedPaths) || affectedPaths.length === 0) {
-        FIND_ENUM_GEN += 1;
-        FIND_ENUM_ROOT_GEN.clear();
-        FIND_ENUM_CACHE.clear();
-        FIND_ENUM_INFLIGHT.clear();
+        const roots = new Set([
+            ...FIND_ENUM_CACHE.keys(),
+            ...FIND_ENUM_INFLIGHT.keys(),
+        ].map(findEnumerationRootFromKey));
+        for (const root of roots) {
+            if (!FIND_ENUM_WATCHERS.has(root)) invalidateFindEnumerationRoot(root);
+        }
         return;
     }
     const keys = new Set([...FIND_ENUM_CACHE.keys(), ...FIND_ENUM_INFLIGHT.keys()]);
@@ -453,13 +514,7 @@ registerCacheInvalidationListener((affectedPaths) => {
         }
     }
     for (const root of affectedRoots) {
-        FIND_ENUM_ROOT_GEN.set(root, findEnumerationRootGeneration(root) + 1);
-        for (const key of [...FIND_ENUM_CACHE.keys()]) {
-            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_CACHE.delete(key);
-        }
-        for (const key of [...FIND_ENUM_INFLIGHT.keys()]) {
-            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_INFLIGHT.delete(key);
-        }
+        invalidateFindEnumerationRoot(root);
     }
 });
 
@@ -576,9 +631,10 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         if (ttl > 0 && !truncated && !partial
             && FIND_ENUM_GEN === genAtStart
             && findEnumerationRootGeneration(root) === rootGenAtStart) {
+            const watched = ensureFindEnumerationWatcher(root);
             FIND_ENUM_CACHE.set(key, {
                 files,
-                expiresAt: Date.now() + ttl,
+                expiresAt: watched ? Number.MAX_SAFE_INTEGER : Date.now() + ttl,
                 gen: genAtStart,
                 rootGen: rootGenAtStart,
             });
@@ -600,13 +656,23 @@ export async function prewarmFindEnumeration(root) {
     try {
         if (!root || typeof root !== 'string') return;
         const hidden = true, includeNoise = false, depth = null;
-        const rgArgs = ['--files', '--no-require-git', '--hidden'];
-        for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
-        rgArgs.push('.');
+        const common = ['--files', '--no-require-git', '--hidden'];
+        const all = ['--files', '--no-ignore', '--hidden'];
+        for (const ex of DEFAULT_IGNORE_GLOBS) {
+            common.push('--glob', ex);
+            all.push('--glob', ex);
+        }
+        common.push('.');
+        all.push('.');
         await getBroadEnumeration({
             root: normalizeOutputPath(root),
             hidden, depth, includeNoise, ignoreMode: 'git',
-            rgArgs, cwd: root, bestEffort: true,
+            rgArgs: common, cwd: root, bestEffort: true,
+        });
+        await getBroadEnumeration({
+            root: normalizeOutputPath(root),
+            hidden, depth, includeNoise, ignoreMode: 'targeted-all',
+            rgArgs: all, cwd: root, bestEffort: true,
         });
     } catch { /* best-effort warm; never surface */ }
 }
@@ -629,6 +695,39 @@ async function getTargetedFindEnumeration({
     const key = JSON.stringify([root, hidden, depth ?? '', includeNoise, terms]);
     const runs = context?.targetedRuns;
     if (runs?.has(key)) return runs.get(key);
+    try {
+        const inventoryArgs = ['--files', '--no-ignore'];
+        if (hidden) inventoryArgs.push('--hidden');
+        if (depth != null) inventoryArgs.push('--max-depth', String(depth));
+        if (!includeNoise) {
+            for (const ex of DEFAULT_IGNORE_GLOBS) inventoryArgs.push('--glob', ex);
+        }
+        inventoryArgs.push('.');
+        const inventory = await getBroadEnumeration({
+            root: normalizeOutputPath(root),
+            hidden,
+            depth,
+            includeNoise,
+            ignoreMode: 'targeted-all',
+            rgArgs: inventoryArgs,
+            cwd: root,
+            runRgImpl,
+            signal,
+        });
+        if (!inventory.truncated && !inventory.partial) {
+            const lowerTerms = terms.map((term) => term.toLowerCase());
+            return {
+                files: inventory.files.filter((path) => {
+                    const lower = path.toLowerCase();
+                    return lowerTerms.some((term) => lower.includes(term));
+                }),
+                truncated: false,
+                partial: false,
+            };
+        }
+    } catch {
+        if (signal?.aborted) throw findEnumerationAbortError(signal);
+    }
     let batches = FIND_TARGETED_BATCHES_BY_RUNNER.get(runRgImpl);
     if (!batches) {
         batches = new Map();

package/src/runtime/agent/orchestrator/tools/builtin/search-tool.mjs

@@ -1563,7 +1563,11 @@ export async function executeGlobTool(args, workDir, options = {}) {
     let accumTruncated = false;
     let rgStdoutTruncated = false;
     let rgStdoutPartial = false;
+    let rgWindowIncomplete = false;
     const accumCap = 50000;
+    const canWindowNatural = globGroups.length === 1
+        && sortMode === 'natural'
+        && headLimit !== Infinity;
     const groupRuns = await Promise.all(globGroups.map(async ([root, rels]) => {
         const rgArgs = ['--files', '--hidden'];
         for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
@@ -1602,6 +1606,21 @@ export async function executeGlobTool(args, workDir, options = {}) {
             };
         }
         try {
+            if (canWindowNatural) {
+                const served = await runRgWindowedLines(
+                    rgArgs,
+                    { cwd: rgCwd, timeout: 10000, signal: options.signal },
+                    { offset: 0, limit: offset + headLimit + 1 },
+                );
+                return {
+                    error: null,
+                    paths: served.lines.map((line) =>
+                        isAbsolute(line) ? line : resolveAgainstCwd(line, rgCwd)),
+                    stdoutTruncated: false,
+                    stdoutPartial: false,
+                    windowIncomplete: served.complete !== true,
+                };
+            }
             const stdout = await runRg(rgArgs, { cwd: rgCwd, timeout: 10000, signal: options.signal });
             const stdoutTruncated = Boolean(stdout && typeof stdout === 'object' && stdout.truncated);
             const stdoutPartial = Boolean(stdout && typeof stdout === 'object' && stdout.partial);
@@ -1631,6 +1650,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
         }
         if (run.stdoutTruncated) rgStdoutTruncated = true;
         if (run.stdoutPartial) rgStdoutPartial = true;
+        if (run.windowIncomplete) rgWindowIncomplete = true;
         for (const p of run.paths) {
             allFiles.push(p);
             if (allFiles.length >= accumCap) {
@@ -1680,14 +1700,17 @@ export async function executeGlobTool(args, workDir, options = {}) {
             emptyDiag = `(no files found) pattern=${patternStr} path=${baseLabel}; ${basePathDiagnostic(baseEntries.map((e) => e.root), workDir, statCache)}`;
         }
     }
+    const moreSuffix = rgWindowIncomplete
+        ? `\n... [more entries available — pass offset:${offset + capped.length} to continue]`
+        : (remaining > 0 ? `\n... [${remaining} more entries of ${totalBeforeOffset} total — pass offset:${offset + capped.length} to continue]` : '');
     const body = capped.length > 0
-        ? `${capped.join('\n')}${remaining > 0 ? `\n... [${remaining} more entries of ${totalBeforeOffset} total — pass offset:${offset + capped.length} to continue]` : ''}${errSuffix}`
+        ? `${capped.join('\n')}${moreSuffix}${errSuffix}`
         : '';
     const out = globPatternCapNote + (body || emptyDiag || '(no files found)');
-    if (options?.scopedCacheOutcome && (accumTruncated || rgStdoutTruncated || rgStdoutPartial || remaining > 0)) {
+    if (options?.scopedCacheOutcome && (accumTruncated || rgStdoutTruncated || rgStdoutPartial || rgWindowIncomplete || remaining > 0)) {
         markScopedCacheIncomplete(options.scopedCacheOutcome);
     }
-    const globIncomplete = accumTruncated || rgStdoutTruncated || rgStdoutPartial || remaining > 0;
+    const globIncomplete = accumTruncated || rgStdoutTruncated || rgStdoutPartial || rgWindowIncomplete || remaining > 0;
     if (!globIncomplete) {
         cacheSet(cacheKey, out, { scopes: [...groups.keys()].map((root) => resolvedForSearchRoot(root)) });
     }

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.5",
+  "version": "0.1.6",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-darwin-arm64",
-      "sha256": "8124df97acdac619126c0686896c8b419fca9c3f2fc605547c21459b840deb3b"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-darwin-arm64",
+      "sha256": "43df904a60384761e6a0f848feec93fce0d6a3db6246695475b52cf355891a35"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-darwin-x64",
-      "sha256": "64a4f2d5bb4e769373beb4aec7d355bcf53882af9ab8a401338f99441ee2e99b"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-darwin-x64",
+      "sha256": "1bfbf4bc4ff0a55ed04477919e3a22a30de41af7404b8895e74d5ca0216e0285"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-linux-arm64",
-      "sha256": "ac9aae52012267b37139eeae45f6d2de780ec8f3e128a06a3843884f34434fa4"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-linux-arm64",
+      "sha256": "60512d468674105997b9171b9d9cc23c341144ada555cdc21f2e9b5cfbdd7ecb"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-linux-x64",
-      "sha256": "12314eaf7d2168ff203edf0d45dff315fba00d49704183f61f0eba9cfc1cab72"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-linux-x64",
+      "sha256": "9bddb7e78922081c550197ad7e34044fa4486ba57372dd0b662f3805c84f1561"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.5/mixdog-graph-win32-x64.exe",
-      "sha256": "b7d724ec01e5af4bee1764a08796bf0e1cefc2e2b841e6285f7b669a54774d10"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.6/mixdog-graph-win32-x64.exe",
+      "sha256": "0ad9198a5c5cf61993cb1bf76b2e4652f06542e8cf8f22601b7ca065a96b65f1"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/lib/pwsh-standby-pool.mjs

@@ -60,7 +60,7 @@ export function _resolvePwshPoolTarget({
     if (!Number.isFinite(free) || free < 0) {
         try { free = freemem(); } catch { free = 0; }
     }
-    const cpuTarget = Math.max(1, Math.min(8, Math.floor(cores) - 1 || 1));
+    const cpuTarget = Math.max(1, Math.min(4, Math.floor(cores) - 1 || 1));
     if (free < 768 * MB) return 0;
     if (free < 1536 * MB) return Math.min(1, cpuTarget);
     if (free < 3072 * MB) return Math.min(2, cpuTarget);
@@ -111,6 +111,12 @@ function _standbyBootScript(nonce) {
         '$null = & {0}',
         "[Console]::Out.Write('')",
         "[Console]::Error.Write('')",
+        // Prime the exact per-command parser/render pipeline before READY.
+        // Every standby pays this once in the background instead of making
+        // its first adopted command absorb ScriptBlock/Out-String JIT.
+        "$__warmSc = [ScriptBlock]::Create(\"'__mixdog_warm__'\")",
+        "$null = (& $__warmSc | Microsoft.PowerShell.Utility\\Out-String -Stream | Microsoft.PowerShell.Core\\ForEach-Object { [Console]::Out.Write('') })",
+        'Remove-Variable -Name __warmSc -Force -ErrorAction SilentlyContinue',
         '$__sr = New-Object System.IO.StreamReader([Console]::OpenStandardInput(), (New-Object System.Text.UTF8Encoding($false)))',
         '$__baseEnv = @{}',
         'Get-ChildItem env: | ForEach-Object { $__baseEnv[$_.Name] = $_.Value }',

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -454,11 +454,16 @@ export function execShellCommand({
       child = spawned.child;
       spawned.adoptErrorHandler(_onChildError);
       }
-      childGuardian = startChildGuardian({
-        childPid: child.pid,
-        childGroupPid: child.pid,
-        label: 'shell-command',
-      });
+      // A standby is daemon-owned, timeout-killed by this command, and checked
+      // for new descendants before recycle. Spawning another detached guardian
+      // for every short reuse duplicates those guarantees and dominates latency.
+      if (!_standby) {
+        childGuardian = startChildGuardian({
+          childPid: child.pid,
+          childGroupPid: child.pid,
+          label: 'shell-command',
+        });
+      }
     } catch (err) {
       const cleanupError = await releaseResourceLease();
       const spawnText = String((err && err.message) || err);

package/src/runtime/channels/providers/discord-attachments.mjs

@@ -5,7 +5,11 @@ import { join, sep } from "path";
 
 const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 
-async function downloadSingleAttachment(att, inboxDir, { timeoutMs = 180_000 } = {}) {
+async function downloadSingleAttachment(
+  att,
+  inboxDir,
+  { timeoutMs = 180_000, providerName = "discord" } = {},
+) {
   if (att.size > MAX_ATTACHMENT_BYTES) {
     throw new Error(
       `attachment too large: ${(att.size / 1024 / 1024).toFixed(1)}MB, max ${MAX_ATTACHMENT_BYTES / 1024 / 1024}MB`
@@ -46,7 +50,7 @@ async function downloadSingleAttachment(att, inboxDir, { timeoutMs = 180_000 } =
   }
   const buf = Buffer.concat(chunks.map((c) => Buffer.from(c.buffer, c.byteOffset, c.byteLength)), received);
   if (att.size > 0 && buf.length !== att.size) {
-    process.stderr.write(`mixdog discord: attachment size mismatch: expected ${att.size} got ${buf.length} (${att.name ?? att.id})\n`);
+    process.stderr.write(`mixdog ${providerName}: attachment size mismatch: expected ${att.size} got ${buf.length} (${att.name ?? att.id})\n`);
   }
   const name = att.name ?? `${att.id}`;
   const rawExt = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1) : "bin";

package/src/runtime/channels/providers/telegram.mjs

@@ -1,11 +1,46 @@
-import { mkdirSync } from "fs";
+import { mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
 import { createHash } from "crypto";
+import { join } from "path";
 import { chunk } from "../lib/format.mjs";
 import { readSection } from "../../shared/config.mjs";
 import { toMarkdownV2, stripMdV2, isParseEntitiesError } from "../lib/telegram-format.mjs";
+import { safeAttName } from "./discord-access.mjs";
+import { downloadSingleAttachment } from "./discord-attachments.mjs";
 
 const MAX_TELEGRAM_MESSAGE = 4096;
 const API_BASE = "https://api.telegram.org";
+const TELEGRAM_ATTACHMENT_CACHE_CAP = 1000;
+const ATTACHMENT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+
+function attachmentCacheKey(chatId, messageId) {
+  return `${String(chatId)}:${String(messageId)}`;
+}
+
+function telegramVoiceAttachments(msg) {
+  const attachments = [];
+  const add = (file, fallbackName, fallbackType) => {
+    if (!file?.file_id) return;
+    const id = String(file.file_unique_id || file.file_id);
+    attachments.push({
+      id,
+      fileId: String(file.file_id),
+      name: safeAttName({ id, name: file.file_name || fallbackName }),
+      contentType: String(file.mime_type || fallbackType),
+      size: Math.max(0, Number(file.file_size) || 0),
+    });
+  };
+  add(msg?.voice, `voice-${msg?.message_id ?? "message"}.ogg`, "audio/ogg");
+  add(msg?.audio, `audio-${msg?.message_id ?? "message"}.mp3`, "audio/mpeg");
+  return attachments;
+}
+
+function telegramFileUrl(token, filePath) {
+  const encodedPath = String(filePath || "")
+    .split("/")
+    .map((part) => encodeURIComponent(part))
+    .join("/");
+  return `${API_BASE}/file/bot${token}/${encodedPath}`;
+}
 
 // Chunk raw text so that EACH chunk still fits Telegram's limit AFTER
 // MarkdownV2 escaping. We first chunk normally (code-fence aware), then for any
@@ -85,6 +120,7 @@ class TelegramProvider {
   mainChannelId;
   stateDir;
   configFile;
+  inboxDir;
   isStatic;
   initialAccess;
   // Long-poll state.
@@ -94,11 +130,13 @@ class TelegramProvider {
   _pollGen = 0;
   _offset = 0;
   _typingIntervals = /* @__PURE__ */ new Map();
+  _attachmentMessages = /* @__PURE__ */ new Map();
   constructor(config, stateDir) {
     this.token = config.token;
     this.mainChannelId = config.mainChannelId ?? "";
     this.stateDir = stateDir;
     this.configFile = config.configPath ?? "";
+    this.inboxDir = join(stateDir, "inbox");
     this.isStatic = config.accessMode === "static";
     this.initialAccess = normalizeAccess(config.access);
     try { mkdirSync(this.stateDir, { recursive: true }); } catch {}
@@ -201,6 +239,7 @@ class TelegramProvider {
     // Re-entry guard mirrors DiscordProvider.connect(): a second connect() while
     // one is in flight/settled returns the same promise (no duplicate loops).
     if (this._connectPromise) return this._connectPromise;
+    this._sweepInboxOnce();
     this._connectPromise = (async () => {
       // Validate the token once (also surfaces a bad token early). getMe is
       // cheap and non-mutating; a failure here throws so startup can react.
@@ -221,6 +260,31 @@ class TelegramProvider {
     })();
     return this._connectPromise;
   }
+  _sweepInboxOnce() {
+    if (this._inboxSweepDone) return;
+    this._inboxSweepDone = true;
+    try {
+      const cutoff = Date.now() - ATTACHMENT_RETENTION_MS;
+      for (const name of readdirSync(this.inboxDir)) {
+        const path = join(this.inboxDir, name);
+        try {
+          const info = statSync(path);
+          if (info.isFile() && info.mtimeMs < cutoff) unlinkSync(path);
+        } catch { /* per-file best-effort */ }
+      }
+    } catch { /* inbox may not exist yet */ }
+  }
+  _rememberAttachments(chatId, messageId, attachments) {
+    if (!attachments.length) return;
+    const key = attachmentCacheKey(chatId, messageId);
+    this._attachmentMessages.delete(key);
+    this._attachmentMessages.set(key, attachments);
+    while (this._attachmentMessages.size > TELEGRAM_ATTACHMENT_CACHE_CAP) {
+      const oldest = this._attachmentMessages.keys().next().value;
+      if (oldest == null) break;
+      this._attachmentMessages.delete(oldest);
+    }
+  }
   async _pollLoop(gen) {
     while (this._polling && gen === this._pollGen) {
       const ac = new AbortController();
@@ -271,11 +335,12 @@ class TelegramProvider {
     if (!this._isAllowedChat(chatId, from.id)) return;
     if (from.is_bot) return; // ignore bot echoes / other bots.
     const text = msg.text ?? msg.caption ?? "";
+    const attachments = telegramVoiceAttachments(msg);
+    this._rememberAttachments(chatId, msg.message_id, attachments);
     const receivedAtMs = Date.now();
     // Mirror discord.mjs handleInbound's onMessage object shape so downstream
     // routing (resolveInboundRoute etc.) is provider-agnostic. Telegram has no
-    // thread/parent concept here → parentChatId null; attachments unsupported
-    // in scope 1 → [].
+    // thread/parent concept here → parentChatId null.
     if (this.onMessage) {
       this.onMessage({
         chatId: String(chatId),
@@ -287,7 +352,7 @@ class TelegramProvider {
         userId: String(from.id ?? ""),
         text,
         ts: new Date((typeof msg.date === "number" ? msg.date * 1000 : receivedAtMs)).toISOString(),
-        attachments: []
+        attachments: attachments.map(({ fileId: _fileId, ...attachment }) => attachment)
       });
     }
   }
@@ -474,10 +539,31 @@ class TelegramProvider {
       await this._api("deleteMessage", { chat_id: chatId, message_id: Number(messageId) });
     } catch { /* best-effort */ }
   }
-  // Attachment download is unsupported in scope 1. getFile + a download step
-  // can be added later; returning [] keeps the call site safe meanwhile.
-  async downloadAttachment() {
-    return [];
+  async downloadAttachment(chatId, messageId, opts = {}) {
+    const attachments = this._attachmentMessages.get(
+      attachmentCacheKey(chatId, messageId),
+    ) ?? [];
+    const filter = typeof opts.filter === "function" ? opts.filter : null;
+    const results = [];
+    for (const attachment of attachments) {
+      const { fileId, ...meta } = attachment;
+      if (filter && !filter(meta)) continue;
+      const file = await this._api("getFile", { file_id: fileId }, {
+        signal: AbortSignal.timeout(opts.timeoutMs ?? 180_000),
+      });
+      if (!file?.file_path) {
+        throw new Error(`telegram getFile returned no file path: ${meta.name}`);
+      }
+      const path = await downloadSingleAttachment({
+        ...meta,
+        url: telegramFileUrl(this.token, file.file_path),
+      }, this.inboxDir, {
+        ...opts,
+        providerName: "telegram",
+      });
+      results.push({ ...meta, path });
+    }
+    return results;
   }
   async validateChannel(chatId) {
     // getChat confirms the bot can see the chat; throws (like Discord's

package/src/runtime/channels/providers/telegram.test.mjs

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { TelegramProvider } from "./telegram.mjs";
+
+test("Telegram voice messages expose and download audio attachments", async () => {
+  const stateDir = await mkdtemp(join(tmpdir(), "mixdog-telegram-"));
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+  try {
+    const provider = new TelegramProvider({
+      token: "test-token",
+      mainChannelId: "42",
+      accessMode: "static",
+      access: { dmPolicy: "allowlist", channels: {} },
+    }, stateDir);
+    let inbound = null;
+    provider.onMessage = (message) => {
+      inbound = message;
+    };
+    provider._handleUpdate({
+      update_id: 1,
+      message: {
+        message_id: 7,
+        date: 1_700_000_000,
+        chat: { id: 42 },
+        from: { id: 9, username: "voice-user" },
+        voice: {
+          file_id: "download-id",
+          file_unique_id: "stable-id",
+          file_size: 4,
+          duration: 1,
+        },
+      },
+    });
+
+    assert.equal(inbound?.attachments?.length, 1);
+    assert.deepEqual(inbound.attachments[0], {
+      id: "stable-id",
+      name: "voice-7.ogg",
+      contentType: "audio/ogg",
+      size: 4,
+    });
+
+    globalThis.fetch = async (url, options = {}) => {
+      calls.push({ url: String(url), options });
+      if (String(url).endsWith("/getFile")) {
+        assert.deepEqual(JSON.parse(options.body), { file_id: "download-id" });
+        return new Response(JSON.stringify({
+          ok: true,
+          result: { file_path: "voice/file 7.oga" },
+        }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      return new Response(Buffer.from("OggS"), { status: 200 });
+    };
+
+    const downloaded = await provider.downloadAttachment("42", "7", {
+      timeoutMs: 1000,
+    });
+    assert.equal(downloaded.length, 1);
+    assert.equal(downloaded[0].id, "stable-id");
+    assert.equal(downloaded[0].contentType, "audio/ogg");
+    assert.equal(await readFile(downloaded[0].path, "utf8"), "OggS");
+    assert.equal(calls.length, 2);
+    assert.match(calls[1].url, /\/file\/bottest-token\/voice\/file%207\.oga$/);
+  } finally {
+    globalThis.fetch = originalFetch;
+    await rm(stateDir, { recursive: true, force: true });
+  }
+});

package/src/session-runtime/prewarm.mjs

@@ -100,6 +100,14 @@ export function createPrewarmSchedulers({
       } catch (error) {
         bootProfile('tool-runtime:token-estimator-failed', { error: error?.message || String(error) });
       }
+      try {
+        const { prewarmFindEnumeration } = await import('../runtime/agent/orchestrator/tools/builtin/list-tool.mjs');
+        const startedAt = performance.now();
+        await prewarmFindEnumeration(getCurrentCwd());
+        bootProfile('tool-runtime:path-index', { warmed: true, ms: (performance.now() - startedAt).toFixed(1) });
+      } catch (error) {
+        bootProfile('tool-runtime:path-index-failed', { error: error?.message || String(error) });
+      }
     })(), delayMs);
     timer.unref?.();
   }