mixdog 0.9.1 → 0.9.2

package/src/output-styles/default.md

@@ -1,22 +1,27 @@
 ---
 name: default
-title: Summary
+title: Default
 description: Concise engineering summaries
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Mixdog default — concise engineering summaries.
+Mixdog default — the most detailed of the three styles, but only as long as the
+task warrants.
 
-- Lead with the outcome plus a single decisive piece of evidence: a path,
-  command, error, or verification result. Drop everything non-essential.
+- Lead with the outcome, then add the supporting detail that matters: what
+  changed, key evidence (paths, commands, errors, verification), and important
+  context. Include trade-offs or follow-up only when they actually matter.
+- Use a few bullets or short paragraphs when they add signal; this style may run
+  longer than Simple, but match length to the work — do not pad a small change
+  into a full report. Cut anything that does not earn its place.
 - Use labels such as `바뀐 점`, `확인한 것`, and `남은 리스크/다음 단계`
-  only in final reports; do not add titles/labels to interim progress text.
-- Collapse trivial tasks to a single short sentence.
+  in final reports to structure the summary; skip labels on interim progress.
+- Collapse trivial tasks to a couple of sentences instead of forcing sections.
 - Synthesize agent or retrieval results; never forward raw reports, long file
   lists, tool traces, or session metadata.
 - Do not hide blockers, failed verification, or required follow-up; surface them
-  in one short clause rather than omitting them.
+  explicitly rather than omitting them.
 - Keep paths, commands, symbols, API names, code, and exact errors verbatim.
 - Never name this style unless asked.

package/src/output-styles/minimal.md

@@ -0,0 +1,25 @@
+---
+name: minimal
+title: Minimal
+description: One- or two-sentence summary
+aliases: extreme, extreme-simple
+keep-coding-instructions: true
+---
+
+# Output Style
+
+Minimal — a very short summary: one or two sentences, nothing more.
+
+- Summarize only the net result in one short sentence; add a second short
+  sentence only if a second fact (verification, blocker) genuinely needs it.
+  Never cram unrelated facts into one run-on line just to stay at one sentence.
+- Summarize, never itemize: do not describe which files changed or how they were
+  edited. State only what the change accomplishes.
+- No headings, bullets, numbered lists, labels, or sections — plain sentences
+  only. This holds even when the request says "report" or "summary"; keep it to
+  one or two sentences regardless.
+- Preferred pattern: `<target> 변경되었습니다. <verification> 통과 완료입니다.`
+- If verification was not run, say the change is done and verification was not
+  run.
+- Preserve only the single decisive path, command, symbol, API name, code, or
+  error verbatim.

package/src/output-styles/oneline.md

@@ -0,0 +1,21 @@
+---
+name: oneline
+title: Oneline
+description: Single sentence under 100 characters
+aliases: one-line, one line, mono
+keep-coding-instructions: true
+---
+
+# Output Style
+
+Oneline — the most minimal style: exactly one sentence, under 100 characters.
+
+- Reply with a SINGLE sentence, always under 100 characters. Never a second
+  sentence, clause pile-up, or run-on that smuggles in extra facts.
+- State only the net result. Drop file lists, how-it-was-done, verification
+  detail, and follow-ups unless one is the single most decisive fact.
+- No headings, bullets, numbered lists, labels, or sections — one plain sentence
+  only, even when the request says "report" or "summary".
+- Preferred pattern: `<target> 변경 완료.`
+- Preserve only the single decisive path, command, symbol, or error verbatim,
+  and only if it fits the limit.

package/src/output-styles/simple.md

@@ -1,22 +1,23 @@
 ---
 name: simple
-title: Practical Concise
+title: Simple
 description: Outcome-first concise handoffs for coding work
-aliases: summary, concise, handoff
+aliases: concise, handoff
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Practical concise — outcome-first handoffs for coding work without report bloat.
+Practical concise — outcome-first handoffs for coding work: summarize the result,
+do not narrate the change.
 
 - Open with the outcome in one sentence: done, blocked, or awaiting a decision.
-- Add only high-signal evidence next: changed paths (use `file_path:line_number`
-  when it helps navigation), commands, lint/test results, or the exact error —
-  not step-by-step narration.
-- Keep controlled detail: usually 1–3 short bullets or 2–4 sentences total.
-  Expand only when the user asks, scope is ambiguous, or a blocker needs concrete
-  next steps.
+- Summarize what the change accomplishes rather than listing every file and how
+  each was edited. Name a path (`file_path:line_number`) only when the reader
+  truly needs it to navigate — not as a per-file changelog.
+- Keep controlled detail: usually 1–3 short bullets or 2–4 sentences total. No
+  step-by-step narration, no exhaustive file/line inventory. Expand only when the
+  user asks, scope is ambiguous, or a blocker needs concrete next steps.
 - On final handoffs, optional labels such as `바뀐 점`, `확인한 것`, and
   `남은 리스크/다음 단계` fit Korean-facing profiles; use plain English labels
   when the thread is English. Do not label interim progress.

package/src/repl.mjs

@@ -160,13 +160,17 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
 
       let streamedText = '';
       let printedAny = false;
+      let printedToolCard = false;
       try {
         const runtime = await ensureRuntime();
         const { result } = await runtime.ask(
           line,
           {
             onToolCall: async (_iter, calls) => {
-              for (const c of calls || []) stdout.write('\n' + (await renderToolCardLazy(c)) + '\n');
+              for (const c of calls || []) {
+                printedToolCard = true;
+                stdout.write('\n' + (await renderToolCardLazy(c)) + '\n');
+              }
           },
             onTextDelta: (chunk) => {
               printedAny = true;
@@ -184,12 +188,18 @@ export async function runRepl({ provider: providerName, model, toolMode = 'full'
         // raw text already on screen is fine (and we must not emit cursor escapes
         // into a pipe).
         if (finalText) {
-          if (printedAny && colorEnabled()) {
+          if (printedAny && colorEnabled() && !printedToolCard) {
             eraseStreamedBlock(streamedText);
             stdout.write(await renderMarkdownLazy(finalText) + '\n');
           } else if (!printedAny) {
             // Nothing streamed live (provider without onTextDelta) — render once.
             stdout.write(await renderMarkdownLazy(finalText) + '\n');
+          } else if (printedToolCard) {
+            // Tool cards are printed after the streamed text. Erasing only the
+            // streamed text from the current cursor position would clear/move
+            // through the card rows and make the terminal scroll jump. Keep the
+            // live transcript as-is for mixed text+tool turns.
+            stdout.write('\n');
           } else {
             // Non-TTY / NO_COLOR: leave the raw stream, just terminate the line.
             stdout.write('\n');

package/src/rules/agent/00-common.md

@@ -8,8 +8,10 @@
   text before tool calls.
 - If tools are needed, call them immediately. Emit text only for the final
   handoff after tool work is done.
-- Final output style: follow the role's stricter output contract when one is
-  defined; otherwise write a compact English handoff for Lead: outcome, key
-  files, verification, and only material risks. Avoid report-style headings,
-  markdown tables unless explicitly requested, long narration, raw logs, and
-  unnecessary next-checks.
+- Final handoff: minimum characters, maximum information for Lead. Follow the
+  role's stricter output contract if defined; else emit fragments — outcome
+  (1 line), key `file:line`(s), verification result, material risks (only if
+  any).
+- Banned as pure cost: report headings, markdown tables (unless requested),
+  prose narration, raw logs/tool traces, speculative next-checks, restated
+  brief, articles/politeness.

package/src/rules/agent/30-explorer.md

@@ -6,17 +6,16 @@ kind: retrieval
 
 # Role: explorer
 
-Locator only. Find likely file/symbol/line anchors for the query; do not
-analyze, debug, decide, or recommend.
+Locator only: likely file/symbol/line anchors; no analysis, debugging, decisions,
+or recommendations.
 
 Output only:
 - `path:line — symbol/name — short reason`
 - or `EXPLORATION_FAILED`
 
-No preambles, including tool-call preambles. No bullets, headings, summaries,
-code quotes, verdicts, or invented coordinates; output anchor lines only.
-Prompt queries need exact function/prompt anchors. Weak anchors: `?`.
+No preambles/tool-call preambles, bullets, headings, summaries, code quotes,
+verdicts, or invented coordinates. Weak anchors: `?`.
 
-Work fast: maximize independent read-only fan-out in every lookup turn. Once
-credible anchors are found, you must stop; do not call another tool or
-broaden/verify.
+One batched lookup turn; first plausible anchor wins. No verification loop,
+synonym sweep, or proof-chasing. Hard stop after 5 tool calls; if uncertain,
+return best weak anchors with `?`.

package/src/rules/lead/01-general.md

@@ -3,7 +3,9 @@
 - Omit direct names, honorifics, headings, and labels in preambles.
 - Preambles are optional: use them only when they add user-visible value, keep
   them to one short sentence, and skip routine lookup narration.
-- When you emit a preamble or other user-facing lead-in, it MUST be in the user's configured response language (see Profile Preferences).
 - Destructive/hard-to-reverse actions require explicit confirmation.
 - Never push, build, or deploy without an explicit user request.
   Implementation approval is not deploy approval.
+- Rather than deferring checks or work to the user, proactively handle whatever
+  you can first, and propose only the parts that need a decision in a
+  consultative tone ("Shall we proceed this way?").

package/src/rules/lead/lead-tool.md

@@ -4,3 +4,10 @@
 - Use the current project/workspace selected by the session. Only change the work project when the user asks for a different project or a tool call explicitly needs another project root.
 - Use `shell` directly for approved git/build/test/run work; do not delegate those commands to agents.
 - Use `agent` for scoped implementation, research, review, and debugging, not for git commit/push/stash or Ship.
+- Reuse the same agent tag/session for follow-up on the same scope (`send` or
+  `spawn` with the same tag reuses a live session). Spawn a new tag only for a
+  genuinely independent scope.
+- Briefs: minimum characters, maximum information. Fixed one-line fragment
+  fields — `Goal:` `Anchors:` `Allow/Forbid:` `Deliver:` `Verify:` (+`Stop:` for
+  heavy-worker). Omit role-known rules (git/preamble bans, output format),
+  background, motivation; non-actionable tokens are wasted cost.

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

@@ -1,14 +1,19 @@
 # Tool Use
 
-- Run independent tool calls in the same turn. Start source lookup with one
-  compact combined batch, not serial probes.
-- Route by clue: `explore` broad unknowns, `code_graph` symbols/deps/callers,
-  `grep` exact text, `find` path/name clues, `glob` structure, `list` dirs,
-  `read` known file windows.
-- Use available `explore` for broad/uncertain repo anchors; narrow queries.
-- Use available `search` / `web_fetch` only for web/current external info;
-  available `recall` only for history.
-- Fan out read-only lookup calls. Batch known independent files with `read`.
-- If editing is available, put related multi-file edits in one `apply_patch`.
-  Do not run state-changing edits or shell alongside other tool calls.
-- Use available `shell` only for git/build/test/run/verification, not browsing.
+- Independent lookups MUST batch in one turn; serialize only when a call needs a prior result.
+- Target validity comes first: symbols/callers/deps → `code_graph`; exact text in
+  a verified scope → `grep`; unknown path/name → `find`; structure → `glob`;
+  dirs → `list`; verified file → `read`; broad unknown with no anchor →
+  `explore`. Never call `grep`/`read` on guessed paths.
+- Concept normalization comes first: one concept gets one batched
+  `grep pattern:[...]` with `output_mode:"content_with_context"` (or one
+  `code_graph symbols[]`). Refine from returned paths; do not repeat equivalent
+  patterns or scopes.
+- On miss/error, normalize the target once and switch tool; on a plausible hit,
+  stop searching and answer from the framed context. Do not follow
+  `content_with_context` with `read` unless the needed span is not shown.
+- Avoid read fragmentation: `read` uses `offset`/`limit` only. If you need 2+
+  spans from one or more known files, make one batched `read` call with
+  `{path,offset,limit}` region objects instead of serial reads.
+- `search`/`web_fetch` for external info; `recall` for history.
+- Don't mix `apply_patch` with shell or other state-changing calls in one turn.

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -9,7 +9,7 @@
  * The returned function uses the existing caller signature, so call sites
  * do not need changes:
  *
- *   const llm = makeAgentDispatch({ role: 'maintenance', preset: 'haiku' });
+ *   const llm = makeAgentDispatch({ agent: 'maintenance', preset: 'haiku' });
  *   const text = await llm({ prompt });
  *
  * Internally it:
@@ -23,7 +23,7 @@
 
 import { loadConfig } from '../config.mjs';
 import { resolveRuntimeSpec } from '../config.mjs';
-import { getHiddenRole, resolveAgentSessionPermission } from '../internal-roles.mjs';
+import { getHiddenAgent, resolveAgentSessionPermission } from '../internal-agents.mjs';
 import { prepareAgentSession } from './session-builder.mjs';
 import {
     askSession,
@@ -50,6 +50,41 @@ function applyBriefCap(text) {
     return `${head}\n\n... [TRUNCATED — full answer was ~${approxTokens} tokens / ${Math.round(text.length / 1024)} KB. Re-run with brief:false for the complete synthesis]`;
 }
 
+function formatCompactElapsedSeconds(ms) {
+    const value = Math.max(0, Number(ms) || 0);
+    if (value <= 0) return '';
+    return `${Math.max(1, Math.ceil(value / 1000))}s`;
+}
+
+function agentCompactEventLabel(event = {}) {
+    const status = String(event.status || '').toLowerCase();
+    const reactive = String(event.trigger || '').toLowerCase() === 'reactive';
+    if (status === 'failed') return reactive ? 'Compact failed (overflow retry)' : 'Compact failed';
+    if (status === 'skipped') return 'Compact skipped';
+    if (status === 'no_change') return 'Compact checked';
+    return reactive ? 'Compact complete (overflow recovery)' : 'Compact complete';
+}
+
+function agentCompactEventDetail(event = {}) {
+    const parts = [];
+    const elapsed = formatCompactElapsedSeconds(Number(event.durationMs ?? event.elapsedMs ?? 0));
+    if (elapsed) parts.push(elapsed);
+    const type = String(event.compactType || event.type || '').trim();
+    if (type && type !== 'semantic') parts.push(type);
+    const trigger = String(event.trigger || '').toLowerCase();
+    if (trigger === 'reactive') parts.push('reactive');
+    else if (trigger === 'manual') parts.push('manual');
+    const before = Number(event.beforeTokens ?? event.pressureTokens ?? 0);
+    const after = Number(event.afterTokens ?? 0);
+    const fmtTok = (n) => {
+        const v = Number(n) || 0;
+        if (v >= 1000) return `${(v / 1000).toFixed(v >= 10_000 ? 0 : 1)}k`;
+        return `${Math.round(v)}`;
+    };
+    if (before > 0 && after > 0 && after !== before) parts.push(`${fmtTok(before)}→${fmtTok(after)}`);
+    return parts.join(' · ');
+}
+
 // Unified-shard policy — most agent sessions (Pool B + Pool C) share the
 // same tool schema so BP_1 is bit-identical across roles and one provider-side
 // cache shard serves every caller. Per-role behaviour is steered by:
@@ -57,9 +92,10 @@ function applyBriefCap(text) {
 //      rules/agent/<role>.md
 //   2. call-time guards (loop.mjs write-block + ai-wrapped-dispatch
 //      recursion break)
-// Hidden-role exceptions are declarative: defaults/hidden-roles.json may set
+// Hidden-agent exceptions are declarative: defaults/agents.json may set
 // toolSchemaProfile when first-turn routing quality is worth a separate tool
-// prefix. Standard profiles are none/read/full; legacy names stay as aliases.
+// prefix. Standard profiles are none/read/full/read-write-search; legacy names
+// stay as aliases.
 // See manager.mjs resolveSessionTools for the single source of truth;
 // agent visibility is declared via annotations.agentHidden on each tool def.
 const HIDDEN_ROLE_TOOL_SCHEMA_PROFILES = Object.freeze({
@@ -73,6 +109,17 @@ const HIDDEN_ROLE_TOOL_SCHEMA_PROFILES = Object.freeze({
         'grep',
         'read',
     ]),
+    'read-write-search': Object.freeze([
+        'code_graph',
+        'find',
+        'glob',
+        'list',
+        'grep',
+        'read',
+        'apply_patch',
+        'search',
+        'web_fetch',
+    ]),
     // Backward-compatible aliases for older hidden-role definitions.
     unified: null,
     'llm-only': Object.freeze([]),
@@ -95,7 +142,7 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
     if (Object.prototype.hasOwnProperty.call(HIDDEN_ROLE_TOOL_SCHEMA_PROFILES, profile)) {
         return HIDDEN_ROLE_TOOL_SCHEMA_PROFILES[profile];
     }
-    process.stderr.write(`[agent-dispatch] unknown hidden-role toolSchemaProfile="${profile}" role="${hidden.name || 'unknown'}"; using full schema\n`);
+    process.stderr.write(`[agent-dispatch] unknown hidden-agent toolSchemaProfile="${profile}" agent="${hidden.agent || 'unknown'}"; using full schema\n`);
     return null;
 }
 
@@ -114,11 +161,11 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
  * Hidden roles read their slot from `maint[maintKey || slot]`; the cycle1/2/3
  * agents share one knob via the `maintKey: 'memory'` override.
  */
-export function resolveMaintenanceRoute({ preset, optsPreset, role, config: cfgIn = null }) {
+export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfgIn = null }) {
     if (preset) return preset;
     if (optsPreset) return optsPreset;
-    if (!role) return null;
-    const hidden = getHiddenRole(role);
+    if (!agent) return null;
+    const hidden = getHiddenAgent(agent);
     if (hidden) {
         try {
             const config = cfgIn || loadConfig({ secrets: false });
@@ -134,14 +181,14 @@ export function resolveMaintenanceRoute({ preset, optsPreset, role, config: cfgI
 export const resolvePresetName = resolveMaintenanceRoute;
 
 // A maintenance slot value is a direct route when it carries provider+model.
-function maintenanceRouteToPreset(routeOrName, role) {
+function maintenanceRouteToPreset(routeOrName, agent) {
     if (!routeOrName || typeof routeOrName !== 'object') return null;
     const provider = String(routeOrName.provider || '').trim();
     const model = String(routeOrName.model || '').trim();
     if (!provider || !model) return null;
     const out = {
-        id: `maint-${role}`,
-        name: `MAINT ${String(role || '').toUpperCase()}`,
+        id: `maint-${agent}`,
+        name: `MAINT ${String(agent || '').toUpperCase()}`,
         type: 'agent',
         provider,
         model,
@@ -157,50 +204,50 @@ function maintenanceRouteToPreset(routeOrName, role) {
  * Build an agent-backed dispatch callback.
  *
  * @param {object} opts
- * @param {string} opts.role        — REQUIRED; canonical role name (worker, cycle1-agent, scheduler-task, ...)
+ * @param {string} opts.agent       — REQUIRED; canonical agent name (worker, cycle1-agent, scheduler-task, ...)
  * @param {string} [opts.taskType]  — optional internal classification stamped on the session
- * @param {string} [opts.preset]    — explicit preset override (bypasses role → preset lookup)
+ * @param {string} [opts.preset]    — explicit preset override (bypasses agent → preset lookup)
  * @param {string} [opts.parentSessionId] — parent agent session for trace aggregation
  * @param {string|null} [opts.ownerSessionId] — owning Mixdog session for statusline isolation
  * @param {AbortSignal} [opts.parentSignal] — optional AbortSignal from the fan-out coordinator;
- *   when aborted the agent role session's own controller is also aborted so the
+ *   when aborted the agent session's own controller is also aborted so the
  *   provider call tears down promptly (parent→child cascade).
  * @returns {(args: { prompt, preset?, sourceName? }) => Promise<string>}
  */
 export function makeAgentDispatch(opts = {}) {
-    if (!opts.role || typeof opts.role !== 'string') {
-        throw new Error('[agent-dispatch] opts.role is required');
+    if (!opts.agent || typeof opts.agent !== 'string') {
+        throw new Error('[agent-dispatch] opts.agent is required');
     }
-    const role = opts.role;
+    const agent = opts.agent;
 
     return async function agentDispatch({ prompt, preset: presetArg, sourceName: sourceNameArg, parentSignal: callParentSignal, idleTimeoutMs: callIdleTimeoutMs }) {
         if (typeof prompt !== 'string' || !prompt) {
-            throw new Error(`[agent-dispatch] prompt required for role "${role}"`);
+            throw new Error(`[agent-dispatch] prompt required for agent "${agent}"`);
         }
 
         const config = opts.config || loadConfig({ secrets: false });
         const routeOrName = resolveMaintenanceRoute({
             preset: presetArg,
             optsPreset: opts.preset,
-            role,
+            agent,
             config,
         });
         if (!routeOrName) {
             throw new Error(
-                `[agent-dispatch] maintenance route unresolved for role "${role}" `
+                `[agent-dispatch] maintenance route unresolved for agent "${agent}" `
                 + `(preset="${presetArg || opts.preset || ''}")`,
             );
         }
         // Preferred path: a maintenance slot that stores its model directly
         // (route object). Legacy path: a slot still holding a preset NAME —
         // resolve it against config.presets for backward compatibility.
-        let preset = maintenanceRouteToPreset(routeOrName, role);
+        let preset = maintenanceRouteToPreset(routeOrName, agent);
         if (!preset) {
             const legacyName = String(routeOrName || '').trim();
             preset = config.presets?.find((p) => p.id === legacyName || p.name === legacyName) || null;
             if (!preset) {
                 throw new Error(
-                    `[agent-dispatch] maintenance route for role "${role}" is neither a `
+                    `[agent-dispatch] maintenance route for agent "${agent}" is neither a `
                     + `{provider,model} route nor a known preset name ("${legacyName}")`,
                 );
             }
@@ -208,11 +255,11 @@ export function makeAgentDispatch(opts = {}) {
         // Stable label for traces / session metadata, derived from the resolved
         // preset object regardless of whether it came from a direct route or a
         // legacy preset name.
-        const presetName = preset.id || preset.name || `maint-${role}`;
+        const presetName = preset.id || preset.name || `maint-${agent}`;
 
         const runtimeSpec = resolveRuntimeSpec(preset, {
             lane: 'agent',
-            agentId: role,
+            agentId: agent,
         });
 
         // Callers (e.g. aiWrapped explore dispatch) may pass an explicit
@@ -232,12 +279,12 @@ export function makeAgentDispatch(opts = {}) {
         // Runtime permission enforcement was removed (every tool call is
         // trusted); schema profiles remain a routing-efficiency layer that
         // narrows the advertised tool list, not a runtime safety gate.
-        const hidden = getHiddenRole(role);
+        const hidden = getHiddenAgent(agent);
         const isPoolC = Boolean(hidden);
         // Permission: read-declared hidden roles are locked in
         // resolveAgentSessionPermission (prepareAgentSession applies the same).
         const permission = resolveAgentSessionPermission(
-            role,
+            agent,
             opts.permission ?? (isPoolC ? (hidden?.permission || 'read') : null),
         );
         // Pool C hidden-role instructions live in BP2 role-scoped context
@@ -252,7 +299,7 @@ export function makeAgentDispatch(opts = {}) {
         // layer (account-level), not the session level.
         const finalPrompt = prompt;
         const { session } = prepareAgentSession({
-            role,
+            agent,
             presetName,
             preset,
             runtimeSpec,
@@ -273,7 +320,7 @@ export function makeAgentDispatch(opts = {}) {
         // count-only "tools=N" line.
         try {
             const _toolNames = (session.tools || []).map((t) => t?.name).filter(Boolean);
-            process.stderr.write(`[agent-dispatch] role=${role} tool-list (${_toolNames.length}): ${_toolNames.join(',')}\n`);
+            process.stderr.write(`[agent-dispatch] agent=${agent} tool-list (${_toolNames.length}): ${_toolNames.join(',')}\n`);
         } catch { /* best-effort diagnostic */ }
 
         await updateSessionStatus(session.id, 'running');
@@ -297,7 +344,7 @@ export function makeAgentDispatch(opts = {}) {
         // - firstResponseTimeoutMs cuts quickly only when the model produces no
         //   first stream/tool activity at all.
         // - idle/tool-running caps come from role stallCap (hidden roles) or env defaults.
-        const _watchdogPolicy = resolveAgentWatchdogPolicy(role, {
+        const _watchdogPolicy = resolveAgentWatchdogPolicy(agent, {
             idleTimeoutMs: Number.isFinite(callIdleTimeoutMs)
                 ? callIdleTimeoutMs
                 : opts.idleTimeoutMs,
@@ -330,11 +377,22 @@ export function makeAgentDispatch(opts = {}) {
             : null;
         if (_idleTimer && typeof _idleTimer.unref === 'function') _idleTimer.unref();
         let terminalStatus = 'idle';
-        process.stderr.write(`[agent-dispatch] role=${role} preset=${presetName} model=${preset.model} provider=${preset.provider} session=${session.id}\n`);
+        process.stderr.write(`[agent-dispatch] agent=${agent} preset=${presetName} model=${preset.model} provider=${preset.provider} session=${session.id}\n`);
         const _agentDispatchT0 = Date.now();
         try {
-            const result = await askSession(session.id, finalPrompt, null, null, cwd);
-            process.stderr.write(`[agent-dispatch] role=${role} session=${session.id} elapsed=${Date.now() - _agentDispatchT0}ms\n`);
+            const result = await askSession(session.id, finalPrompt, null, null, cwd, undefined, {
+                onCompactEvent: (event) => {
+                    try {
+                        const label = agentCompactEventLabel(event);
+                        const detail = agentCompactEventDetail(event);
+                        const suffix = detail ? ` (${detail})` : '';
+                        process.stderr.write(
+                            `[agent-dispatch] agent=${agent} session=${session.id} compact: ${label}${suffix}\n`,
+                        );
+                    } catch { /* best-effort compact visibility */ }
+                },
+            });
+            process.stderr.write(`[agent-dispatch] agent=${agent} session=${session.id} elapsed=${Date.now() - _agentDispatchT0}ms\n`);
             const raw = result?.content || '';
             // Brief cap. Agent role answers (explore/recall/search)
             // occasionally balloon to 8-10k token walls that then ride in the

package/src/runtime/agent/orchestrator/agent-runtime/agent-loop-policy.mjs

@@ -0,0 +1,32 @@
+/**
+ * Agent loop ceiling — a single high runaway-guard shared by every session
+ * (Lead and delegated sub-agents alike). There are intentionally NO low
+ * per-agent caps: a worker/heavy-worker must be free to run as many tool +
+ * synthesis turns as the task needs. This ceiling exists ONLY to stop a truly
+ * runaway loop; it is not a task-length budget.
+ */
+
+function envPositiveInt(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === '') return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+
+// Single runaway guard for ALL sessions. High by design; env-overridable only
+// to raise/lower the safety ceiling, never used as a per-agent task budget.
+export const LEAD_MAX_LOOP_ITERATIONS = envPositiveInt('MIXDOG_AGENT_MAX_LOOP', 200);
+
+/**
+ * Resolve the hard cap used by agentLoop for this session.
+ *
+ * Order: explicit override → session-pinned value → shared runaway guard.
+ * No per-agent low caps are applied.
+ */
+export function resolveSessionMaxLoopIterations(sessionRef, explicit) {
+    if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+    if (Number.isFinite(sessionRef?.maxLoopIterations) && sessionRef.maxLoopIterations > 0) {
+        return Math.floor(sessionRef.maxLoopIterations);
+    }
+    return LEAD_MAX_LOOP_ITERATIONS;
+}

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -4,7 +4,7 @@
  * lastProgressAt during long tool work; this module decides when to abort.
  */
 
-import { getHiddenRole } from '../internal-roles.mjs';
+import { getHiddenAgent } from '../internal-agents.mjs';
 import {
     resolveAgentStallThresholds,
     resolveAgentToolThresholdSeconds,
@@ -31,7 +31,7 @@ function resolveExplicitMs(value, fallback) {
     return fallback;
 }
 
-export function resolveAgentWatchdogPolicy(role, overrides = {}) {
+export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
     const firstResponseMs = resolveExplicitMs(
         overrides.firstResponseTimeoutMs,
         DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
@@ -40,15 +40,27 @@ export function resolveAgentWatchdogPolicy(role, overrides = {}) {
     let idleStaleMs;
     if (Number.isFinite(overrides.idleTimeoutMs) && overrides.idleTimeoutMs >= 0) {
         idleStaleMs = Math.floor(overrides.idleTimeoutMs);
-    } else if (getHiddenRole(role)) {
-        const { abort } = resolveAgentStallThresholds(role);
+    } else if (getHiddenAgent(agent)) {
+        const { abort } = resolveAgentStallThresholds(agent);
         idleStaleMs = abort * 1000;
     } else {
-        idleStaleMs = DEFAULT_STALE_TIMEOUT_MS;
+        // Part B: the primary mid-stream stall catch is now the provider-level
+        // SEMANTIC idle abort (~120s, ping-immune). This public-agent idle is a
+        // BACKSTOP only, so it must not exceed the stall abort (600s default) —
+        // the old 30-min value meant a ping-only wedge that slipped past the
+        // provider layer would still hang the owner for half an hour. Cap it at
+        // the stall abort while keeping 30 min as an absolute ceiling. The
+        // tool-running heartbeat exemption (toolRunningMs, below) is unchanged,
+        // so legitimately long tool calls still refresh progress and are safe.
+        const { abort } = resolveAgentStallThresholds(agent);
+        const backstopMs = Math.max(0, Math.floor(abort * 1000));
+        idleStaleMs = backstopMs > 0
+            ? Math.min(DEFAULT_STALE_TIMEOUT_MS, backstopMs)
+            : DEFAULT_STALE_TIMEOUT_MS;
     }
 
     const idleSec = idleStaleMs / 1000;
-    const toolRunningSec = resolveAgentToolThresholdSeconds(role, idleSec);
+    const toolRunningSec = resolveAgentToolThresholdSeconds(agent, idleSec);
     const toolRunningMs = Math.max(0, Math.floor(toolRunningSec * 1000));
 
     return {