mixdog 0.9.95 → 0.9.97

package/scripts/{channel-daemon-stub.mjs → daemon-stub.mjs}

@@ -1,17 +1,18 @@
-// Stub channels daemon for the flip smoke: same lifecycle contract as
-// src/standalone/channel-daemon.mjs (pid-verified singleton claim, HTTP+SSE
+// Stub channel service for the flip smoke: same lifecycle contract as
+// src/standalone/daemon.mjs (pid-verified singleton claim, HTTP+SSE
 // transport, discovery file, ready handshake, client-grace self-shutdown) but
 // with a STUB runtime instead of worker-main — no Discord token needed. The
 // real channel-worker.mjs spawn-or-attach path forks THIS via
-// MIXDOG_CHANNEL_DAEMON_ENTRY, so the flip is exercised end to end.
+// MIXDOG_DAEMON_ENTRY, so the flip is exercised end to end.
 process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 
 import os from 'node:os';
 import path from 'node:path';
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { writeJsonAtomicSync } from '../src/runtime/shared/atomic-file.mjs';
 import { claimSingletonOwner, releaseSingletonOwner } from '../src/runtime/shared/singleton-owner.mjs';
 import { safeIpcSend } from '../src/runtime/shared/safe-ipc-send.mjs';
-import { createChannelDaemonTransport } from '../src/standalone/channel-daemon-transport.mjs';
+import { createChannelTransport } from '../src/standalone/channel-transport.mjs';
 
 function runtimeRoot() {
   return process.env.MIXDOG_RUNTIME_ROOT
@@ -20,8 +21,8 @@ function runtimeRoot() {
 }
 const RUNTIME_ROOT = runtimeRoot();
 const DATA_DIR = process.env.MIXDOG_DATA_DIR ? path.resolve(process.env.MIXDOG_DATA_DIR) : RUNTIME_ROOT;
-const DISCOVERY_PATH = path.join(RUNTIME_ROOT, 'channel-daemon.json');
-const OWNER_PATH = path.join(DATA_DIR, 'channel-daemon-owner.json');
+const DISCOVERY_PATH = path.join(RUNTIME_ROOT, 'daemon.json');
+const OWNER_PATH = path.join(DATA_DIR, 'daemon-owner.json');
 
 function log(line) { if (process.env.DAEMON_SMOKE_VERBOSE) process.stderr.write(`[stub-daemon] ${line}\n`); }
 
@@ -31,23 +32,24 @@ async function shutdown(reason, code = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
   try { await transport?.stop?.(); } catch {}
+  try { rmSync(DISCOVERY_PATH, { force: true }); } catch {}
   try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {}
   process.exit(code);
 }
 
 async function main() {
   try { mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
-  const claim = claimSingletonOwner(OWNER_PATH, { kind: 'channel-runtime-daemon', pid: process.pid, meta: { cwd: process.cwd() } });
+  const claim = claimSingletonOwner(OWNER_PATH, { kind: 'mixdog-daemon', pid: process.pid, meta: { cwd: process.cwd() } });
   if (!claim.owned) { process.exit(0); } // race loser → spawner attaches to winner
   process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
 
   // Optional env dump for the tool smoke: proves daemonEnv() spawned us with
-  // the daemon-mode flags (MIXDOG_CHANNEL_DAEMON=1, MIXDOG_CLI_OWNED=0).
+  // the host-mode flags (MIXDOG_DAEMON_HOST=1, MIXDOG_CLI_OWNED=0).
   if (process.env.SMOKE_CHANNEL_ENV_OUT) {
     try {
       writeFileSync(process.env.SMOKE_CHANNEL_ENV_OUT, JSON.stringify({
         cliOwned: process.env.MIXDOG_CLI_OWNED,
-        daemon: process.env.MIXDOG_CHANNEL_DAEMON,
+        host: process.env.MIXDOG_DAEMON_HOST,
       }));
     } catch { /* smoke-only, best-effort */ }
   }
@@ -61,15 +63,19 @@ async function main() {
     return { ok: true, name, args, leadPid: ctx.leadPid };
   };
 
-  transport = createChannelDaemonTransport({
+  transport = createChannelTransport({
     handleCall,
-    discoveryPath: DISCOVERY_PATH,
     clientGraceMs: 250,
     sweepMs: 1000,
     log,
     onClientsEmpty: () => { void shutdown('no live clients'); },
   });
   const { port, token } = await transport.start();
+  writeJsonAtomicSync(DISCOVERY_PATH, {
+    pid: process.pid,
+    startedAt: Date.now(),
+    endpoints: { channel: { port, token } },
+  }, { compact: true });
   safeIpcSend(process, { type: 'ready', port, token });
   log(`ready port=${port} pid=${process.pid}`);
 }

package/scripts/fixtures/patch-replay-corpus.json

@@ -0,0 +1,98 @@
+[
+  {
+    "id": "eof-marker-midfile",
+    "note": "observed: a mid-file hunk carried *** End of File; the EOF-anchored seek missed and every recovery tier was gated off, so a byte-perfect context failed",
+    "expect": "applied",
+    "expect_content": { "a.txt": "one\nTWO\nthree\nfour\nfive\n" },
+    "file_snapshots": { "a.txt": "one\ntwo\nthree\nfour\nfive\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.txt\n@@\n one\n-two\n+TWO\n three\n*** End of File\n*** End Patch\n" }
+  },
+  {
+    "id": "deletion-line-one-char-off",
+    "note": "observed: `first divergent line` hints whose expected/actual differ by <= 1 character (retyped from memory) on a deletion line",
+    "expect": "applied",
+    "expect_content": { "src.js": "alpha\nconst total = count + 2;\nbeta\ngamma\n" },
+    "file_snapshots": { "src.js": "alpha\nconst total = count + 1;\nbeta\ngamma\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: src.js\n@@\n alpha\n-const total = cout + 1;\n+const total = count + 2;\n beta\n*** End Patch\n" }
+  },
+  {
+    "id": "stale-outer-context-line",
+    "note": "observed: one unrelated context line copied just outside the real edit",
+    "expect": "applied",
+    "expect_content": { "tools.js": "const tools = {\n  shell_step: {\n    command: 'node test.js',\n  },\n};\n" },
+    "file_snapshots": { "tools.js": "const tools = {\n  shell_step: {\n    command: 'node test.js',\n    cwd: root,\n    timeout: 30000,\n  },\n};\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: tools.js\n@@\n stale outer context\n   shell_step: {\n     command: 'node test.js',\n-    cwd: root,\n-    timeout: 30000,\n   },\n*** End Patch\n" }
+  },
+  {
+    "id": "context-retyped-from-memory",
+    "note": "observed (dominant stale-context shape): the surrounding context was retyped from memory while the edited line itself is current and unique",
+    "expect": "applied",
+    "expect_content": { "cfg.js": "l1\nl2\nl3\nconst flag = false;\nl5\nl6\nl7\n" },
+    "file_snapshots": { "cfg.js": "l1\nl2\nl3\nconst flag = true;\nl5\nl6\nl7\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: cfg.js\n@@\n remembered header\n another stale line\n-const flag = true;\n+const flag = false;\n stale trailer\n*** End Patch\n" }
+  },
+  {
+    "id": "retyped-context-with-duplicate-core",
+    "note": "guard: the same rescue must refuse when the edited line occurs more than once",
+    "expect": "rejected",
+    "expect_error": "context not found",
+    "file_snapshots": { "dupcore.js": "a\nconst flag = true;\nb\nc\nconst flag = true;\nd\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: dupcore.js\n@@\n stale one\n-const flag = true;\n+const flag = false;\n stale two\n*** End Patch\n" }
+  },
+  {
+    "id": "decomposed-unicode-context",
+    "note": "observed: context authored in decomposed Unicode against composed on-disk text",
+    "expect": "applied",
+    "expect_content": { "label.js": "head\nconst label = \"tea\";\ntail\n" },
+    "file_snapshots": { "label.js": "head\nconst label = \"caf\u00e9\";\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: label.js\n@@\n head\n-const label = \"cafe\u0301\";\n+const label = \"tea\";\n tail\n*** End Patch\n" }
+  },
+  {
+    "id": "stacked-at-anchors",
+    "note": "V4A anchor chain (@@ class + @@ def): consecutive headers must narrow ONE hunk, not silently resolve against the first occurrence",
+    "expect": "applied",
+    "expect_content": { "dup.py": "class A:\n    def run():\n        return 1\n\nclass B:\n    def run():\n        return 2\n" },
+    "file_snapshots": { "dup.py": "class A:\n    def run():\n        return 1\n\nclass B:\n    def run():\n        return 1\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: dup.py\n@@ class B:\n@@     def run():\n-        return 1\n+        return 2\n*** End Patch\n" }
+  },
+  {
+    "id": "divergent-line-far-off",
+    "note": "observed (dominant class, 65 of 91 hinted misses): the quoted context is genuinely different content — must stay a hard miss with a divergence hint",
+    "expect": "rejected",
+    "expect_error": "first divergent line|context not found",
+    "file_snapshots": { "app.js": "head\nawait engine.startWork();\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: app.js\n@@\n head\n-unsubscribe();\n+cleanup();\n tail\n*** End Patch\n" }
+  },
+  {
+    "id": "shifted-context-first-line-only",
+    "note": "observed (62 misses): the first old line exists but the block does not — must reject and point at the nearest line",
+    "expect": "rejected",
+    "expect_error": "nearest line|context not found",
+    "file_snapshots": { "shift.js": "open();\nmiddle();\nclose();\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: shift.js\n@@\n open();\n-gone();\n-also gone();\n+replacement();\n close();\n*** End Patch\n" }
+  },
+  {
+    "id": "near-miss-in-two-places",
+    "note": "guard: a near-miss context that fits two windows must never be applied to a guessed one",
+    "expect": "rejected",
+    "expect_error": "context not found",
+    "file_snapshots": { "dup.js": "alpha\nvalue = 1;\nbeta\nalpha\nvalue = 1;\nbeta\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: dup.js\n@@\n alpha\n-value = 7;\n+value = 2;\n beta\n*** End Patch\n" }
+  },
+  {
+    "id": "compacted-history-placeholder",
+    "note": "observed (39 rows): the patch argument was replaced by the history-compaction marker",
+    "expect": "rejected",
+    "expect_error": "compacted-history placeholder",
+    "file_snapshots": { "a.txt": "one\ntwo\n" },
+    "args": { "patch": "[mixdog compacted patch: 15983 chars, sha256:9ae407d696803e2a; already applied to a.txt - do not copy]" }
+  },
+  {
+    "id": "missing-patch-argument",
+    "note": "observed (783 rows, single harness burst): apply_patch called with no patch argument — must be a stated contract error, never a runtime type crash",
+    "expect": "rejected",
+    "expect_error": "\"patch\" is required",
+    "file_snapshots": {},
+    "args": { "base_path": null }
+  }
+]

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/defaults/skills/setup/SKILL.md

@@ -132,7 +132,7 @@ apply it, and verify the result.
 ### Discord / Telegram / voice channels
 
 1. Check `/channels` (or `/setting` → Channel) and runtime channel status.
-2. Update the requested backend, credential, or main channel/chat setting.
+2. Update the requested provider, credential, or main channel/chat setting.
 3. Restart/reconnect only when the channel implementation requires it.
 4. Verify channel presence and a non-secret status signal.
 

package/src/lib/keychain-cjs.cjs

@@ -6,7 +6,7 @@ const fs = require('fs');
 const { resolvePluginData } = require('./plugin-paths.cjs');
 
 const SERVICE = 'mixdog';
-// Shared bound for every synchronous keychain backend (DPAPI/PowerShell on
+// Shared bound for every synchronous keychain provider (DPAPI/PowerShell on
 // Windows, security(1) on macOS). A single env override keeps them consistent.
 const KEYCHAIN_TIMEOUT_MS = Number(process.env.MIXDOG_KEYCHAIN_TIMEOUT_MS || 15000);
 const POWERSHELL_TIMEOUT_MS = KEYCHAIN_TIMEOUT_MS;

package/src/lib/mixdog-debug.cjs

@@ -102,8 +102,7 @@ const CANONICAL_PLUGIN_LOG_NAMES = new Set([
   'webhook.log',
   'perf.log',
   'tool-events.log',
-  'memory-runtime-proxy.log',
-  'channels-worker-standalone.log',
+  'daemon.log',
   'mixdog-tui.stderr.log',
 ]);
 
@@ -183,7 +182,7 @@ function rotateBoundedLog(filePath, maxBytes, keepBytes) {
 }
 
 // Shared bound for unbounded per-writer plugin logs (tool-events,
-// memory-runtime-proxy, channels-worker-standalone). Keep a tail so recent
+// memory runtime and daemon logs). Keep a tail so recent
 // context survives rotation while the file stays under the 10 MB cap.
 const PLUGIN_LOG_MAX_BYTES = 10 * 1024 * 1024;
 const PLUGIN_LOG_KEEP_BYTES = 2 * 1024 * 1024;

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/lead/01-general.md

@@ -7,12 +7,11 @@
 - Destructive/hard-to-reverse action needs explicit confirmation and explicit
   validated target paths — never `~`, a root, or unresolved variables/globs;
   report material deletions with recoverability.
-- Act proactively; ask only for decisions.
+- Ask only for decisions.
 - Build only what the task requires; trust internal and framework guarantees.
 - Mid-task input: a replacement supersedes current work, an addition folds
   into it, a status question gets a brief answer while work continues; after
   context compaction continue from the summary — never restart or redo
   finished work.
-- When blocked, exhaust safe in-scope checks once and report the blocker.
 - Your final message ends the turn: answer only when the work is done. After a
   failed tool call, fix and re-run it, or state plainly that it is unresolved.

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

@@ -1,6 +1,3 @@
 # Lead Tools
 
-- Write-role agents self-verify with `shell`. Lead uses `shell` only for git,
-  benches, and cross-scope verification no retrieval tool can produce;
-  inspection stays on `read`/`grep`/`glob`/`list`/`find`/`code_graph`.
 - Use the current project/workspace unless the request or tool requires another.

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

@@ -1,31 +1,23 @@
 # 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`. Call `shell` only
+  when the task actually requires one of those operations; do not treat it as
+  a routine investigation or completion step. Never use shell equivalents for
+  file discovery or content retrieval.
+- Use verified paths (cwd/project/user/tool); explicit paths may be outside cwd;
+  guessed fragments use `find`. Maximize fan-out across routed retrieval tools
+  and fetch all information needed in one batch; never re-fetch an unchanged
+  span.
+- Once the edit is determined, finish in one assistant turn with one
+  `apply_patch` for all edits. If final verification actually requires `shell`,
+  use one verification chain after the edit; otherwise finish without it.
+- 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,
     });

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

@@ -9,7 +9,8 @@ import { isDiagnosticIOEnabled } from '../../../lib/mixdog-debug.cjs';
 const WARNED_KEYS = new Set();
 
 // ---------------------------------------------------------------------------
-// In-memory buffer + HTTP flush to memory-service /admin/trace-record
+// In-memory buffer. Product sessions flush directly into the daemon-hosted
+// memory module; the standalone path can still use its local HTTP service.
 // ---------------------------------------------------------------------------
 let _buffer = [];
 const _BUFFER_MAX = 2000;
@@ -225,21 +226,11 @@ try {
 function _resolveServiceUrl() {
     if (_serviceUrl) return _serviceUrl;
     try {
-        // Prefer the single-writer discovery advert (discovery/memory.json),
-        // pid-validated; fall back to legacy active-instance.json memory_port.
+        // Standalone memory HTTP uses its pid-validated discovery advert.
         const advertPort = readServicePort('memory', { requirePid: false });
         if (advertPort) { _serviceAdvertPort = advertPort; _serviceUrl = `http://127.0.0.1:${advertPort}`; return _serviceUrl; }
         _serviceAdvertPort = null;
-        const runtimeRoot = process.env.MIXDOG_RUNTIME_ROOT
-            ? join(process.env.MIXDOG_RUNTIME_ROOT)
-            : join(os.tmpdir(), 'mixdog');
-        const activeFile = join(runtimeRoot, 'active-instance.json');
-        if (!existsSync(activeFile)) return null;
-        const active = JSON.parse(readFileSync(activeFile, 'utf-8'));
-        const port = Number(active && active.memory_port);
-        if (!Number.isFinite(port) || port <= 0) return null;
-        _serviceUrl = `http://127.0.0.1:${port}`;
-        return _serviceUrl;
+        return null;
     } catch {
         return null;
     }