mixdog 0.9.90 → 0.9.92

package/src/runtime/agent/orchestrator/tools/patch/v4a-convert.mjs

@@ -27,6 +27,7 @@ import {
 import {
   findLineSequence,
   findLineSequenceEscapeEquiv,
+  longestCommonSubstringLen,
   splitTextLinesForPatch,
   firstMeaningfulPatchLine,
   nearestPatchLineHint,
@@ -42,6 +43,7 @@ function v4AHunkLineStats(hunk) {
   let newCount = 0;
   const oldLines = [];
   const newLines = [];
+  const oldTags = [];
   for (const raw of hunk.lines || []) {
     if (!raw) continue;
     const tag = raw[0];
@@ -51,15 +53,17 @@ function v4AHunkLineStats(hunk) {
       newCount++;
       oldLines.push(body);
       newLines.push(body);
+      oldTags.push(' ');
     } else if (tag === '-') {
       oldCount++;
       oldLines.push(body);
+      oldTags.push('-');
     } else if (tag === '+') {
       newCount++;
       newLines.push(body);
     }
   }
-  return { oldCount, newCount, oldLines, newLines };
+  return { oldCount, newCount, oldLines, newLines, oldTags };
 }
 
 function findAnchorLine(lines, anchors, fromLine) {
@@ -164,6 +168,46 @@ function eofInsertionIndex(sourceLines) {
   return len > 0 && sourceLines[len - 1] === '' ? len - 1 : len;
 }
 
+// Bounded context-tolerance tier (fuzzy, non-EOF, last resort before the
+// context-miss error). Recovers the measured top remaining failure class —
+// 1-2 nearby context lines drifted since the model last saw the file — under
+// guards that make mis-application practically impossible:
+//   - every '-' (deletion) line must match the file byte-exactly;
+//   - only ' ' (context) lines may mismatch, at most 2, and each drifted
+//     line must still resemble the file line (shared substring >= half);
+//   - at least 2 exact non-blank matches must anchor the window;
+//   - the qualifying window must be UNIQUE across the ENTIRE file;
+//   - the caller REMAPS tolerated context to the file's on-disk lines, so a
+//     drifted patch line never overwrites file content it did not target.
+function findContextTolerantWindow(sourceLines, oldLines, oldTags) {
+  const n = oldLines.length;
+  if (n < 3 || !Array.isArray(oldTags) || oldTags.length !== n) return null;
+  const collapse = (s) => String(s ?? '').replace(/\s+/g, ' ').trim();
+  const similar = (a, b) => {
+    const ca = collapse(a);
+    const cb = collapse(b);
+    if (!ca || !cb) return false;
+    return longestCommonSubstringLen(ca, cb) >= Math.max(4, Math.ceil(Math.max(ca.length, cb.length) / 2));
+  };
+  const windows = [];
+  for (let i = 0; i + n <= sourceLines.length && windows.length < 2; i++) {
+    let mismatches = 0;
+    let exactNonBlank = 0;
+    let ok = true;
+    for (let k = 0; k < n; k++) {
+      const pat = oldLines[k];
+      const src = sourceLines[i + k];
+      if (src === pat) {
+        if (collapse(pat)) exactNonBlank++;
+        continue;
+      }
+      if (oldTags[k] !== ' ' || ++mismatches > 2 || !similar(pat, src)) { ok = false; break; }
+    }
+    if (ok && mismatches > 0 && exactNonBlank >= 2) windows.push(i);
+  }
+  return windows.length === 1 ? { start: windows[0] } : null;
+}
+
 function resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, options = {}) {
   const stats = v4AHunkLineStats(hunk);
   if (stats.oldCount === 0 && stats.newCount === 0) return { skip: true };
@@ -242,6 +286,33 @@ function resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, options = {})
       }
     }
   }
+  // Context-tolerance tier: see findContextTolerantWindow. Tolerated context
+  // lines are remapped to the file's actual lines on BOTH the old and new
+  // side (same shape as the escape-equiv remap above); remapping bails on any
+  // string ambiguity so an unrelated occurrence can never be rewritten.
+  if (oldStartIdx < 0 && fuzzy && !eof && oldLinesPattern.length >= 3) {
+    const tolTags = trimmedTrailing ? stats.oldTags.slice(0, -1) : stats.oldTags;
+    const tol = findContextTolerantWindow(sourceLines, oldLinesPattern, tolTags);
+    if (tol) {
+      const remapped = new Map();
+      let ambiguous = false;
+      for (let k = 0; k < oldLinesPattern.length; k++) {
+        const pat = oldLinesPattern[k];
+        const src = sourceLines[tol.start + k];
+        if (src === pat) continue;
+        if (
+          oldLinesPattern.filter((l) => l === pat).length > 1
+          || (remapped.has(pat) && remapped.get(pat) !== src)
+        ) { ambiguous = true; break; }
+        remapped.set(pat, src);
+      }
+      if (!ambiguous) {
+        newLinesPattern = newLinesPattern.map((l) => remapped.get(l) ?? l);
+        oldLinesPattern = oldLinesPattern.map((_, k) => sourceLines[tol.start + k]);
+        oldStartIdx = tol.start;
+      }
+    }
+  }
   if (oldStartIdx < 0) {
     const msg = `V4A hunk context not found: ${formatV4AHunkLocator(hunk)};${formatV4AContextMissHint(sourceLines, stats, anchorLine)}`;
     return { error: msg };

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

@@ -48,7 +48,7 @@ const APPLY_PATCH_JSON_DESCRIPTION = [
   '- *** Delete File: <path> with nothing after it.',
   '- *** Update File: <path>, optionally followed by *** Move to: <new path>.',
   'Updates contain hunks introduced by @@ or @@ <enclosing class/function>. Prefix every hunk line with space (context), - (remove), or + (add); a hunk at end of file may close with *** End of File.',
-  'Copy 3 context lines above and below verbatim from the file. Do not duplicate overlapping context. If context is not unique, add one or more enclosing @@ headers.',
+  'Copy 3 context lines above and below verbatim from the newest tool output of the file (never retype from memory; after your own patch, use post-patch content). Do not duplicate overlapping context. If context is not unique, add one or more enclosing @@ headers.',
   'Use project-relative paths. Every added file line needs +. Never submit a compacted-history marker; re-read and create a fresh patch.',
 ].join('\n');
 

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

@@ -115,9 +115,39 @@ function _admissionSaturationError(admission, waitMs) {
   return error;
 }
 
-async function _acquireShellLeaseBounded(admission, { abortSignal, label }) {
+// Memory-pressure rejections from resource-admission are TRANSIENT: they clear
+// when concurrent work finishes releasing RSS/host memory. Measured 2026-08:
+// ~25 shell calls/14d failed instantly on `[resource pressure]` during
+// parallel bench/build waves. Instead of failing the tool call, retry the
+// acquire on a short backoff inside the existing admission deadline so most
+// of those become slightly-delayed successes. Non-memory errors (queue full,
+// detached-dependency, saturation deadline, aborts) still throw immediately.
+function _isMemoryPressureError(err) {
+  if (!err || err.code !== 'ERESOURCEPRESSURE') return false;
+  if (err.metric === 'rss' || err.metric === 'free-memory') return true;
+  return /memory metrics unavailable/i.test(String(err.message || ''));
+}
+
+function _abortableDelay(ms, signal) {
+  return new Promise((resolveDelay) => {
+    let onAbort = null;
+    // NOT unref'd: this delay is awaited foreground work — an unref'd timer
+    // lets the event loop drain and strands the retry loop forever.
+    const timer = setTimeout(() => {
+      if (onAbort && signal) { try { signal.removeEventListener('abort', onAbort); } catch {} }
+      resolveDelay();
+    }, ms);
+    if (signal) {
+      onAbort = () => { clearTimeout(timer); resolveDelay(); };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+export async function acquireShellLeaseBounded(admission, { abortSignal, label, dependency = 'scoped' } = {}) {
   if (!(SHELL_ADMISSION_WAIT_MS > 0)) {
-    return admission.acquire('shell', { signal: abortSignal || null, label });
+    return admission.acquire('shell', { signal: abortSignal || null, label, dependency });
   }
   const ctl = new AbortController();
   const onAbort = () => {
@@ -127,17 +157,26 @@ async function _acquireShellLeaseBounded(admission, { abortSignal, label }) {
     if (abortSignal.aborted) onAbort();
     else abortSignal.addEventListener('abort', onAbort, { once: true });
   }
+  const deadlineAt = Date.now() + SHELL_ADMISSION_WAIT_MS;
   const deadline = setTimeout(() => {
     try { ctl.abort(_admissionSaturationError(admission, SHELL_ADMISSION_WAIT_MS)); } catch {}
   }, SHELL_ADMISSION_WAIT_MS);
   if (deadline.unref) deadline.unref();
   try {
-    const lease = await admission.acquire('shell', { signal: ctl.signal, label });
-    // Hand governance back to the caller's signal: the internal deadline
-    // controller may still fire in a lost race after grant, and a stale
-    // aborted signal on the lease would poison later parent-restore paths.
-    lease.signal = abortSignal || null;
-    return lease;
+    for (;;) {
+      try {
+        const lease = await admission.acquire('shell', { signal: ctl.signal, label, dependency });
+        // Hand governance back to the caller's signal: the internal deadline
+        // controller may still fire in a lost race after grant, and a stale
+        // aborted signal on the lease would poison later parent-restore paths.
+        lease.signal = abortSignal || null;
+        return lease;
+      } catch (err) {
+        const remainingMs = deadlineAt - Date.now();
+        if (!_isMemoryPressureError(err) || ctl.signal.aborted || remainingMs <= 1_200) throw err;
+        await _abortableDelay(Math.min(1_000, remainingMs), ctl.signal);
+      }
+    }
   } finally {
     clearTimeout(deadline);
     if (abortSignal) { try { abortSignal.removeEventListener('abort', onAbort); } catch {} }
@@ -320,7 +359,7 @@ export function execShellCommand({
     let _markerFilters = null;
     let _onChildErrorRef = null;
     try {
-      resourceLease = await _acquireShellLeaseBounded(admission, {
+      resourceLease = await acquireShellLeaseBounded(admission, {
         abortSignal,
         label: String(command || '').slice(0, 120),
       });

package/src/runtime/channels/backends/discord.mjs

@@ -12,7 +12,9 @@ async function ensureDiscord() {
 import {
   mkdirSync,
   statSync,
-  realpathSync
+  realpathSync,
+  readdirSync,
+  unlinkSync
 } from "fs";
 import { join, sep } from "path";
 import { createHash } from "crypto";
@@ -83,8 +85,26 @@ class DiscordBackend {
   }
   // ── Lifecycle ──────────────────────────────────────────────────────
   async connect() {
+    this._sweepInboxOnce();
     return gateway.connect(this);
   }
+  // Voice/attachment inbox retention: downloaded .ogg/.wav payloads are
+  // consumed at transcription time and were never cleaned up (audit: 477
+  // files / 55 MB accumulated since July). Best-effort, once per process.
+  _sweepInboxOnce() {
+    if (this._inboxSweepDone) return;
+    this._inboxSweepDone = true;
+    try {
+      const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+      for (const name of readdirSync(this.inboxDir)) {
+        const p = join(this.inboxDir, name);
+        try {
+          const st = statSync(p);
+          if (st.isFile() && st.mtimeMs < cutoff) unlinkSync(p);
+        } catch { /* per-file best-effort */ }
+      }
+    } catch { /* inbox may not exist yet */ }
+  }
   async disconnect() {
     for (const interval of this.typingIntervals.values()) {
       clearInterval(interval);

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

@@ -32,7 +32,7 @@ export const TOOL_DEFS = [
     name: "fetch",
     title: "Fetch",
     annotations: { title: "Fetch", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    description: "Discord-only recent messages. NOT for URLs; use web_fetch.",
+    description: "Discord-only: read recent messages from a channel.",
     inputSchema: {
       type: "object",
       properties: {

package/src/runtime/memory/lib/trace-store.mjs

@@ -465,13 +465,18 @@ async function ensureCurrentAndNextMonthPartitions(client) {
 // Trace retention: drop named monthly partitions older than the configured
 // window. Trace is regenerable observability data, so aging out old months is
 // non-destructive to durable state. Config via MIXDOG_TRACE_RETENTION_MONTHS
-// (default 6); set to 0 to disable. Only DROPs partitions strictly older than
+// (default 1); set to 0 to disable. Only DROPs partitions strictly older than
 // the cutoff month; the default catch-all partition is never dropped.
+// Default rationale: a personal-machine audit found trace partitions at 76%
+// of the 1.5 GB memory DB (July alone 787 MB) while durable entries were
+// 207 MB. Monthly partitions mean retention 1 always keeps the current +
+// previous month (30-60 days of full-resolution diagnostics) while bounding
+// the DB to a rolling ceiling instead of unbounded growth.
 const TRACE_RETENTION_MONTHS = (() => {
   const raw = process.env.MIXDOG_TRACE_RETENTION_MONTHS
-  if (raw == null || raw === '') return 6
+  if (raw == null || raw === '') return 1
   const n = Number(raw)
-  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 6
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 1
 })()
 
 async function dropAgedTracePartitions(client) {
@@ -499,6 +504,22 @@ async function dropAgedTracePartitions(client) {
   `)
 }
 
+// Row-level ageing for the non-partitioned trace side tables. agent_calls and
+// agent_llm grew unbounded (284 MB observed) because only trace_events had a
+// retention path. Same window, same regenerable-diagnostics rationale; space
+// is reclaimed by autovacuum row reuse rather than immediate disk shrink.
+async function deleteAgedTraceRows(client) {
+  if (TRACE_RETENTION_MONTHS <= 0) return
+  const months = TRACE_RETENTION_MONTHS
+  for (const table of ['agent_calls', 'agent_llm', 'bridge_calls', 'bridge_llm']) {
+    try {
+      await client.query(`DELETE FROM ${table} WHERE ts < now() - interval '${months} months'`)
+    } catch (err) {
+      __mixdogMemoryLog(`[trace-store] aged-row delete skipped for ${table}: ${err?.message ?? err}\n`)
+    }
+  }
+}
+
 async function isBootstrapComplete(client) {
   try {
     // Harden the check: require (a) root is partitioned, (b) schema-version
@@ -624,6 +645,7 @@ export async function openTraceDatabase(dataDir) {
         await c.query(`SET search_path = trace, public`)
         await ensureCurrentAndNextMonthPartitions(c)
         await dropAgedTracePartitions(c)
+        await deleteAgedTraceRows(c)
       } catch (err) {
         __mixdogMemoryLog(`[trace-store] periodic partition ensure failed: ${err?.message ?? err}\n`)
       } finally {

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

@@ -48,7 +48,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history for prior-work context (resumes, earlier decisions); not a reflexive pre-step. Query is topic/semantic, not regex; period selects the time window; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history for prior-work context (resumes, earlier decisions). Query is topic/semantic, not regex; period selects the time window; id for exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -60,12 +60,10 @@ export const TOOL_DEFS = [
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },
         category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
         includeArchived: { type: 'boolean', description: 'Include archived entries.' },
-        sessionId: { type: 'string', description: 'Scoped session id.' },
         includeMembers: { type: 'boolean', description: 'Include chunk members in output; does not widen the search pool.' },
         includeRaw: { type: 'boolean', description: 'Include unchunked raw/episode rows.' },
         sessionOnly: { type: 'boolean', description: 'Search this session only.' },
         projectScope: { type: 'string', description: 'Project pool selector: inferred from cwd, common, all, or slug.' },
-        cwd: { type: 'string', description: 'Infer projectScope.' },
       },
       additionalProperties: false,
     },

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

@@ -8,7 +8,7 @@ export const TOOL_DEFS = [
   {
     name: 'search',
     title: 'Mixdog Web Search',
-    description: `Web/docs/current-info search; not repo-local. ${TOOL_SYNC_EXECUTION_CONTRACT} Cached; query supports array fan-out.`,
+    description: `Web/docs/current-info search. ${TOOL_SYNC_EXECUTION_CONTRACT} Cached; query supports array fan-out.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -16,23 +16,7 @@ export const TOOL_DEFS = [
         site: { type: 'string', description: 'Site/domain filter.' },
         type: { type: 'string', enum: ['web', 'news', 'images'], description: 'Default web.' },
         maxResults: { type: 'number', minimum: 1, maximum: 20, description: 'Result count, 1-20.' },
-        locale: {
-          description: 'Optional locale hint.',
-          anyOf: [
-            { type: 'string' },
-            {
-              type: 'object',
-              properties: {
-                country: { type: 'string', description: 'Country.' },
-                language: { type: 'string', description: 'Language.' },
-                region: { type: 'string', description: 'Region.' },
-                city: { type: 'string', description: 'City.' },
-                timezone: { type: 'string', description: 'Timezone.' },
-              },
-              additionalProperties: false,
-            },
-          ],
-        },
+        locale: { type: 'string', description: 'Optional locale hint, e.g. ko-KR or a city/region name.' },
         contextSize: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Default low.' },
       },
       required: [],

package/src/runtime/shared/tool-execution-contract.mjs

@@ -2,7 +2,7 @@ export const TOOL_SYNC_EXECUTION_CONTRACT =
   'Runs synchronously in this tool call.';
 
 export const TOOL_ASYNC_EXECUTION_CONTRACT =
-  'Runs sync inline; no default auto-background. async forces a background task_id + completion notification. status/read/wait are recovery/blocking only.';
+  'Runs sync inline by default; async returns a background task_id and delivers a completion notification.';
 
 export const TOOL_MANUAL_CONTROL_CONTRACT =
   'wait/read/status/cancel are for explicit blocking or recovery only.';

package/src/session-runtime/output-styles.mjs

@@ -5,10 +5,8 @@ import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
 
-const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'extreme-minimal'];
+const OUTPUT_STYLE_ORDER = ['detailed', 'simple', 'minimal', 'extreme-minimal'];
 const OUTPUT_STYLE_ALIASES = new Map([
-  ['compact', 'default'],
-  ['normal', 'default'],
   ['extreme', 'extreme-minimal'],
   ['extremesimple', 'extreme-minimal'],
   ['extreme-simple', 'extreme-minimal'],
@@ -146,15 +144,15 @@ export function findOutputStyle(value, styles) {
 
 function configuredOutputStyleValue(dataDir) {
   const unified = readJsonSafe(join(dataDir, 'mixdog-config.json')) || {};
-  return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'default') || 'default';
+  return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'simple') || 'simple';
 }
 
 export function outputStyleStatus(rootDir, dataDir, { fresh = false } = {}) {
   const styles = listOutputStyleCatalog(rootDir, dataDir, { fresh });
   const configured = configuredOutputStyleValue(dataDir);
   const current = findOutputStyle(configured, styles)
-    || findOutputStyle('default', styles)
+    || findOutputStyle('simple', styles)
     || styles[0]
-    || { id: 'default', label: 'Default', description: '', aliases: [], source: 'builtin' };
+    || { id: 'simple', label: 'Simple', description: '', aliases: [], source: 'builtin' };
   return { configured, current, styles };
 }

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

@@ -18,7 +18,6 @@ export const TOOL_SEARCH_TOOL = {
     type: 'object',
     properties: {
       names: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Exact deferred tool names/aliases to load.' },
-      select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Legacy alias for names; accepts exact names/aliases and select:name syntax.' },
     },
     additionalProperties: false,
   },

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

@@ -26,8 +26,17 @@ export function createToolSurface({
 
   // A workflow that delegates to NOBODY must not advertise the agent tool: a
   // schema-visible tool policy always rejects is a guaranteed error turn.
+  // The SESSION's effective workflow wins over the config-active one: headless
+  // and per-session overrides (e.g. bench `workflow=solo`) never touch the
+  // config default, so keying off config alone left the agent tool visible in
+  // Solo sessions (observed across a full TB2.1 run: advertised, never used).
   function workflowAllowsAgents() {
     try {
+      const sessionWorkflow = getSession()?.workflow;
+      if (sessionWorkflow && typeof sessionWorkflow === 'object'
+          && sessionWorkflow.agentsConfigured === true) {
+        return Array.isArray(sessionWorkflow.agents) && sessionWorkflow.agents.length > 0;
+      }
       const pack = loadWorkflowPack(cfgMod.getPluginData?.() || dataDir, activeWorkflowId(getConfig()));
       if (!pack || pack.agentsConfigured !== true) return true;
       return Array.isArray(pack.agents) && pack.agents.length > 0;

package/src/session-runtime/workflow.mjs

@@ -16,12 +16,18 @@ export const FIXED_AGENT_SLOTS = Object.freeze([
   // (user: 창이 크지 않으니 설명은 짧게).
   { id: 'explore', label: 'Explore', description: 'Repository exploration', workflowSlot: 'explorer' },
   { id: 'maintainer', label: 'Maintainer', description: 'Memory and upkeep', workflowSlot: 'memory' },
-  { id: 'worker', label: 'Worker', description: 'Scoped implementation' },
-  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Multi-file implementation' },
+  { id: 'worker', label: 'Worker', description: 'Simple tasks' },
+  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Complex tasks' },
   { id: 'reviewer', label: 'Reviewer', description: 'Diff and risk review' },
   { id: 'debugger', label: 'Debugger', description: 'Root-cause debugging' },
 ]);
 const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
+// Slot-backed built-ins (explore/maintainer) run through their own dedicated
+// channels — the explore tool and the memory cycle — so they are never
+// Lead-delegation targets and stay out of the Available Agents catalog.
+const BUILTIN_SLOT_AGENT_IDS = new Set(
+  FIXED_AGENT_SLOTS.filter((agent) => agent.workflowSlot).map((agent) => agent.id),
+);
 export const DEFAULT_WORKFLOW_ID = 'default';
 
 const SEARCH_CAPABLE_PROVIDERS = new Set([
@@ -229,6 +235,13 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
       name: clean(pack?.name) || (id === DEFAULT_WORKFLOW_ID ? 'Default' : id),
       description: clean(pack?.description),
       source: clean(pack?.source),
+      // Delegation surface fields: the session stores this summary as
+      // session.workflow, and the agent-tool gate (tool-surface.mjs
+      // workflowAllowsAgents) needs them to filter the agent tool for
+      // packs that delegate to nobody — including headless/bench sessions
+      // whose workflow never touches the config-active pack.
+      agentsConfigured: pack?.agentsConfigured === true,
+      agents: Array.isArray(pack?.agents) ? pack.agents.slice() : [],
     };
   }
 
@@ -275,16 +288,20 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     lines.push(pack.body);
     // A hand-edited pack may name a hidden role in its `agents:` frontmatter;
     // internal roles are never delegatable, so they never enter the catalog.
+    // Slot-backed built-ins are equally non-delegatable (they ride the explore
+    // tool / memory cycle), so they are filtered even when a pack names them.
     const agentIds = (pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id))
-      .filter((id) => !isHiddenAgent(id));
+      .filter((id) => !isHiddenAgent(id) && !BUILTIN_SLOT_AGENT_IDS.has(id));
     const agentBlocks = agentIds.map((id) => loadAgentDefinition(dir, id)).filter(Boolean);
     if (agentBlocks.length) {
       lines.push('# Available Agents');
-      for (const agent of agentBlocks) {
-        lines.push(`## ${agent.name} (${agent.id})`);
-        if (agent.description) lines.push(agent.description);
-        lines.push(agent.body);
-      }
+      // Name + description only: the AGENT.md body is the worker's own system
+      // prompt and rides in the worker session at spawn time — repeating it in
+      // the Lead prompt only bloats context. Lead picks agents by description
+      // (Claude Code whenToUse pattern); the workflow body carries the rules.
+      lines.push(agentBlocks
+        .map((agent) => `- ${agent.name} (${agent.id})${agent.description ? `: ${agent.description}` : ''}`)
+        .join('\n'));
     }
     return lines.join('\n\n');
   }

package/src/tui/dist/index.mjs

@@ -26573,6 +26573,7 @@ function drainTuiSteeringPersist(leadSessionId) {
   return _serialize(async () => {
     let drained = [];
     let droppedStale = 0;
+    let prunedOrphans = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
@@ -26586,7 +26587,21 @@ function drainTuiSteeringPersist(leadSessionId) {
           return !stale;
         });
         drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return void 0;
+        for (const otherKey of Object.keys(next.sessions)) {
+          if (otherKey === key) continue;
+          const rows = Array.isArray(next.sessions[otherKey]) ? next.sessions[otherKey] : [];
+          const otherTouched = Number(next.sessionTouchedAt?.[otherKey]) || 0;
+          const allStale = rows.every((row) => {
+            const at = Number(row?.at) || otherTouched;
+            return at > 0 && now - at > STALE_STEERING_RESTORE_TTL_MS;
+          });
+          if (rows.length === 0 || allStale) {
+            delete next.sessions[otherKey];
+            if (next.sessionTouchedAt) delete next.sessionTouchedAt[otherKey];
+            prunedOrphans += rows.length;
+          }
+        }
+        if (drained.length === 0 && droppedStale === 0 && prunedOrphans === 0) return void 0;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -26602,6 +26617,13 @@ function drainTuiSteeringPersist(leadSessionId) {
     if (droppedStale > 0) {
       try {
         process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}
+`);
+      } catch {
+      }
+    }
+    if (prunedOrphans > 0) {
+      try {
+        process.stderr.write(`[tui] pruned ${prunedOrphans} orphaned steering row(s) from stale sessions
 `);
       } catch {
       }
@@ -30212,6 +30234,15 @@ function createEngineApiA(bag) {
         restoreState.requeueEntries = [];
         restoreState.discardExecutionPendingResumeKeys = [];
       }
+      const pendingAfterAbortKick = setTimeout(() => {
+        try {
+          if (flags.disposed) return;
+          if (getState().busy) return;
+          if (pending.length > 0 && typeof drain === "function") void drain();
+        } catch {
+        }
+      }, 150);
+      pendingAfterAbortKick.unref?.();
       const abortEpoch = flags.leadTurnEpoch;
       const recoveryMs = Number(flags.manualAbortRecoveryMs) > 0 ? Number(flags.manualAbortRecoveryMs) : MANUAL_ABORT_RECOVERY_MS;
       const recoveryTimer = setTimeout(() => {

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

@@ -616,6 +616,23 @@ export function createEngineApiA(bag) {
       // ── Bounded manual-abort recovery ───────────────────────────────────
       // runtime.abort() above normally rejects the in-flight runtime.ask() so
       // the turn's own finally clears busy within a tick. If that unwind is
+      // starved the recovery timer below hard-releases busy. Separately from
+      // recovery: queued work must never strand behind a cancelled turn
+      // (Codex parity — abort preserves pending input for the next turn; CC
+      // parity — the command queue survives cancel and fires when idle). The
+      // drain loop that owns a normal turn continues on its own; this bounded
+      // kick covers unwinds where no drain owner re-checks pending after busy
+      // clears. drain() self-guards (busy/draining/commandBusy), so the
+      // drain-owned path is unchanged and a duplicate kick is a no-op.
+      const pendingAfterAbortKick = setTimeout(() => {
+        try {
+          if (flags.disposed) return;
+          if (getState().busy) return;
+          if (pending.length > 0 && typeof drain === 'function') void drain();
+        } catch { /* best-effort */ }
+      }, 150);
+      pendingAfterAbortKick.unref?.();
+      // If that unwind is
       // starved — e.g. a provider abort that never settles after a post-tool
       // fetch stall — busy would stay true until the far-larger turn watchdog
       // trips, wedging the TUI with dead input. Arm a short grace timer that

package/src/tui/engine/tui-steering-persist.mjs

@@ -195,6 +195,7 @@ export function drainTuiSteeringPersist(leadSessionId) {
   return _serialize(async () => {
     let drained = [];
     let droppedStale = 0;
+    let prunedOrphans = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
@@ -210,7 +211,26 @@ export function drainTuiSteeringPersist(leadSessionId) {
           return !stale;
         });
         drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return undefined;
+        // Orphan cleanup: buckets of OTHER sessions whose every row already
+        // aged past the restore TTL can never be restored (restore is keyed
+        // by the live session id), so they only grow the file forever
+        // (observed live: queued rows from sessions closed days ago). Prune
+        // them under the same lock/write.
+        for (const otherKey of Object.keys(next.sessions)) {
+          if (otherKey === key) continue;
+          const rows = Array.isArray(next.sessions[otherKey]) ? next.sessions[otherKey] : [];
+          const otherTouched = Number(next.sessionTouchedAt?.[otherKey]) || 0;
+          const allStale = rows.every((row) => {
+            const at = Number(row?.at) || otherTouched;
+            return at > 0 && (now - at) > STALE_STEERING_RESTORE_TTL_MS;
+          });
+          if (rows.length === 0 || allStale) {
+            delete next.sessions[otherKey];
+            if (next.sessionTouchedAt) delete next.sessionTouchedAt[otherKey];
+            prunedOrphans += rows.length;
+          }
+        }
+        if (drained.length === 0 && droppedStale === 0 && prunedOrphans === 0) return undefined;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -222,6 +242,9 @@ export function drainTuiSteeringPersist(leadSessionId) {
     if (droppedStale > 0) {
       try { process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}\n`); } catch {}
     }
+    if (prunedOrphans > 0) {
+      try { process.stderr.write(`[tui] pruned ${prunedOrphans} orphaned steering row(s) from stale sessions\n`); } catch {}
+    }
     return drained;
   });
 }