mixdog 0.9.115 → 0.9.117

package/package.json

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

package/scripts/tool-stress.mjs

@@ -0,0 +1,143 @@
+// Tool-layer burst stress: hammers the in-process tool execution surface with
+// concurrent multi-session waves and checks that results stay correct and
+// bounded under load (no unhandled rejections, no resource-pressure failures,
+// patch/read integrity preserved, cancellation clean). One-shot script:
+// `node scripts/tool-stress.mjs`. Exit 0 = stable, 1 = instability found.
+import '../src/runtime/shared/uv-threadpool-boot.mjs';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
+import { executeCodeGraphTool } from '../src/runtime/agent/orchestrator/tools/code-graph.mjs';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+const root = join(fileURLToPath(new URL('.', import.meta.url)), '..');
+const SESSIONS = 8;
+const WAVES = 5;
+const stats = new Map(); // tool -> {n, errs:[], lat:[]}
+const failures = [];
+
+function record(tool, ms, result, expectRe) {
+  let s = stats.get(tool);
+  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)}`);
+}
+
+async function timed(tool, expectRe, fn) {
+  const t0 = Date.now();
+  try {
+    const out = await fn();
+    record(tool, Date.now() - t0, out, expectRe);
+    return out;
+  } catch (err) {
+    record(tool, Date.now() - t0, `Error: thrown ${err?.message || err}`);
+    return null;
+  }
+}
+
+function pct(list, p) {
+  if (!list.length) return 0;
+  const sorted = [...list].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length))];
+}
+
+const tmp = mkdtempSync(join(tmpdir(), 'mixdog-tool-stress-'));
+const t0 = Date.now();
+try {
+  // ── Phase A+C: concurrent multi-session waves (search/read/graph/shell +
+  // per-session patch integrity riding the same load) ──────────────────────
+  for (let wave = 0; wave < WAVES; wave++) {
+    const calls = [];
+    for (let s = 0; s < SESSIONS; s++) {
+      const opts = { sessionId: `stress-s${s}` };
+      const marker = `stress_w${wave}_s${s}`;
+      calls.push(
+        timed('grep', /path-string|paths only|grep|\(no matches\)|Fuzzy/i, () => executeBuiltinTool('grep', {
+          pattern: ['Fuzzy filename', 'paths only'], path: 'src/runtime/agent/orchestrator/tools/builtin', glob: '*.mjs', limit: 20, context: 0,
+        }, root, opts)),
+        timed('glob', /tool-defs\.mjs|\.mjs/, () => executeBuiltinTool('glob', {
+          pattern: '**/*.mjs', path: 'src/session-runtime', limit: 40,
+        }, root, opts)),
+        timed('find', /tool-defs|no fuzzy match/, () => executeBuiltinTool('find', {
+          query: 'tool-defs', limit: 8,
+        }, root, opts)),
+        timed('list', /01-tool\.md|file/, () => executeBuiltinTool('list', {
+          path: 'src/rules/shared',
+        }, root, opts)),
+        timed('read', /Tool Use|read/, () => executeBuiltinTool('read', {
+          path: [['src/rules/shared/01-tool.md', 0, 10], ['package.json', 0, 5]],
+        }, root, opts)),
+        timed('code_graph', /symbol|binding|files|edges/i, () => executeCodeGraphTool('code_graph', {
+          mode: 'symbols', files: 'scripts/smoke.mjs',
+        }, root)),
+        timed('shell', /55350/, () => executeBuiltinTool('shell', {
+          command: 'node -e "console.log(123*450)"', timeout: 60_000,
+        }, root, opts)),
+        (async () => {
+          const patch = [
+            '*** Begin Patch',
+            `*** Add File: ${marker}.txt`,
+            `+payload ${marker}`,
+            '*** End Patch',
+          ].join('\n');
+          await timed('apply_patch', /applied|OK/i, () => executePatchTool('apply_patch', { patch, base_path: tmp }, tmp, opts));
+          const back = await timed('read-verify', new RegExp(`payload ${marker}`), () => executeBuiltinTool('read', { path: `${marker}.txt` }, tmp, opts));
+          if (!String(back || '').includes(`payload ${marker}`)) failures.push(`patch integrity lost for ${marker}`);
+        })(),
+      );
+    }
+    await Promise.all(calls);
+  }
+
+  // ── Phase B: oversized inputs stay budget-bounded ─────────────────────────
+  await Promise.all([
+    timed('grep-broad', /Showing|import|export/, () => executeBuiltinTool('grep', {
+      pattern: 'import', path: 'src', limit: 300, mode: 'files',
+    }, root, { sessionId: 'stress-big' })),
+    timed('glob-broad', /\.mjs|entries/, () => executeBuiltinTool('glob', {
+      pattern: '**/*', path: 'src/runtime/agent/orchestrator/tools', limit: 0,
+    }, root, { sessionId: 'stress-big' })),
+    timed('read-big', /./, () => executeBuiltinTool('read', {
+      path: 'src/tui/dist/index.mjs', limit: 2000,
+    }, root, { sessionId: 'stress-big' })),
+  ]);
+  for (const [tool, s] of stats) {
+    if (tool.endsWith('-broad') || tool === 'read-big') {
+      const worst = Math.max(...s.lat);
+      if (worst > 30_000) failures.push(`${tool} exceeded 30s budget: ${worst}ms`);
+    }
+  }
+
+  // ── Phase D: cancellation under load ─────────────────────────────────────
+  const bg = await timed('shell-async', /task_id/, () => executeBuiltinTool('shell', {
+    command: 'node -e "setTimeout(()=>{}, 30000)"', mode: 'async', timeout: 60_000,
+  }, root, { sessionId: 'stress-cancel' }));
+  const bgId = (/task_id:\s*(\S+)/.exec(String(bg)) || [])[1];
+  if (!bgId) failures.push('async shell did not return task_id');
+  else {
+    await timed('task-cancel', /cancelled/, () => executeBuiltinTool('task', { action: 'cancel', task_id: bgId }, root, { sessionId: 'stress-cancel' }));
+    const st = await timed('task-status', /cancelled|failed/, () => executeBuiltinTool('task', { action: 'status', task_id: bgId }, root, { sessionId: 'stress-cancel' }));
+    if (!/cancelled/.test(String(st))) failures.push(`cancelled task not reported cancelled: ${String(st).slice(0, 120)}`);
+  }
+} finally {
+  try { rmSync(tmp, { recursive: true, force: true }); } catch { /* best-effort */ }
+}
+
+// ── Report ──────────────────────────────────────────────────────────────────
+let errTotal = 0;
+for (const [tool, s] of [...stats.entries()].sort()) {
+  errTotal += s.errs.length;
+  console.log(
+    `${tool.padEnd(14)} n=${String(s.n).padStart(3)} errs=${s.errs.length}`
+    + ` p50=${pct(s.lat, 50)}ms p95=${pct(s.lat, 95)}ms max=${Math.max(...s.lat)}ms`,
+  );
+  for (const e of s.errs.slice(0, 3)) console.log(`  ! ${e}`);
+}
+for (const f of failures) console.log(`FAIL ${f}`);
+const calls = [...stats.values()].reduce((a, s) => a + s.n, 0);
+console.log(`tool stress ${failures.length || errTotal ? 'FAILED' : 'passed'} calls=${calls} errors=${errTotal} failures=${failures.length} elapsed=${Math.round((Date.now() - t0) / 1000)}s`);
+process.exit(failures.length || errTotal ? 1 : 0);

package/src/cli.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import './runtime/shared/uv-threadpool-boot.mjs';
 import { fileURLToPath } from 'node:url';
 import { classifyCliInvocation } from './headless-command.mjs';
 import {

package/src/rules/shared/01-tool.md

@@ -1,7 +1,7 @@
 # Tool Use
 
 - Baseline routing assigns each facet directly by the evidence needed to
-  determine the complete edit:
+  determine the complete answer or edit:
   path/name only→`find`; wildcard/recursive paths→`glob` (including known-root
   unknown descendants); exact directory entries→`list`;
   source content/value/`path:line`→`grep`; exact symbol/relation→`code_graph`;
@@ -18,41 +18,45 @@
   relies on it. Within the current project, pass
   project-relative paths and omit optional scopes equal to its root; explicit
   paths may be outside cwd only for targets outside the project.
-- Plan the fewest dependent rounds, then the fewest calls. A conclusive
-  result ends its facet, and known state — anything the task supplied, a
-  tool returned, or a check already proved — is never re-found,
-  re-derived, or re-verified. Batch calls iff none needs
+- Plan the fewest dependent rounds, then the fewest calls. Known state —
+  anything the task supplied, a tool returned, or a check already proved —
+  is never re-found, re-derived, or re-verified; a change to its subject
+  re-opens it. Batch calls iff none needs
   another's output or can change another's inputs/state; otherwise
   serialize. Before each batch, deduplicate the facets still required by the request,
   route each once to the cheapest sufficient tool with all required
   variants/scopes — every distinct sample/format in the same batch —
   and launch every independent call together — never
   split or duplicate a facet across tools, mutate merely to widen
-  retrieval, reserve known work, or cap fanout. Guessed terms go wide
-  with batched fan-out; narrow a scope only on verified cues — returned
-  siblings/conventions or known literals. Mine each returned output for
-  every remaining facet before the next round. Symbol relations end at
+  retrieval, reserve known work, or cap fanout. Each round asks everything
+  it can and keeps everything it gets: guesses go wide in one batch, scopes
+  narrow only on verified cues — returned siblings/conventions or known
+  literals — and returned output is fully mined before the next round.
+  Symbol relations end at
   `code_graph`; values/locations end at the context grep returns; `read`
   covers only what returned spans cannot, as an anchored offset/limit
-  window. The moment evidence determines the answer, edit, or deliverable,
-  stop retrieving; patch if needed.
+  window. A conclusive result ends its facet; evidence that determines the
+  answer, edit, or deliverable ends retrieval — patch if needed.
 - Once the edit or deliverable is determined, finish in one assistant turn:
   before `apply_patch`, obtain every target hunk's exact current content and
   anchor from `grep`, `code_graph`, or `read`; never infer patch context from
   another file, a sample, or expected text. Then issue `apply_patch` calls
   serially, never in parallel; use one cohesive call with one file section per
-  target, all patches first, and their one
-  batched verification `shell` in the same turn, running the real required
-  postconditions on every changed file and produced artifact, never echoing
-  a claim;
-  runtime waits for every patch and skips the shell
-  if any fails. Retry only failed envelopes; rerun a failed check only
-  after a fix that can change its result, else report it unresolved.
+  target, all patches first, then their one batched verification `shell` in
+  the same turn — the runtime runs it after every patch and only if all
+  succeeded, so verification never needs its own turn. It runs the real
+  required postconditions on every changed file and produced artifact,
+  never echoing a claim; a postcondition that did not actually run is
+  unresolved, not passed. Retry only failed envelopes; rerun a failed check only
+  after a change that can alter its outcome — commands alike; else switch
+  route or report it unresolved.
   Hand-authored text is edited only with `apply_patch`; computed artifacts
   (data/reports/derived values) come from `shell` computation, never
   hand-transcribed numbers. Earlier `shell` is only for runtime/state
   evidence unavailable to file tools—an independent facet, batched with
   the rest; independent probes are parallel shell calls, never one
   serial script per round.
-- A background `task_id` ends the turn; completion resumes work. Never poll;
-  use task control only for recovery or a required blocking result.
+- A long or uncertain command runs async — never nohup — and its
+  `task_id` ends the turn; completion resumes work. Never poll in any
+  form — sleep/status probes included; task control is for recovery or a
+  required blocking result only.

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -19,8 +19,6 @@ const WORKER_DENIED_TOOLS = new Set([
     // (type=spawn|send|close|list). Denying the one name blocks all worker
     // session control.
     'agent',
-    // channels module (owner/Discord-facing)
-    'reply', 'fetch',
     // host input injection
     'inject_input',
 ]);

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

@@ -32,7 +32,7 @@ export const BUILTIN_TOOLS = [
         name: 'read',
         title: 'Mixdog Read',
         annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Known-file contents or line ranges; not directories. Replaces cat/head/tail.',
+        description: 'Known-file contents or line ranges; images render for viewing; not directories. Replaces cat/head/tail.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -75,7 +75,7 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run a shell command. Sync inline by default; async returns task_id and sends a completion notification. Executable/runtime/state evidence only — never file exploration in any command segment: NOT ls/find/cat/head/tail/grep/rg/sed; dedicated file tools cover those.',
+        description: 'Run a shell command; async returns task_id and sends a completion notification. Executable/runtime/state evidence only — never file exploration in any command segment: NOT ls/find/cat/head/tail/grep/rg/sed; dedicated file tools cover those.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -194,7 +194,7 @@ export const BUILTIN_TOOLS = [
                     description: 'Filename or directory path fragments matched against path strings; query[] batches.',
                 },
                 path: { type: 'string', description: 'Project-relative base; omit for project root; absolute only outside.' },
-                limit: { type: 'number', description: 'Max paths across the call. Defaults to 25.' },
+                limit: { type: 'number', description: 'Max paths; default 25; 0 unlimited.' },
                 include_noise: { type: 'boolean', description: 'Also search gitignored/dependency trees.' },
             },
             required: ['query'],

package/src/runtime/agent/orchestrator/tools/builtin/fs-reachability.mjs

@@ -13,6 +13,12 @@
 import { stat } from 'node:fs/promises';
 
 const FS_REACHABILITY_DEADLINE_MS = 5000;
+// Under burst load the libuv threadpool can queue a healthy local stat past
+// the base deadline (slow ≠ dead). Before declaring the path unreachable,
+// keep waiting for the SAME pending probe up to this extended ceiling: a
+// loaded-but-alive filesystem answers within it, a dead mount stays silent.
+const FS_REACHABILITY_EXTENDED_MS = 15_000;
+let _lastSlowStatWarnAt = 0;
 
 // Resolve true when the path is reachable (exists OR cleanly absent — ENOENT,
 // EACCES, etc. are "the FS answered", let the real sync logic produce its own
@@ -34,8 +40,25 @@ export async function assertPathReachable(path, deadlineMs = FS_REACHABILITY_DEA
         deadline,
     ]);
     if (result === 'TIMEOUT') {
+        // Grace window: distinguish threadpool queueing from a dead mount by
+        // waiting longer for the probe that is still in flight.
+        let extTimer = null;
+        const extended = await Promise.race([
+            probe.finally(() => { if (extTimer) clearTimeout(extTimer); }),
+            new Promise((resolve) => {
+                extTimer = setTimeout(() => resolve('TIMEOUT'), Math.max(ms, FS_REACHABILITY_EXTENDED_MS - ms));
+            }),
+        ]);
+        if (extended !== 'TIMEOUT') {
+            const now = Date.now();
+            if (now - _lastSlowStatWarnAt > 30_000) {
+                _lastSlowStatWarnAt = now;
+                process.stderr.write(`[fs-reachability] slow stat >${ms}ms under load (resolved in grace window): ${path}\n`);
+            }
+            return extended;
+        }
         const err = new Error(
-            `path unreachable: stat exceeded ${ms}ms (possible dead mount / hung filesystem): ${path}`,
+            `path unreachable: stat exceeded ${FS_REACHABILITY_EXTENDED_MS}ms (possible dead mount / hung filesystem): ${path}`,
         );
         err.code = 'EFSUNREACHABLE';
         throw err;

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

@@ -19,6 +19,13 @@ let _server = null; // { child, pending: Map, sequence }
 let _binaryPath = undefined; // undefined = unresolved, null = unavailable
 let _lastFailureAt = 0;
 
+function _setServerReferenced(server, referenced) {
+  const method = referenced ? 'ref' : 'unref';
+  try { server?.child?.[method]?.(); } catch {}
+  try { server?.child?.stdin?.[method]?.(); } catch {}
+  try { server?.child?.stdout?.[method]?.(); } catch {}
+}
+
 function _resolveBinary() {
   if (_binaryPath !== undefined) return _binaryPath;
   const explicit = String(process.env.MIXDOG_SEARCH_SERVER_BIN || '').trim();
@@ -77,7 +84,10 @@ function _ensureServer() {
   });
   child.on('error', (error) => { if (_server === server) _teardown(error); });
   child.on('exit', () => { if (_server === server) _teardown(); });
-  child.unref?.();
+  // A detached child can still pin a one-shot CLI/test through its pipe
+  // handles. Keep the resident server idle-unreferenced, then ref all handles
+  // only while a request is awaiting a response.
+  _setServerReferenced(server, false);
   _server = server;
   return server;
 }
@@ -85,11 +95,30 @@ function _ensureServer() {
 /** rg-runner seam: returns a runRgWindowedLines-shaped result, or null when
  *  the server is unavailable / the request shape is unsupported (caller then
  *  spawns rg exactly as before). */
+// Boot-time prewarm: binary resolution is async (dynamic import), so the
+// first search of a cold session otherwise races it and falls back to a
+// spawn. Long-lived hosts call this fire-and-forget to have the resident
+// server up before the first tool call. Honors the same kill switch.
+export async function warmNativeSearchServer() {
+  try {
+    if (process.env.MIXDOG_SEARCH_SERVER === '0') return false;
+    if (_resolveBinary() === null) {
+      const mod = await import('../code-graph/graph-binary.mjs');
+      const candidate = mod.graphBinaryPath?.() || mod.resolveGraphBinaryPath?.() || null;
+      if (candidate && existsSync(candidate)) _binaryPath = candidate;
+    }
+    return Boolean(_ensureServer());
+  } catch {
+    return false;
+  }
+}
+
 export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   if (process.env.MIXDOG_SEARCH_SERVER === '0') return null;
   const server = _ensureServer();
   if (!server) return null;
   const id = ++server.sequence;
+  _setServerReferenced(server, true);
   const request = {
     id,
     cwd: String(execOptions.cwd || process.cwd()),
@@ -100,17 +129,37 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
       : 0,
   };
   const response = await new Promise((resolve) => {
+    let settled = false;
+    let onAbort = null;
+    const cancelServerWork = () => {
+      try { server.child.stdin.write(`${JSON.stringify({ cancel: id })}\n`); } catch {}
+    };
+    const settle = (value, cancel = false) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (onAbort) {
+        try { execOptions.signal?.removeEventListener?.('abort', onAbort); } catch {}
+        onAbort = null;
+      }
+      if (cancel) cancelServerWork();
+      resolve(value);
+      if (server.pending.size === 0) _setServerReferenced(server, false);
+    };
     const timer = setTimeout(() => {
       server.pending.delete(id);
-      resolve(null);
+      settle(null, true);
     }, REQUEST_TIMEOUT_MS);
     timer.unref?.();
-    const settle = (value) => { clearTimeout(timer); resolve(value); };
     server.pending.set(id, { resolve: settle, reject: () => settle(null) });
-    const onAbort = () => {
+    onAbort = () => {
       server.pending.delete(id);
-      settle(null);
+      settle(null, true);
     };
+    if (execOptions.signal?.aborted) {
+      onAbort();
+      return;
+    }
     execOptions.signal?.addEventListener?.('abort', onAbort, { once: true });
     try {
       server.child.stdin.write(`${JSON.stringify(request)}\n`);

package/src/runtime/agent/orchestrator/tools/builtin/rg-runner.mjs

@@ -582,15 +582,14 @@ function spawnRg(argsList, execOptions) {
 }
 
 export async function runRg(argsList, execOptions = {}) {
-    // `rg --files` (glob tool) has the same spawn-dominated cost profile as
-    // content grep; the resident server answers it without a process. Only a
-    // COMPLETE served listing substitutes for the buffered-stdout contract.
-    if (argsList.includes('--files')) {
-        try {
-            const served = await tryServeSearch(argsList, execOptions, { offset: 0, limit: 0 });
-            if (served && served.complete) return served.lines.join('\n');
-        } catch { /* server is an accelerator only */ }
-    }
+    // Resident server first for BOTH profiles — `rg --files` (glob tool) and
+    // buffered content grep share the spawn-dominated cost. Unsupported args
+    // answer null and fall through to the real spawn. Only a COMPLETE served
+    // result substitutes for the buffered-stdout contract.
+    try {
+        const served = await tryServeSearch(argsList, execOptions, { offset: 0, limit: 0 });
+        if (served && served.complete) return served.lines.join('\n');
+    } catch { /* server is an accelerator only */ }
     await assertRgAvailable();
     try {
         return await spawnRg(argsList, execOptions);

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-spawn.mjs

@@ -63,6 +63,17 @@ import {
     psSingleQuote,
     isPowerShellShell,
 } from './lib/shell-spawn-helpers.mjs';
+import os from 'node:os';
+
+// Background work yields CPU to interactive tool calls: demote the job's
+// process priority best-effort (below-normal). Children inherit it. Purely a
+// scheduling hint — failures (permissions, dead pid) are ignored.
+// MIXDOG_BG_PRIORITY=0 disables.
+export function demoteBackgroundShellPriority(pid) {
+    if (process.env.MIXDOG_BG_PRIORITY === '0') return;
+    if (!Number.isFinite(pid) || pid <= 0) return;
+    try { os.setPriority(pid, os.constants.priority.PRIORITY_BELOW_NORMAL); } catch { /* best-effort */ }
+}
 
 // Facade re-exports: path/detail helpers and the job-not-found message moved
 // to sibling modules; keep existing importers of shell-jobs.mjs resolving.
@@ -186,6 +197,7 @@ export async function _startBackgroundShellJobImpl({
         try { unlinkSync(wrappedTempPath); } catch {}
         return { jobId, kind: 'bash', status: 'failed', error: `failed to spawn shell background task: ${e?.message || e}` };
     }
+    demoteBackgroundShellPriority(child.pid);
     const detail = {
         jobId,
         kind: 'bash',
@@ -429,6 +441,7 @@ async function startBackgroundPowerShellJob({
     if (!Number.isFinite(childPid) || childPid <= 0) {
         return { jobId, kind: 'bash', status: 'failed', error: 'PowerShell background task spawn returned no pid' };
     }
+    demoteBackgroundShellPriority(childPid);
     const detail = {
         jobId,
         kind: 'bash',

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -18,7 +18,7 @@ import {
     getBackgroundTask,
 } from '../../../../shared/background-tasks.mjs';
 import { startChildGuardian } from '../../../../shared/child-guardian.mjs';
-import { _startBackgroundShellJobImpl } from './shell-job-spawn.mjs';
+import { _startBackgroundShellJobImpl, demoteBackgroundShellPriority } from './shell-job-spawn.mjs';
 import { detachedSpawnOpts } from '../../../../shared/spawn-flags.mjs';
 import {
     getShellJobsDir,
@@ -804,6 +804,9 @@ export function watchBackgroundShellJob(jobId, notifyCtx) {
 // 'running' detail.
 export function adoptForegroundShellJob({ command, cwd, pid, timeoutMs, mergeStderr, stdoutPath, stderrPath, clientHostPid, ownerSessionId }) {
     const jobId = `job_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    // Auto-backgrounded work is by definition long-running: yield CPU to
+    // interactive tool calls from here on (children inherit the class).
+    demoteBackgroundShellPriority(pid);
     const exitPath = shellJobExitPath(jobId);
     const donePath = shellJobDonePath(jobId);
     const detail = {

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary.mjs

@@ -33,6 +33,13 @@ function _graphBinaryPath() {
   try { return findCachedGraphBinary(getPluginData()); } catch { return null; }
 }
 
+// Public resolver for consumers outside the graph build (the resident
+// native-search-client duck-types this exact name). Returns an absolute
+// path or null; never throws.
+export function graphBinaryPath() {
+  try { return _graphBinaryPath() || null; } catch { return null; }
+}
+
 async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null, signal = null) {
   let binPath = _graphBinaryPath();
   if (!binPath) {

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.3",
+  "version": "0.1.4",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.3/mixdog-graph-darwin-arm64",
-      "sha256": "16b46d7d6c11adc252ccbd645c2af483f1460facf27b91a90d80580850c3bfe7"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-darwin-arm64",
+      "sha256": "1531098011a3c32ad9a6d002e7240b829352fda60afc5708699dd0d335405201"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.3/mixdog-graph-darwin-x64",
-      "sha256": "0242a4f449ae4d913699f7e40972c5521e09289371da02190a8193a7818cb871"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-darwin-x64",
+      "sha256": "ead5684bebc2ef001724b2d71f23f3e7fc6e52d60d6deb5cea17b73fc3768a1b"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.3/mixdog-graph-linux-arm64",
-      "sha256": "4e77e1f7f920e4eb99abadd189fe153e73c3eff994c31185a895425a82c4eb1d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-linux-arm64",
+      "sha256": "8d6d24490dfff31f66967b8384f4afe8f85051f9352c3866a2da32e6ef52d644"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.3/mixdog-graph-linux-x64",
-      "sha256": "c57fa8f870602e72777bb64bd64e339571f6936cece24c25d940b4d820d67ef3"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-linux-x64",
+      "sha256": "ed26c40956d90d9863d18c028cc7766e9abf5af33405a9cab02f7cbc4a3c7eac"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.3/mixdog-graph-win32-x64.exe",
-      "sha256": "48f1b2ba11a0d4fd380eda1770fbcb88307370829337d0e65d188619732cb2ef"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.4/mixdog-graph-win32-x64.exe",
+      "sha256": "f87bd63e70ecc0a7639f0143b5954a2b673d84e6c59e1ca8f7a8e5cdcc50a21a"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -48,6 +48,7 @@ const APPLY_PATCH_JSON_DESCRIPTION = [
   'Hunks start with @@ or @@ <symbol|1-based line>; lines start space, -, or +; every Update hunk needs >=1 +/- line; optional *** End of File.',
   'Use 3 verbatim context lines from newest output (post-patch body after edits); avoid overlap; stack @@ only if ambiguous.',
   'Project-relative paths; explicit absolute paths only outside the project; + every added line. Never send compacted-history markers; re-read first.',
+  'A same-turn shell runs after all patches succeed.',
 ].join('\n');
 
 export const PATCH_TOOL_DEFS = [

package/src/runtime/agent/orchestrator/tools/progress-message.mjs

@@ -72,12 +72,6 @@ export function formatToolStartProgress(name, args = {}) {
         case 'memory':
             return 'managing memory';
 
-        // ── channels module ──────────────────────────────────────────────
-        case 'reply':
-            return 'replying';
-        case 'fetch':
-            return 'fetching messages';
-
         // ── host_input / cwd ─────────────────────────────────────────────
         case 'inject_input':
             return 'injecting input';

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

@@ -35,6 +35,7 @@ import * as nodeUtil from 'node:util';
 import { getPluginData } from '../config.mjs';
 import { startChildGuardian } from '../../../shared/child-guardian.mjs';
 import { resourceAdmission } from '../../../shared/resource-admission.mjs';
+import { acquire as acquireChildSpawnSlot } from '../../../shared/child-spawn-gate.mjs';
 // Runtime-only import (used inside execShellCommand's auto-background
 // transition). shell-jobs.mjs imports stripAnsi from this module, so this is
 // a static cycle — safe because neither binding is touched at module-eval
@@ -415,7 +416,17 @@ export function execShellCommand({
       // 'close' fires with 'exit' and grandchildren cannot hold the capture
       // open. Falls back to pipe capture if the files cannot be opened.
       const _directCapture = SHELL_DIRECT_CAPTURE ? taskOutput.openDirectCapture() : null;
-      const spawned = await _spawnShellWithRetry({
+      // Spawn-burst gate: hold a 'process-spawn' slot only across process
+      // creation (CreateProcess + AV scan + EPERM retries), released the
+      // moment the child exists. Bounds the Defender convoy a shell burst
+      // creates without limiting how many commands RUN concurrently — the
+      // full-lifetime gating concern in the note below stays true.
+      const _releaseSpawnSlot = await acquireChildSpawnSlot(abortSignal || null, 'process-spawn', {
+        ownerKey: ownerSessionId,
+      });
+      let spawned;
+      try {
+        spawned = await _spawnShellWithRetry({
         shell,
         argv,
         shellArg,
@@ -427,20 +438,19 @@ export function execShellCommand({
         stdio: _directCapture
           ? ['ignore', _directCapture.stdoutFd, _directCapture.stderrFd]
           : ['ignore', 'pipe', 'pipe'],
-        // NOTE (child-spawn-gate): intentionally NOT routed through
-        // src/runtime/shared/child-spawn-gate.mjs. bash/pwsh commands can run
-        // for minutes (or auto-background), so holding a finite gate slot for
-        // the whole lifetime would let a few long shells starve rg/code_graph —
-        // the opposite of the gate's intent. TODO: if shell saturation becomes
-        // a problem, gate only the brief spawn burst (release on first output /
-        // adoption), not the full run.
+        // NOTE (child-spawn-gate): the full command lifetime is intentionally
+        // NOT gated — bash/pwsh commands can run for minutes and would starve
+        // rg/code_graph. Only the spawn window above holds a slot.
         // POSIX: detached gives the child its own process group so treeKill can
         // signal the whole group. The child is still CLI-owned because we do
         // not unref it after adoption. Windows detached has different console
         // semantics, so it stays off there.
         detached: process.platform !== 'win32',
         },
-      });
+        });
+      } finally {
+        try { _releaseSpawnSlot(); } catch { /* idempotent */ }
+      }
       child = spawned.child;
       spawned.adoptErrorHandler(_onChildError);
       }

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -10,10 +10,7 @@ import { OutputForwarder } from "./output-forwarder.mjs";
 // call time — matching the original in-file closure semantics.
 function createToolDispatch({
   getForwarder,
-  PROVIDER_TOOLS,
   isChannelsDegraded,
-  dispatchReply,
-  dispatchFetch,
   lifecycle,
 }) {
   const {
@@ -39,12 +36,6 @@ function createToolDispatch({
     let result;
     try {
       switch (name) {
-        case "reply":
-          result = await dispatchReply(args);
-          break;
-        case "fetch":
-          result = await dispatchFetch(args);
-          break;
         case "activate_channel_bridge": {
             const active = args.active === true;
             const wasActive = getChannelBridgeActive();
@@ -152,23 +143,6 @@ function createToolDispatch({
       _lastForwardMs = now;
       await forwarder.forwardNewText();
     }
-    if (PROVIDER_TOOLS.has(toolName) && !getBridgeRuntimeConnected()) {
-      // Remote-owner startup: ensure this owner's provider is connected.
-      for (let i = 0; i < 2 && !getBridgeRuntimeConnected(); i++) {
-        try {
-          // Auto-connect this owner's provider (daemon singleton — no seat claim).
-          await refreshBridgeOwnership();
-        } catch {
-        }
-        if (!getBridgeRuntimeConnected()) await new Promise((r) => setTimeout(r, 300));
-      }
-      if (!getBridgeRuntimeConnected()) {
-        return {
-          content: [{ type: "text", text: `Discord auto-connect failed after retries. Check token and network.` }],
-          isError: true
-        };
-      }
-    }
     const result = await handleToolCall(toolName, args, signal);
     const toolLine = OutputForwarder.buildToolLine(toolName, args);
     if (toolLine) {

package/src/runtime/channels/lib/worker-main.mjs

@@ -61,7 +61,6 @@ import {
 } from "./crash-log.mjs";
 import { dropTrace, preview, _dtIdxFlush } from "./index-drop-trace.mjs";
 import { createVoiceTranscription } from "./voice-transcription.mjs";
-import { createProviderDispatch } from "./provider-dispatch.mjs";
 import { createParentBridge } from "./parent-bridge.mjs";
 import { createInboundRouting } from "./inbound-routing.mjs";
 import { createToolDispatch } from "./tool-dispatch.mjs";
@@ -500,7 +499,6 @@ import { TOOL_DEFS } from '../tool-defs.mjs';
 // bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
 // orphan worker-level MCP Server: the parent (server.mjs) owns the single
 // connected transport and routes CallTool through the IPC `call` path.
-const PROVIDER_TOOLS = /* @__PURE__ */ new Set(["reply", "fetch"]);
 // ── Inbound routing / dedup / ownership helpers ─────────────────────────────
 // Extracted → lib/inbound-routing.mjs. Bound to live config/identity getters.
 const {
@@ -512,19 +510,6 @@ const {
   getInstanceId: () => INSTANCE_ID,
   getChannelOwnerPath,
 });
-// ── Provider-tool dispatch helpers ───────────────────────────────────────────
-// Each helper dispatches through the local provider (this process is always the
-// owner in opt-in remote mode). Extracted → lib/provider-dispatch.mjs. Bound to
-// live config/provider getters so runtime reloads keep the original file-level
-// reference semantics.
-const {
-  dispatchReply,
-  dispatchFetch,
-} = createProviderDispatch({
-  getConfig: () => config,
-  getProvider: () => provider,
-  scheduler,
-});
 // ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
 // handleToolCall switch + bridge auto-connect retry wrapper. Extracted →
 // lib/tool-dispatch.mjs. The switch is entangled with ~8 runtime-lifecycle
@@ -538,10 +523,7 @@ const {
   handleToolCallWithBridgeRetry,
 } = createToolDispatch({
   getForwarder: () => forwarder,
-  PROVIDER_TOOLS,
   isChannelsDegraded,
-  dispatchReply,
-  dispatchFetch,
   lifecycle: {
     getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
     getChannelBridgeActive: () => channelBridgeActive,

package/src/runtime/channels/tool-defs.mjs

@@ -1,49 +1,7 @@
 export const TOOL_DEFS = [
-  {
-    name: "reply",
-    title: "Discord Reply",
-    annotations: { title: "Discord Reply", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-    description: "Send message to configured channel. files are local paths.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        message: { type: "string", description: "Message text for the configured channel." },
-        reply_to: { type: "string", description: "Reply message id." },
-        files: {
-          type: "array",
-          items: { type: "string" },
-          description: "Local file paths."
-        },
-        embeds: {
-          type: "array",
-          items: { type: "object", additionalProperties: true },
-          description: "Discord embeds."
-        },
-        components: {
-          type: "array",
-          items: { type: "object", additionalProperties: true },
-          description: "Discord components."
-        }
-      },
-      required: ["message"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "fetch",
-    title: "Fetch",
-    annotations: { title: "Fetch", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    description: "Discord-only: read recent messages from a channel.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        channel: { type: "string", description: "Discord channel id." },
-        limit: { type: "number", description: "Max messages." }
-      },
-      required: ["channel"],
-      additionalProperties: false
-    }
-  },
+  // reply/fetch model-facing tools removed 2026-08: the output forwarder
+  // delivers session output to the channel and the inbound bridge injects
+  // incoming messages, so the model never needed to call them directly.
   // memory and recall_memory tools are now provided by memory-service.mjs via MCP
   // react/edit_message/download_attachment tools removed (no remaining
   // callers); provider editMessage/downloadAttachment/react methods stay for

package/src/runtime/shared/child-spawn-gate.mjs

@@ -40,13 +40,24 @@ export function resolveDefaultChildSpawnLaneMaxInflight(
   if (Number.isFinite(laneOverride) && laneOverride >= 1) return Math.floor(laneOverride);
   const sharedOverride = Number(env.MIXDOG_CHILD_SPAWN_MAX_INFLIGHT);
   if (Number.isFinite(sharedOverride) && sharedOverride >= 1) return Math.floor(sharedOverride);
-  if (platform !== 'win32') return Infinity;
+  const cpus = Math.max(1, Math.floor(Number(parallelism) || 1));
+  if (platform !== 'win32') {
+    // No AV amplification, but disk/CPU saturation is platform-neutral: an
+    // unbounded multi-agent burst still convoys. Bound search generously.
+    return lane === 'search' ? Math.max(4, Math.min(12, Math.ceil(cpus / 2))) : Infinity;
+  }
+  // Shell/child process creation window (CreateProcess + Defender scan).
+  // Slots are held only across the spawn itself, so a small cap smooths the
+  // AV convoy without limiting how many commands run concurrently.
+  if (lane === 'process-spawn') return Math.max(2, Math.min(4, Math.floor(cpus / 6) || 2));
+  // One cold graph build saturates memory/disk; allow a second only on big hosts.
+  if (lane === 'code-graph') return cpus >= 12 ? 2 : 1;
   if (lane !== 'search') return 1;
   // Multiple rg processes beat one under multi-session load, but each process
-  // is itself threaded and Defender amplifies excess fan-out. Scale slowly and
-  // cap at four: 4 cores→1, 8→2, 12→3, 16+→4.
-  const cpus = Math.max(1, Math.floor(Number(parallelism) || 1));
-  return Math.max(1, Math.min(4, Math.floor(cpus / 4)));
+  // is itself threaded and Defender amplifies excess fan-out. Burst stress
+  // measured cap-4 starvation (find p50 15s at 8 concurrent sessions), so
+  // scale with cores and cap at eight: 4→2, 8→3, 12→4, 18→6, 24+→8.
+  return Math.max(2, Math.min(8, Math.ceil(cpus / 3)));
 }
 
 const DEFAULT_MAX_INFLIGHT = resolveDefaultChildSpawnMaxInflight();

package/src/runtime/shared/tool-result-summary.mjs

@@ -400,7 +400,6 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
     case 'remember':
     case 'save_memory':
     case 'update_memory':
-    case 'reply':
     case 'request_user_input':
     case 'update_plan':
     case 'cwd':

package/src/runtime/shared/tool-surface.mjs

@@ -175,8 +175,6 @@ export function displayToolName(name, args = {}) {
       return 'Agent';
     case 'code_graph':
       return codeGraphLabel(parseToolArgs(args));
-    case 'reply':
-      return 'Channel';
     default:
       return titleizeToolName(name);
   }
@@ -308,8 +306,6 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
     }
     case 'code_graph':
       return codeGraphSummary(a, max);
-    case 'reply':
-      return truncateToolText(a.channel || a.channelId || a.messageId || a.emoji || '', max);
     case 'skill':
     case 'skill_execute':
     case 'skill_view':
@@ -384,7 +380,6 @@ const TOOL_CATEGORY = new Map([
   ['job_wait', 'Shell'],
   ['task', 'Task'],
   ['agent', 'Agent'],
-  ['reply', 'Channel'],
   ['list_mcp_resources', 'Setup'],
   ['list_mcp_resource_templates', 'Setup'],
   ['cwd', 'Setup'],
@@ -576,8 +571,6 @@ export function toolWorkUnit(name, args = {}, category = '') {
     case 'skills_list':
     case 'use_skill':
       return unitDescriptor('Skill', { count: queryCount(a, 'name', 'skill', 'skill_name', 'query', 'q') || 1, noun: 'skill' });
-    case 'reply':
-      return unitDescriptor('Channel', { count: queryCount(a, 'messages', 'messageId', 'text') || 1, noun: 'message' });
     case 'code_graph': {
       const mode = String(a.mode || a.action || '').toLowerCase();
       const searching = mode === 'search' || mode === 'find_symbol' || mode === 'references' || mode === 'callers' || mode === 'callees';

package/src/runtime/shared/uv-threadpool-boot.mjs

@@ -0,0 +1,13 @@
+// Evaluate BEFORE the first libuv threadpool consumer (async fs/dns/zlib/
+// crypto): Node sizes the pool lazily on first use from UV_THREADPOOL_SIZE.
+// The default of 4 starves bursty multi-session tool execution — dozens of
+// concurrent async stats/reads queue behind 4 workers and simple stats take
+// seconds (observed >5s, tripping the dead-mount reachability guard on live
+// local paths). Size to the host, bounded: operators override by setting the
+// env var themselves.
+import { availableParallelism } from 'node:os';
+
+if (!process.env.UV_THREADPOOL_SIZE) {
+  const cpus = Math.max(1, Number(availableParallelism()) || 1);
+  process.env.UV_THREADPOOL_SIZE = String(Math.min(16, Math.max(8, cpus)));
+}

package/src/session-runtime/runtime-core.mjs

@@ -1,3 +1,4 @@
+import '../runtime/shared/uv-threadpool-boot.mjs';
 import { createSessionLifecycle } from './session-lifecycle.mjs';
 import { createSessionTitleController } from './session-title.mjs';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';

package/src/session-runtime/tool-catalog-data.mjs

@@ -42,7 +42,7 @@ export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
 
 export const READONLY_TOOL_NAMES = new Set([
   'read', 'list', 'grep', 'find', 'glob', 'code_graph', 'search',
-  'web_fetch', 'recall', 'memory', 'fetch', 'Skill',
+  'web_fetch', 'recall', 'memory', 'Skill',
 ]);
 
 export const DEFERRED_SELECT_ALIASES = {
@@ -50,8 +50,6 @@ export const DEFERRED_SELECT_ALIASES = {
   search: ['search', 'web_fetch'],
   web: ['web_fetch', 'search'],
   memory: ['memory', 'recall'],
-  channels: ['reply', 'fetch'],
-  discord: ['reply', 'fetch'],
   agent: ['agent'],
   graph: ['code_graph'],
   code: ['code_graph'],

package/src/session-runtime/warmup-schedulers.mjs

@@ -145,6 +145,14 @@ export function createWarmupSchedulers({
       void warmCatalogsInBackground()
         .then(() => bootProfile('model-catalog:warm-ready'))
         .catch((error) => bootProfile('model-catalog:warm-failed', { error: error?.message || String(error) }));
+      // Resident native search server: pre-resolve the binary and start the
+      // warm process so the session's FIRST grep/glob already skips the rg
+      // spawn instead of racing the async binary resolution. Best-effort;
+      // honors MIXDOG_SEARCH_SERVER=0 inside the warm call.
+      void import('../runtime/agent/orchestrator/tools/builtin/native-search-client.mjs')
+        .then((mod) => mod.warmNativeSearchServer?.())
+        .then((up) => bootProfile('native-search:warm', { up: up === true }))
+        .catch(() => {});
     }, delayMs);
     timers.modelCatalogWarmupTimer.unref?.();
   }

package/src/session-runtime/workflow.mjs

@@ -24,6 +24,11 @@ const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
 const BUILTIN_SLOT_AGENT_IDS = new Set(
   FIXED_AGENT_SLOTS.filter((agent) => agent.workflowSlot).map((agent) => agent.id),
 );
+const STARTER_AGENT_ORDER = new Map([
+  ['worker', 0],
+  ['heavy-worker', 1],
+  ['reviewer', 2],
+]);
 export const DEFAULT_WORKFLOW_ID = 'default';
 
 const SEARCH_CAPABLE_PROVIDERS = new Set([
@@ -157,7 +162,14 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
         ids.add(id);
       }
     }
-    return [...ids].sort();
+    return [...ids].sort((left, right) => {
+      const leftRank = STARTER_AGENT_ORDER.get(left);
+      const rightRank = STARTER_AGENT_ORDER.get(right);
+      if (leftRank !== undefined || rightRank !== undefined) {
+        return (leftRank ?? Number.MAX_SAFE_INTEGER) - (rightRank ?? Number.MAX_SAFE_INTEGER);
+      }
+      return left.localeCompare(right);
+    });
   }
 
   function readWorkflowPackFromDir(dir, source = 'built-in', dirName = '') {

package/src/standalone/channel-worker.mjs

@@ -11,8 +11,6 @@ import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '.
 import { attachChannel, readChannelDiscovery, probeChannelHealth } from './channel-client.mjs';
 
 const CHANNEL_TOOLS = new Set([
-  'reply',
-  'fetch',
   'activate_channel_bridge',
   'reload_config',
   'rebind_current_transcript',

package/src/standalone/daemon.mjs

@@ -17,6 +17,9 @@
 process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 // This process owns session runtimes and must never proxy back into itself.
 process.env.MIXDOG_DAEMON_HOST = '1';
+// Size the libuv threadpool before any async fs work spins it up (see
+// uv-threadpool-boot.mjs) — imports below already touch fs.
+await import('../runtime/shared/uv-threadpool-boot.mjs');
 
 // V8 compile cache: the daemon is a standalone child entry (not via cli.mjs);
 // caching compiled bytecode across restarts removes the channels+memory

package/src/tui/dist/index.mjs

@@ -3719,7 +3719,6 @@ function summarizeToolResult(name, args, resultText, isError = false) {
     case "remember":
     case "save_memory":
     case "update_memory":
-    case "reply":
     case "request_user_input":
     case "update_plan":
     case "cwd":
@@ -3914,8 +3913,6 @@ function displayToolName(name, args = {}) {
       return "Agent";
     case "code_graph":
       return codeGraphLabel(parseToolArgs(args));
-    case "reply":
-      return "Channel";
     default:
       return titleizeToolName(name);
   }
@@ -4045,8 +4042,6 @@ function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}) {
     }
     case "code_graph":
       return codeGraphSummary(a, max);
-    case "reply":
-      return truncateToolText(a.channel || a.channelId || a.messageId || a.emoji || "", max);
     case "skill":
     case "skill_execute":
     case "skill_view":
@@ -4125,7 +4120,6 @@ var TOOL_CATEGORY = /* @__PURE__ */ new Map([
   ["job_wait", "Shell"],
   ["task", "Task"],
   ["agent", "Agent"],
-  ["reply", "Channel"],
   ["list_mcp_resources", "Setup"],
   ["list_mcp_resource_templates", "Setup"],
   ["cwd", "Setup"],
@@ -4293,8 +4287,6 @@ function toolWorkUnit(name, args = {}, category = "") {
     case "skills_list":
     case "use_skill":
       return unitDescriptor("Skill", { count: queryCount(a, "name", "skill", "skill_name", "query", "q") || 1, noun: "skill" });
-    case "reply":
-      return unitDescriptor("Channel", { count: queryCount(a, "messages", "messageId", "text") || 1, noun: "message" });
     case "code_graph": {
       const mode = String(a.mode || a.action || "").toLowerCase();
       const searching = mode === "search" || mode === "find_symbol" || mode === "references" || mode === "callers" || mode === "callees";

package/src/tui/session/session-api.mjs

@@ -50,6 +50,10 @@ export function createSessionApiA(bag) {
   const {
     runtime, nextId, flags, pending, listeners, getState, getPublishedState = getState, set, flushEmitImmediate, pushItem, patchItem, replaceItems, restoreOlderTranscript, restoreNewerTranscript, settleStreamingTail, clearStreamingTail, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, prioritizeQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
+  // submitAsync may be awaiting auto-clear while the renderer already owns an
+  // optimistic user row. Keep that intake addressable so Esc can reclaim it
+  // before enqueue()/busy publication without racing a delayed snapshot.
+  const acceptingSubmissions = new Map();
   const submission = (text, options = {}) => {
     const t = promptDisplayText(text, options).trim();
     if (!t) return null;
@@ -58,7 +62,7 @@ export function createSessionApiA(bag) {
     // priority, so it is injected at the next tool/model boundary. Explicit
     // options.priority still wins.
    const priority = options.priority;
-    return {
+    const intake = {
       text,
       queueOptions: {
         ...options,
@@ -70,6 +74,14 @@ export function createSessionApiA(bag) {
         priority,
       },
     };
+    acceptingSubmissions.set(intake.queueOptions.id, intake);
+    return intake;
+  };
+  const enqueueSubmission = (intake) => {
+    const submissionId = String(intake?.queueOptions?.id || '').trim();
+    if (submissionId) acceptingSubmissions.delete(submissionId);
+    if (intake?.cancelled === true) return false;
+    return enqueue(intake.text, intake.queueOptions);
   };
   const submit = (text, options = {}) => {
     const intake = submission(text, options);
@@ -77,7 +89,7 @@ export function createSessionApiA(bag) {
     // A running clear (idle auto-clear or session_manage) sets commandBusy;
     // queue the prompt instead of dropping it — it drains after the clear.
     if (flags.autoClearRunning) {
-      return enqueue(intake.text, intake.queueOptions) !== false;
+      return enqueueSubmission(intake) !== false;
     }
     // Any in-flight session command (clear/setModel/newSession/resume/...)
     // holds commandBusy. Previously the prompt was dropped here and only the
@@ -85,16 +97,16 @@ export function createSessionApiA(bag) {
     // commandBusy, and the central release hook re-kicks drain once the
     // command settles, so the prompt runs afterwards rather than vanishing.
     if (getState().commandBusy) {
-      return enqueue(intake.text, intake.queueOptions) !== false;
+      return enqueueSubmission(intake) !== false;
     }
     if (getState().busy) {
-      return enqueue(intake.text, intake.queueOptions) !== false;
+      return enqueueSubmission(intake) !== false;
     }
     // If autoClearBeforeSubmit rejects (e.g. compaction timeout throws), the
     // prompt must still be queued — swallow the rejection so enqueue always
     // runs and the submit is never silently lost.
     void autoClearBeforeSubmit().catch(() => {}).then(
-      () => enqueue(intake.text, intake.queueOptions),
+      () => enqueueSubmission(intake),
     );
     return true;
   };
@@ -108,7 +120,7 @@ export function createSessionApiA(bag) {
     if (!flags.autoClearRunning && !getState().commandBusy && !getState().busy) {
       await autoClearBeforeSubmit().catch(() => {});
     }
-    return enqueue(intake.text, intake.queueOptions) !== false;
+    return enqueueSubmission(intake) !== false;
   };
   return {
     getState: () => getPublishedState(),
@@ -634,11 +646,33 @@ export function createSessionApiA(bag) {
         set({ commandBusy: false, commandStatus: null });
       }
     },
-    compact: async () => {
+    compact: async function compactCommand() {
       if (getState().commandBusy) return null;
       if (getState().busy) {
-        pushNotice('Compact skipped: turn in progress', 'info');
-        return { changed: false, reason: 'compact skipped: turn in progress' };
+        // Schedule instead of dropping: /compact mid-turn runs once the turn
+        // AND the queued follow-ups finish (compacting between queued turns
+        // would interleave a summary pass into the user's planned sequence).
+        // One pending schedule at a time; the timer is unref'd so it never
+        // holds the process open, and any error path clears it.
+        if (bag._scheduledCompactTimer) {
+          pushNotice('Compact already scheduled for turn end', 'info');
+          return { changed: false, scheduled: true };
+        }
+        pushNotice('Compact scheduled: runs when the current turn finishes', 'info');
+        bag._scheduledCompactTimer = setInterval(() => {
+          try {
+            const s = getState();
+            if (s.busy || s.commandBusy || (s.queued || []).length > 0) return;
+            clearInterval(bag._scheduledCompactTimer);
+            bag._scheduledCompactTimer = null;
+            void compactCommand();
+          } catch {
+            try { clearInterval(bag._scheduledCompactTimer); } catch { /* gone */ }
+            bag._scheduledCompactTimer = null;
+          }
+        }, 750);
+        bag._scheduledCompactTimer.unref?.();
+        return { changed: false, scheduled: true };
       }
       const startedAt = Date.now();
       set({ commandBusy: true, commandStatus: { active: true, verb: 'Compacting conversation', startedAt, mode: 'compacting' } });
@@ -690,7 +724,34 @@ export function createSessionApiA(bag) {
       }
     },
     abort: (options = {}) => {
-      if (!getState().busy) return false;
+      const submissionId = String(options?.submissionId || '').trim();
+      if (!getState().busy) {
+        if (!submissionId) return false;
+        const restored = restoreQueued('', submissionId);
+        if (!restored || Number(restored.count) < 1) {
+          const intake = acceptingSubmissions.get(submissionId);
+          if (!intake) return false;
+          intake.cancelled = true;
+          const attachments = hydratePastedAttachments(
+            intake.queueOptions.pastedImages,
+            intake.queueOptions.pastedTexts,
+          );
+          return {
+            aborted: false,
+            restoreText: String(intake.queueOptions.displayText || '').trim(),
+            pastedImages: attachments.pastedImages,
+            pastedTexts: attachments.pastedTexts,
+            restoredSubmissionIds: [submissionId],
+          };
+        }
+        return {
+          aborted: false,
+          restoreText: restored.text,
+          pastedImages: restored.pastedImages,
+          pastedTexts: restored.pastedTexts,
+          restoredSubmissionIds: restored.ids,
+        };
+      }
       denyAllToolApprovals('interrupted by user');
       const restoreState = flags.activePromptRestore;
       // A queued steering prompt means the user already redirected the turn:
@@ -771,6 +832,9 @@ export function createSessionApiA(bag) {
         discardPastedImages,
         pastedTexts: restored.pastedTexts,
         discardPastedTexts,
+        restoredSubmissionIds: restoreText
+          ? (restoreState?.submittedIds || []).map(String).filter(Boolean)
+          : [],
       };
     },
   };

package/src/runtime/channels/lib/provider-dispatch.mjs

@@ -1,61 +0,0 @@
-import { recordFetchedMessages } from "./status-snapshot.mjs";
-
-// Provider-tool dispatch helpers. Extracted verbatim from channels/index.mjs
-// (behavior-preserving). Bound to live getters so runtime config/provider
-// reloads keep the original file-level reference semantics.
-function createProviderDispatch({ getConfig, getProvider, scheduler }) {
-  async function dispatchReply(args) {
-    const config = getConfig();
-    const channelId = String(args?.chat_id || args?.channel_id || args?.channel || config.channelId || '').trim();
-    const message = args?.message ?? args?.text;
-    if (!channelId) throw new Error('reply requires a configured channel id');
-    if (typeof message !== 'string' || !message.trim()) throw new Error('reply requires message text');
-    let files = args?.files ?? [];
-    if (typeof files === 'string') {
-      try {
-        const parsed = JSON.parse(files);
-        files = Array.isArray(parsed) ? parsed : [files];
-      } catch {
-        files = [files];
-      }
-    }
-    if (!Array.isArray(files)) files = [files];
-    const sendOpts = {
-      replyTo: args?.reply_to ?? args?.replyTo,
-      files,
-      embeds: args?.embeds ?? [],
-      components: args?.components ?? []
-    };
-    let ids;
-    // Pre-send activity bump keeps idle gating consistent during the await.
-    scheduler.noteActivity();
-    const sendResult = await getProvider().sendMessage(channelId, message, sendOpts);
-    scheduler.noteActivity();
-    ids = sendResult.sentIds;
-    const text = ids.length === 1 ? `sent (id: ${ids[0]})` : `sent ${ids.length} parts (ids: ${ids.join(", ")})`;
-    return { content: [{ type: "text", text }] };
-  }
-
-  async function dispatchFetch(args) {
-    // `args.channel` is a raw channel id (no label resolution anymore); when
-    // omitted, fall back to the single configured main channel id.
-    const config = getConfig();
-    const channelId = args.channel || config.channelId || "";
-    const limit = args.limit ?? 20;
-    let msgs;
-    msgs = await getProvider().fetchMessages(channelId, limit);
-    recordFetchedMessages(channelId, channelId, msgs);
-    const text = msgs.length === 0 ? "(no messages)" : msgs.map((m) => {
-      const atts = m.attachmentCount > 0 ? ` +${m.attachmentCount}att` : "";
-      return `[${m.ts}] ${m.user}: ${m.text}  (id: ${m.id}${atts})`;
-    }).join("\n");
-    return { content: [{ type: "text", text }] };
-  }
-
-  return {
-    dispatchReply,
-    dispatchFetch,
-  };
-}
-
-export { createProviderDispatch };