mixdog 0.9.95 → 0.9.96

package/src/defaults/mixdog-config.template.json

@@ -1,15 +1,12 @@
 {
   "outputStyle": "default",
-  "mcpServers": {},
-  "channels": {
-    "promptInjection": {
-      "mode": "hook",
-      "targetPath": ""
-    }
+  "agent": {
+    "mcpServers": {},
+    "profile": { "title": "", "language": "system" },
+    "recap": { "enabled": true }
   },
+  "channels": {},
   "memory": {
-    "enabled": true,
-    "user": { "title": "" },
     "cycle1": { "interval": "10m" },
     "cycle2": { "interval": "1h" }
   }

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

@@ -32,11 +32,14 @@ or concept synonym; never a prose phrase. Spaces and non-ASCII are allowed
 only in verbatim quoted error/log literals. Translate other non-English
 queries to English identifiers.
 
-Scope is session cwd; `path` may be omitted. For unverified `src` paths, use
+Scope is every `<roots><root>…</root></roots>` entry when supplied, otherwise
+session cwd. Search every supplied root in the turn-1 batch: grep/glob batch
+`path[]`, while find uses one sibling call per root. Never silently fall back to
+cwd or omit a supplied root. A find result is relative to its exact root; prefix
+that root when returning a path outside cwd. For unverified `src` paths, use
 `find` first; never guess or invent directories or pair `path:"."` with guessed
-`src/**`. Scoped grep/glob may use only an exact find-returned path, no earlier
-than turn 2. After zero hits, change tokens or scope, never wording or guessed
-paths.
+`src/**`. Scoped grep/glob may use only a supplied root or an exact find-returned
+path. After zero hits, change tokens or scope, never wording or guessed paths.
 
 An anchor is a `path:line` containing a query token or synonym, including a
 code_graph hit. Generic terms without query specificity are zero. Never

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

@@ -1,31 +1,22 @@
 # Tool Use
 
-- Gather every known facet — environment, capability, artifact, failure — in
-  one bounded first message, one shortest route each: unknown coordinates→
-  `explore` first and alone, its anchors routing the next batch (roles without
-  it: `find`); a known path or anchor skips it; partial path/name→`find`;
-  verified root+wildcard→`glob`; text/code→`grep`; symbol/relation→`code_graph`;
-  known file/span→`read`, not `grep`; verified directory→`list`; known
-  edit→`apply_patch`; web/current→`search`; only what none of them reach
-  (process/env, git, build/run/test)→`shell`, never to cat/ls/find/grep.
-- Fewest turns, not fewest calls: always send independent calls together in
-  one message, merged per tool — one `shell` chain (`&&`/`;`), one `read`
-  region array, one `apply_patch` with every determined edit proved by its
-  `post_shell` in the same turn; a later turn only for unseen output.
-- Verified paths: project root, session cwd, user-provided, tool-returned.
-  `find` first for guessed fragments; on ENOENT find the basename; retry
-  `EXPLORATION_FAILED` once with changed tokens.
-- Never re-fetch what a tool already returned: every span this session emitted —
-  `path:line` hits, read regions, an `apply_patch` post-patch body — is final for
-  its range, so read only uncovered lines and stop once evidence covers the
-  deliverable; only zero/error justifies new scope, each call narrow
-  (`head_limit`, regions).
-- Verify in proportion to risk: one decisive probe rides the edit call. A pass
-  is final; on failure fix and rerun what failed. Diagnostics non-fatal; report
-  verified vs assumed.
-- `apply_patch` is the primary edit tool: once path and content are known it
-  joins the current batch — all files and hunks in one call, never one turn per
-  file (the format contract lives in its tool description).
-- After a background task starts or reports, end the turn — its notification
-  resumes the work. Never poll or block; wait only for what the turn cannot
-  proceed without. Long commands whose output the next step ignores go async.
+- Unknown coordinates → one `explore` call with every unknown facet, sent
+  alone. Then batch every anchored retrieval needed to determine the complete
+  edit: partial path/name→`find`; exact directory entries→`list`; wildcard→
+  `glob`; text/regex-anchored source blocks→`grep`; anchorless known file/range→
+  `read`; symbol/relation→`code_graph`; web/current→`search`; returned URL body→
+  `web_fetch`; prior work→`recall`; durable compact English memory→`memory`;
+  explicit project change→`cwd`; explicit user-requested conversation reset→
+  `session_manage`; process/env, git, build/run/test→`shell`. Never use shell
+  equivalents for file discovery or content retrieval.
+- Use verified paths (cwd, project root, user-provided, or tool-returned);
+  guessed fragments use `find`. Merge independent calls per tool in one
+  message and fetch all information needed in that batch. Follow up only after
+  zero/error or a newly revealed dependency; never re-fetch an unchanged span.
+- Once every final edit is fully determined, send one assistant tool batch
+  containing one `apply_patch` for all files/hunks and one `shell` chain for
+  verification. The runtime supports this mixed batch. On failure fix and
+  rerun only what failed; report verified versus assumed.
+- After a call returns a background `task_id`, end the turn; its completion
+  notification resumes work. Never poll; use task control only for recovery or
+  a required blocking result.

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

@@ -36,6 +36,7 @@ import {
     abortAgentProgressWatchdog,
     agentWatchdogPolicyActive,
     evaluateAgentWatchdogAbort,
+    partialHandoffTextFromSession,
     resolveAgentWatchdogPolicy,
     resolveHandoffMessageStartIndex,
     watchdogPartialHandoffFromError,
@@ -65,6 +66,17 @@ function formatCompactElapsedSeconds(ms) {
     return `${Math.max(1, Math.ceil(value / 1000))}s`;
 }
 
+// True when an abort explicitly opted into partial salvage — the error object
+// or the abort reason carries `salvagePartial: true`. A DEADLINE-driven caller
+// (explore hard timeout) sets it so the anchors the sub-agent already produced
+// are returned instead of discarded; user cancellation (ESC) never sets it and
+// keeps the throw-everything behaviour.
+function salvagePartialRequested(error, signal) {
+    if (error && typeof error === 'object' && error.salvagePartial === true) return true;
+    const reason = signal?.reason;
+    return !!(reason && typeof reason === 'object' && reason.salvagePartial === true);
+}
+
 function agentCompactEventLabel(event = {}) {
     const status = String(event.status || '').toLowerCase();
     const reactive = String(event.trigger || '').toLowerCase() === 'reactive';
@@ -229,7 +241,7 @@ export function makeAgentDispatch(opts = {}) {
     }
     const agent = opts.agent;
 
-    return async function agentDispatch({ prompt, preset: presetArg, sourceName: sourceNameArg, parentSignal: callParentSignal, idleTimeoutMs: callIdleTimeoutMs, cwd: callCwd }) {
+    return async function agentDispatch({ prompt, preset: presetArg, sourceName: sourceNameArg, parentSignal: callParentSignal, idleTimeoutMs: callIdleTimeoutMs, cwd: callCwd, sessionId: callSessionId }) {
         if (typeof prompt !== 'string' || !prompt) {
             throw new Error(`[agent-dispatch] prompt required for agent "${agent}"`);
         }
@@ -243,6 +255,7 @@ export function makeAgentDispatch(opts = {}) {
             lease = await admission.acquire('agent', {
                 signal: admissionAbortLink.signal,
                 label: agent,
+                ownerKey: callSessionId || opts.ownerSessionId || opts.parentSessionId || opts.sessionId || null,
             });
         } catch (error) {
             admissionAbortLink.dispose();
@@ -470,7 +483,10 @@ export function makeAgentDispatch(opts = {}) {
             try { closeSession(session.id, 'ephemeral-done'); } catch { /* ignore */ }
             return out;
         } catch (err) {
-            const partial = watchdogPartialHandoffFromError(err, getSession(session.id), _handoffMsgStart);
+            const partial = watchdogPartialHandoffFromError(err, getSession(session.id), _handoffMsgStart)
+                ?? (salvagePartialRequested(err, _abortLink?.signal)
+                    ? partialHandoffTextFromSession(getSession(session.id), _handoffMsgStart)
+                    : null);
             if (partial) {
                 terminalStatus = 'idle';
                 try { closeSession(session.id, 'ephemeral-done'); } catch { /* ignore */ }

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

@@ -7,10 +7,26 @@
 import { appendAgentTrace } from '../agent-trace-io.mjs';
 import { getHiddenAgent } from '../internal-agents.mjs';
 import {
+    PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
+    PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
+    STALL_TICK_MS,
     resolveAgentStallThresholds,
     resolveAgentToolThresholdSeconds,
 } from '../stall-policy.mjs';
 
+// Ordering guarantee, stated in stall-policy.mjs: the provider layer — which
+// can retry in place or fall back to non-streaming — must fire STRICTLY before
+// the agent watchdog's terminal abort. Role abort budgets (worker/reviewer
+// 300s, explore 240s) sat at or BELOW the provider semantic-idle window
+// (300s), inverting that order: the watchdog aborted the shared signal first,
+// so the provider's recovery never ran and the `agent_stall` failure — which
+// the classifier calls retryable — died on throwIfAborted instead. Hold the
+// role-derived idle budget at one watchdog tick above the provider window.
+const PROVIDER_RECOVERY_FLOOR_MS = Math.max(
+    PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
+    PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
+) + STALL_TICK_MS;
+
 const WATCHDOG_ABORT_RE = /^agent (?:first (?:transport|semantic response|response) stale|task stale|tool running stale)\s*\(/;
 
 /**
@@ -123,6 +139,16 @@ export function watchdogPartialHandoffFromError(error, session, messageStartInde
     return text.trim() ? text : null;
 }
 
+// Salvage path for NON-watchdog aborts that explicitly opt in (the abort error
+// / abort reason carries `salvagePartial: true` — e.g. the explore wall-clock
+// hard timeout). Same collection rule as the watchdog handoff: only assistant
+// text appended during this run. Plain user cancellation never opts in, so ESC
+// still discards the run.
+export function partialHandoffTextFromSession(session, messageStartIndex = 0) {
+    const text = collectSessionAssistantHandoffText(session, messageStartIndex);
+    return text.trim() ? text : null;
+}
+
 function resolveWatchdogAbortElapsedMs({ error, snapshot, policy, now, anchorTs, lastProgressAt }) {
     if (snapshot && policy) {
         if (snapshot.waitingForFirstActivity) {
@@ -223,7 +249,8 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
         idleStaleMs = Math.floor(overrides.idleTimeoutMs);
     } else if (getHiddenAgent(agent)) {
         const { abort } = resolveAgentStallThresholds(agent);
-        idleStaleMs = abort * 1000;
+        // Role budget, floored so the provider recovery window always wins.
+        idleStaleMs = Math.max(abort * 1000, PROVIDER_RECOVERY_FLOOR_MS);
     } else {
         // 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
@@ -238,6 +265,9 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
         idleStaleMs = backstopMs > 0
             ? Math.min(DEFAULT_STALE_TIMEOUT_MS, backstopMs)
             : DEFAULT_STALE_TIMEOUT_MS;
+        // Same floor for the public backstop: a workflow role (worker 300s,
+        // explore 240s) must not undercut the provider window either.
+        idleStaleMs = Math.max(idleStaleMs, PROVIDER_RECOVERY_FLOOR_MS);
     }
 
     const idleSec = idleStaleMs / 1000;

package/src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs

@@ -1,16 +1,10 @@
-import { isKnownProvider } from '../../../../standalone/provider-admin.mjs';
+import { configuredAgentRouteCandidates } from '../../../shared/agent-route-config.mjs';
 import { loadConfig } from '../config.mjs';
 import { getHiddenAgent } from '../internal-agents.mjs';
 
-const DEFAULT_AGENT_ROUTE_PROVIDER = 'anthropic-oauth';
-
-function normalizeMaintenanceCandidate(candidate, config) {
+function normalizeMaintenanceCandidate(candidate) {
     if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) return candidate || null;
-    const configuredProvider = String(config?.defaultProvider || '').trim();
-    const fallbackProvider = isKnownProvider(configuredProvider)
-        ? configuredProvider
-        : DEFAULT_AGENT_ROUTE_PROVIDER;
-    const provider = String(candidate.provider || fallbackProvider).trim();
+    const provider = String(candidate.provider || '').trim();
     const model = String(candidate.model || '').trim();
     if (!provider || !model) return null;
     return {
@@ -34,20 +28,15 @@ export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfg
     if (hidden) {
         try {
             const config = cfgIn || loadConfig({ secrets: false });
-            const maint = config?.maintenance || {};
             const key = hidden.maintKey || hidden.slot;
             const role = key === 'explore' ? 'explore' : (key === 'memory' ? 'maintainer' : '');
-            const workflowSlot = key === 'explore' ? 'explorer' : (key === 'memory' ? 'memory' : '');
-            if (!role) return maint[key] ?? null;
+            if (!role) return config?.maintenance?.[key] ?? null;
             const candidates = [
-                role ? config?.agents?.[role] : null,
-                key === 'memory' ? config?.agents?.maintenance : null,
-                workflowSlot ? config?.workflowRoutes?.[workflowSlot] : null,
-                maint[key],
+                ...configuredAgentRouteCandidates(config, role),
                 role ? config?.default : null,
             ];
             for (const candidate of candidates) {
-                const route = normalizeMaintenanceCandidate(candidate, config);
+                const route = normalizeMaintenanceCandidate(candidate);
                 if (route) return route;
             }
             return null;

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -31,7 +31,16 @@ function compactRecoveredErrorMessage(value) {
         : message;
 }
 
-function traceAgentLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesEst, agent = null }) {
+function traceAgentLoop({
+    sessionId,
+    iteration,
+    sendMs,
+    preSendMs,
+    toolResumeMs,
+    messageCount,
+    bodyBytesEst,
+    agent = null,
+}) {
     // Two emit modes, no behavior change either way:
     //   VERBOSE=1 → full loop row incl. body_bytes_est (payload serialized).
     //   TIMING=1  → lightweight send-latency attribution for high-fanout
@@ -45,6 +54,8 @@ function traceAgentLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesE
         kind: 'loop',
         agent: agent || null,
         send_ms: sendMs,
+        pre_send_ms: preSendMs ?? null,
+        tool_resume_ms: toolResumeMs ?? null,
         message_count: messageCount,
         body_bytes_est: bodyBytesEst ?? null,
     });