mixdog 0.9.41 → 0.9.44

package/scripts/tui-transcript-jitter-harness-entry.jsx

@@ -0,0 +1,302 @@
+import React from 'react';
+import { PassThrough } from 'node:stream';
+import { Box, measureElement, render } from 'ink';
+import { Item } from '../src/tui/components/TranscriptItem.jsx';
+import { useTranscriptWindow } from '../src/tui/app/use-transcript-window.mjs';
+import {
+  streamingMeasuredRowsById,
+} from '../src/tui/app/transcript-window.mjs';
+import {
+  resetAllStreamingMarkdownStablePrefixes,
+  resetStreamingMarkdownStablePrefix,
+  resolveStreamingMarkdownParts,
+} from '../src/tui/markdown/streaming-markdown.mjs';
+
+const COLUMNS = 42;
+const VIEW_ROWS = 8;
+const INITIAL_SCROLL = 8;
+const STREAM_ID = 'jitter-fence-tail';
+const HISTORY = Array.from({ length: 8 }, (_, index) => ({
+  id: `history-${index}`,
+  kind: 'notice',
+  tone: 'plain',
+  text: `H${index} stable history row`,
+}));
+const SCRIPT = [
+  'Here is the script:',
+  '',
+  '```js',
+  'const first = `',
+  'alpha',
+  '`;',
+  'const second = `',
+  'beta',
+  '`;',
+  'console.log(first, second);',
+  '```',
+  '',
+  'Done.',
+].join('\n');
+
+const frames = [];
+globalThis.__mixdogTailGrowthProbe = null;
+let commit = 0;
+const identity = (value) => value;
+const noop = () => {};
+
+function Harness({ text, step }) {
+  const [scrollOffset, setScrollOffset] = React.useState(INITIAL_SCROLL);
+  const [measuredRowsVersion, setMeasuredRowsVersion] = React.useState(0);
+  const transcriptAnchorRef = React.useRef(null);
+  const transcriptAnchorDirtyRef = React.useRef(true);
+  const scrollTargetRef = React.useRef(INITIAL_SCROLL);
+  const scrollPositionRef = React.useRef(INITIAL_SCROLL);
+  const maxScrollRowsRef = React.useRef(0);
+  const transcriptGeomRef = React.useRef({});
+  const followingRef = React.useRef(false);
+  const dragRef = React.useRef({ active: false, rect: null });
+  const transcriptViewportRef = React.useRef({ top: 0 });
+  const selectionLayoutRef = React.useRef(null);
+  const contentRef = React.useRef(null);
+  const tailRef = React.useRef(null);
+  const streamingTail = React.useMemo(() => ({
+    id: STREAM_ID,
+    kind: 'assistant',
+    text,
+    streaming: true,
+  }), [text]);
+  const transcriptItems = React.useMemo(() => [...HISTORY, streamingTail], [streamingTail]);
+
+  const preHookEntry = streamingMeasuredRowsById.get(STREAM_ID);
+  const preHookMeasuredRows = preHookEntry?.rows ?? null;
+  const preHookEstimateRows = preHookEntry?.estimateRows ?? null;
+
+  const {
+    transcriptWindow,
+    renderedTranscriptItems,
+    transcriptMeasureRef,
+  } = useTranscriptWindow({
+    items: HISTORY,
+    structureRevision: 1,
+    streamingTail,
+    themeEpoch: 0,
+    frameColumns: COLUMNS,
+    toolOutputExpanded: false,
+    transcriptContentHeight: VIEW_ROWS,
+    transcriptBottomSlackRows: 1,
+    transcriptGuardRows: 1,
+    floatingPanelRows: 0,
+    overlayHintRequested: false,
+    scrollOffset,
+    setScrollOffset,
+    transcriptAnchorRef,
+    transcriptAnchorDirtyRef,
+    scrollTargetRef,
+    scrollPositionRef,
+    maxScrollRowsRef,
+    transcriptGeomRef,
+    followingRef,
+    dragRef,
+    transcriptViewportRef,
+    selectionLayoutRef,
+    withSelectionClip: identity,
+    paintSelectionRect: noop,
+    stopSmoothScroll: noop,
+    measuredRowsVersion,
+    setMeasuredRowsVersion,
+  });
+
+  const growthProbe = globalThis.__mixdogTailGrowthProbe;
+  const tailHookRef = transcriptMeasureRef(streamingTail);
+  const combinedTailRef = React.useCallback((element) => {
+    tailHookRef?.(element);
+    tailRef.current = element;
+  }, [tailHookRef]);
+
+  React.useLayoutEffect(() => {
+    const geometry = transcriptGeomRef.current || {};
+    const prefix = geometry.prefixRows || [];
+    const physicalRows = measureElement(contentRef.current).height;
+    const tailYogaRows = measureElement(tailRef.current).height;
+    const renderScrollOffset = transcriptWindow.effectiveScrollOffset;
+    const visibleTopIndexed = transcriptWindow.totalRows - renderScrollOffset - VIEW_ROWS;
+    const visibleTopPhysical = physicalRows - renderScrollOffset - VIEW_ROWS;
+    frames.push({
+      commit: ++commit,
+      step,
+      char: text.at(-1) === '\n' ? '\\n' : (text.at(-1) || ''),
+      totalRows: transcriptWindow.totalRows,
+      renderScrollOffset,
+      visibleTopIndexed,
+      visibleTopPhysical,
+      physicalRows,
+      tailIndexedRows: prefix.length > 1 ? prefix.at(-1) - prefix.at(-2) : -1,
+      tailYogaRows,
+      mountedDelta: tailYogaRows - (prefix.length > 1 ? prefix.at(-1) - prefix.at(-2) : -1),
+      growthLive: growthProbe?.live ?? null,
+      growthBaseline: growthProbe?.baseline ?? null,
+      growthDelta: growthProbe?.delta ?? null,
+      suppressMeasured: geometry.suppressMeasuredRowHeights === true,
+      measuredRowsVersion,
+      preHookMeasuredRows,
+      preHookEstimateRows,
+      postHarvestMeasuredRows: streamingMeasuredRowsById.get(STREAM_ID)?.rows ?? null,
+      postHarvestEstimateRows: streamingMeasuredRowsById.get(STREAM_ID)?.estimateRows ?? null,
+      scrollTarget: scrollTargetRef.current,
+      following: followingRef.current,
+      anchor: transcriptAnchorRef.current?.id || '-',
+    });
+  }, [step, text, measuredRowsVersion, transcriptWindow.totalRows, transcriptWindow.effectiveScrollOffset,
+    transcriptAnchorRef, transcriptGeomRef]);
+
+  return (
+    <Box flexDirection="column" width={COLUMNS} height={VIEW_ROWS} overflow="hidden" justifyContent="flex-end">
+      <Box
+        ref={contentRef}
+        flexDirection="column"
+        width="100%"
+        flexShrink={0}
+        marginBottom={-transcriptWindow.effectiveScrollOffset}
+      >
+        {renderedTranscriptItems.map((item, index, all) => {
+          const hookRef = item.id === STREAM_ID ? combinedTailRef : transcriptMeasureRef(item);
+          return (
+            <Box key={item.id} ref={hookRef} flexDirection="column" flexShrink={0}>
+              <Item
+                item={item}
+                prevKind={index > 0 ? all[index - 1].kind : null}
+                columns={COLUMNS}
+                toolOutputExpanded={false}
+              />
+            </Box>
+          );
+        })}
+        {transcriptWindow.bottomSpacerRows > 0
+          ? <Box height={transcriptWindow.bottomSpacerRows} flexShrink={0} />
+          : null}
+      </Box>
+    </Box>
+  );
+}
+
+function fakeTty(columns, rows) {
+  const stream = new PassThrough();
+  stream.columns = columns;
+  stream.rows = rows;
+  stream.isTTY = true;
+  stream.getColorDepth = () => 1;
+  stream.hasColors = () => false;
+  stream.setRawMode = () => stream;
+  stream.on('data', () => {});
+  return stream;
+}
+
+async function settle(instance) {
+  await instance.waitUntilRenderFlush();
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  await instance.waitUntilRenderFlush();
+}
+
+function assertStreamingMarkdownPartsCache() {
+  const key = 'streaming-parts-cache-coverage';
+  const longText = 'Settled paragraph.\n\n```js\nconst value = 1;';
+  const initial = resolveStreamingMarkdownParts(longText, key);
+  const repeated = resolveStreamingMarkdownParts(`${longText}\n\n`, key);
+  if (repeated !== initial) {
+    throw new Error('normalized-equivalent stream text did not reuse its resolved parts');
+  }
+
+  const regressed = resolveStreamingMarkdownParts('plain text', key);
+  if (regressed === initial || regressed.stablePrefix || regressed.unstableSuffix !== 'plain text') {
+    throw new Error('text regression served a stale streaming-markdown split');
+  }
+
+  const recomputed = resolveStreamingMarkdownParts(longText, key);
+  if (recomputed === initial) {
+    throw new Error('text change did not evict the prior streaming-markdown snapshot');
+  }
+
+  const resetSeed = recomputed;
+  resetStreamingMarkdownStablePrefix(key);
+  if (resolveStreamingMarkdownParts(longText, key) === resetSeed) {
+    throw new Error('streaming-markdown reset did not clear its resolved-parts snapshot');
+  }
+}
+
+assertStreamingMarkdownPartsCache();
+resetAllStreamingMarkdownStablePrefixes();
+streamingMeasuredRowsById.delete(STREAM_ID);
+const stdout = fakeTty(COLUMNS, VIEW_ROWS);
+const stderr = fakeTty(COLUMNS, VIEW_ROWS);
+const stdin = fakeTty(COLUMNS, VIEW_ROWS);
+const instance = render(<Harness text={SCRIPT.slice(0, 1)} step={1} />, {
+  stdout,
+  stderr,
+  stdin,
+  interactive: true,
+  patchConsole: false,
+  exitOnCtrlC: false,
+  maxFps: 1000,
+});
+await settle(instance);
+for (let step = 2; step <= SCRIPT.length; step++) {
+  instance.rerender(<Harness text={SCRIPT.slice(0, step)} step={step} />);
+  await settle(instance);
+}
+instance.unmount();
+await instance.waitUntilExit();
+instance.cleanup();
+
+const byStep = new Map();
+for (const frame of frames) {
+  const list = byStep.get(frame.step) || [];
+  list.push(frame);
+  byStep.set(frame.step, list);
+}
+const dips = [];
+let previousSettled = null;
+for (const [step, list] of [...byStep.entries()].sort((a, b) => a[0] - b[0])) {
+  const first = list[0];
+  const settled = list.at(-1);
+  if (previousSettled
+    && first.visibleTopPhysical !== previousSettled.visibleTopPhysical
+    && settled.visibleTopPhysical === previousSettled.visibleTopPhysical) {
+    dips.push({ previous: previousSettled, transient: first, corrected: settled });
+  }
+  previousSettled = settled;
+}
+
+const print = (label, frame) => {
+  console.log(`${label} c${frame.commit} step=${frame.step} char=${JSON.stringify(frame.char)}`
+    + ` totalRows=${frame.totalRows} renderScrollOffset=${frame.renderScrollOffset}`
+    + ` visibleTop=${frame.visibleTopPhysical} indexedTop=${frame.visibleTopIndexed}`
+    + ` physicalRows=${frame.physicalRows} tail(index/yoga)=${frame.tailIndexedRows}/${frame.tailYogaRows}`
+    + ` mountedDelta=${frame.mountedDelta} helper(live/base/delta)=${frame.growthLive}/${frame.growthBaseline}/${frame.growthDelta}`
+    + ` suppressMeasured=${frame.suppressMeasured ? 1 : 0}`
+    + ` measuredVersion=${frame.measuredRowsVersion}`
+    + ` baseline(measured/estimate)=${frame.preHookMeasuredRows}/${frame.preHookEstimateRows}`
+    + ` harvest(measured/estimate)=${frame.postHarvestMeasuredRows}/${frame.postHarvestEstimateRows}`
+    + ` target=${frame.scrollTarget} following=${frame.following ? 1 : 0} anchor=${frame.anchor}`);
+};
+
+console.log(`# scrolled-up fenced-script frame repro columns=${COLUMNS} viewRows=${VIEW_ROWS} initialScroll=${INITIAL_SCROLL}`);
+console.log(`# append-only characters=${SCRIPT.length} commits=${frames.length} dip-snap events=${dips.length}`);
+for (const event of dips.slice(0, 4)) {
+  print('before   ', event.previous);
+  print('transient', event.transient);
+  print('harvest  ', event.corrected);
+  console.log('');
+}
+const suppressValues = new Set(frames.map((frame) => frame.suppressMeasured));
+console.log(`# suppressMeasuredRowHeights values during repro: ${[...suppressValues].map(Number).join(',')}`);
+if (dips.length > 0) {
+  throw new Error(`expected no visible-top dip/snap while fenced script streams; observed ${dips.length}`);
+}
+if (suppressValues.size !== 1 || !suppressValues.has(true)) {
+  throw new Error('repro unexpectedly toggled suppressMeasuredRowHeights');
+}
+console.log('tui-transcript-jitter-harness: ok');
+
+
+
+

package/scripts/tui-transcript-jitter-harness.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { build } from 'esbuild';
+import { readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const entry = join(ROOT, 'scripts', 'tui-transcript-jitter-harness-entry.jsx');
+const outfile = join(ROOT, 'scripts', '.tui-transcript-jitter-harness.tmp.mjs');
+
+const inkAlias = {
+  name: 'mixdog-ink-alias',
+  setup(ctx) {
+    ctx.onResolve({ filter: /^ink$/ }, () => ({
+      path: '../vendor/ink/build/index.js',
+      external: true,
+    }));
+  },
+};
+
+// Build-only probe: records the exact delta seen by the production helper
+// without adding another stateful estimator call from the harness.
+const growthProbe = {
+  name: 'streaming-tail-growth-probe',
+  setup(ctx) {
+    ctx.onLoad({ filter: /transcript-window\.mjs$/ }, async (args) => {
+      let source = (await readFile(args.path, 'utf8')).replace(/\r\n/g, '\n');
+      const target = '  return { tailRows: idEntry.rows, delta };';
+      const replacement = `  globalThis.__mixdogTailGrowthProbe = { live, baseline, delta, tailRows: idEntry.rows };\n${target}`;
+      if (!source.includes(target)) return null;
+      source = source.replace(target, replacement);
+      return { contents: source, loader: 'js' };
+    });
+  },
+};
+
+try {
+  await build({
+    entryPoints: [entry],
+    outfile,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node22',
+    jsx: 'automatic',
+    packages: 'external',
+    plugins: [inkAlias, growthProbe],
+    banner: {
+      js: "import { createRequire as __mixdogCreateRequire } from 'node:module';\nconst require = __mixdogCreateRequire(import.meta.url);",
+    },
+    logLevel: 'silent',
+  });
+  await import(`${pathToFileURL(outfile).href}?run=${Date.now()}`);
+} finally {
+  await rm(outfile, { force: true });
+}
+
+

package/scripts/tui-transcript-perf-test.mjs

@@ -8,7 +8,7 @@ import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-wi
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-function makeTurnHarness(ask) {
+function makeTurnHarness(ask, stateOverrides = {}) {
   let seq = 0;
   let state = {
     items: [],
@@ -18,6 +18,7 @@ function makeTurnHarness(ask) {
     busy: false,
     spinner: null,
     thinking: null,
+    ...stateOverrides,
   };
   const itemIndexById = new Map();
   const set = (patch) => { state = { ...state, ...patch }; return true; };
@@ -43,6 +44,15 @@ function makeTurnHarness(ask) {
   const clearStreamingTail = (id = null) => {
     if (id == null || state.streamingTail?.id === id) set({ streamingTail: null });
   };
+  const replaceItems = (items, options = {}) => {
+    state = replaceEngineItemsState({
+      state,
+      items,
+      itemIndexById,
+      preserveStreamingTail: options.preserveStreamingTail === true,
+    });
+    return items;
+  };
   const bag = {
     runtime: { id: null, toolMode: 'auto', ask, abort: () => true },
     nextId: () => `id_${++seq}`,
@@ -55,6 +65,7 @@ function makeTurnHarness(ask) {
     set,
     pushItem,
     patchItem,
+    replaceItems,
     updateStreamingTail,
     settleStreamingTail,
     clearStreamingTail,
@@ -77,6 +88,50 @@ function makeTurnHarness(ask) {
   return { runTurn: createRunTurn(bag), getState: () => state };
 }
 
+test('successful mid-turn compact trims history but preserves live turn references', async () => {
+  let preservedTail = false;
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('before compact\n');
+    await wait(30);
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    options.onTextDelta('after compact\n');
+    return { result: { content: 'before compact\nafter compact\n' }, session: { messages: [] } };
+  }, {
+    items: [
+      { id: 'old', kind: 'assistant', text: 'old history' },
+      { id: 'current-user', kind: 'user', text: 'go' },
+    ],
+  });
+
+  assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');
+  assert.equal(preservedTail, true);
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'current-user'), true);
+  assert.equal(
+    harness.getState().items.filter((item) => item.label === 'Compact complete (overflow recovery)').length,
+    2,
+  );
+  assert.equal(
+    harness.getState().items.find((item) => item.kind === 'assistant')?.text,
+    'before compact\nafter compact\n',
+  );
+});
+
+test('failed mid-turn compact leaves prior transcript items untouched', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onCompactEvent({ status: 'failed' });
+    return { result: { content: '' }, session: { messages: [] } };
+  }, {
+    items: [{ id: 'old', kind: 'assistant', text: 'old history' }],
+  });
+
+  assert.equal(await harness.runTurn('go'), 'done');
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Compact failed'), true);
+});
+
 test('stream flush keeps settled items identity and finalize appends one assistant', async () => {
   let identityStable = false;
   const harness = makeTurnHarness(async (_text, options) => {

package/src/agents/reviewer/AGENT.md

@@ -6,9 +6,11 @@ permission: read
 
 Independent regression/risk review agent.
 
-Review the approved intent, diff, and tests with independent judgment. Prioritize
-actionable correctness, regression, security, and verification risks; inspect
-affected boundaries. Do not reimplement the change or report non-risky nits.
+Review the diff and tests with independent judgment. Prioritize actionable
+correctness, regression, security, and verification risks; inspect affected
+boundaries. Do not reimplement the change or report non-risky nits. Independently
+evaluate the final deliverable with a critical lens, actively seeking errors,
+unsupported assumptions, and counterexamples before confirming.
 Report findings first, severity-ordered, with one line per `file:line`. If clean,
 say so in one line and include only material residual risk.
 

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

@@ -8,12 +8,13 @@
   `Task:`. Never infer exactness from a task name, file count, or perceived
   difficulty.
 - All other fields are optional task-specific deltas: `Anchors:`
-  `Allow/Forbid:` `Deliver:` `Verify:`. Omit any that add no information.
+  `Allow/Forbid:` `Deliver:`. Omit any that add no information.
 - Anchors: `file:line` + one-line conclusion; never log/code bodies. Specify
   outcome, not method unless required. `Deliver:` gives shape/size, never a long
-  handoff. Referenced spec/test beats its summary.
-- Preserve the exact same `Task:` across Worker -> Debugger -> Reviewer. Never
-  summarize, rewrite, or replace it when handing the scope to the next role.
+  handoff. The original request and official spec/test acceptance criteria beat
+  their brief summary.
+- Each role independently constructs a role-appropriate, lossless `Task:` from
+  the original request and official spec/test acceptance criteria.
 - Full brief only for fresh spawn/`respawned: true`; live follow-ups are delta.
   Dead-tag send is cold: re-supply anchors.
 - Never `send` mid-run; batch one follow-up after completion; interrupt only to

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

@@ -24,6 +24,7 @@
 import { loadConfig } from '../config.mjs';
 import { resolveRuntimeSpec } from '../config.mjs';
 import { getHiddenAgent, resolveAgentSessionPermission } from '../internal-agents.mjs';
+import { isKnownProvider } from '../../../../standalone/provider-admin.mjs';
 import { prepareAgentSession } from './session-builder.mjs';
 import {
     askSession,
@@ -163,9 +164,30 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
  *     against config.presets for backward compatibility.
  *   - null — unresolved.
  *
- * Hidden roles read their slot from `maint[maintKey || slot]`; the cycle1/2/3
- * agents share one knob via the `maintKey: 'memory'` override.
+ * Explore and memory hidden roles mirror public spawning precedence:
+ * `agents.<role>` (including legacy `agents.maintenance`) → workflow route →
+ * maintenance route → Main. The cycle1/2/3 agents share the memory knob via
+ * their `maintKey: 'memory'` override. Scheduler and webhook are unchanged.
  */
+const DEFAULT_AGENT_ROUTE_PROVIDER = 'anthropic-oauth';
+
+function normalizeMaintenanceCandidate(candidate, config) {
+    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 model = String(candidate.model || '').trim();
+    if (!provider || !model) return null;
+    return {
+        provider,
+        model,
+        effort: String(candidate.effort || '').trim() || undefined,
+        fast: candidate.fast === true,
+    };
+}
+
 export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfgIn = null }) {
     if (preset) return preset;
     if (optsPreset) return optsPreset;
@@ -175,7 +197,22 @@ export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfg
         try {
             const config = cfgIn || loadConfig({ secrets: false });
             const maint = config?.maintenance || {};
-            return maint[hidden.maintKey || hidden.slot] ?? null;
+            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;
+            const candidates = [
+                role ? config?.agents?.[role] : null,
+                key === 'memory' ? config?.agents?.maintenance : null,
+                workflowSlot ? config?.workflowRoutes?.[workflowSlot] : null,
+                maint[key],
+                role ? config?.default : null,
+            ];
+            for (const candidate of candidates) {
+                const route = normalizeMaintenanceCandidate(candidate, config);
+                if (route) return route;
+            }
+            return null;
         } catch { return null; }
     }
     return null;

package/src/runtime/agent/orchestrator/config.mjs

@@ -7,6 +7,20 @@ import {
     hasGrokOAuthCredentials,
 } from './providers/oauth-credential-probes.mjs';
 
+// Keep config loading free of standalone provider-admin and its provider
+// runtimes. These identifiers mirror that module's static catalog, assembled
+// solely from the lightweight config/provider constants already imported here.
+const CONFIG_PROVIDER_IDS = new Set([
+    ...Object.keys(AGENT_PROVIDER_ENV),
+    ...Object.keys(OPENAI_COMPAT_PRESETS),
+    'openai-oauth',
+    'anthropic-oauth',
+    'grok-oauth',
+]);
+function isConfiguredProviderId(provider) {
+    return CONFIG_PROVIDER_IDS.has(String(provider || '').trim());
+}
+
 // Thin wrapper around resolvePluginData so callers in this orchestrator tree
 // can import a single helper without reaching into shared/.
 export function getPluginData() {
@@ -18,15 +32,12 @@ export function getPluginData() {
 // Canonical maintenance defaults. Single source of truth — imported by
 // llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
 //
-// Every hidden maintenance slot carries a CONCRETE preset here, so
-// resolvePresetName() (agent-dispatch) always resolves a model directly from
-// `maint[slot]` — no shared `defaultPreset` fallback is needed or used.
-// Memory cycles + Lead helper fan-out (explore/cycle1/cycle2/cycle3) and
-// entry-driven dispatch (scheduler/webhook) all default to `haiku`. The three
-// memory cycles (chunker / re-scorer / core reviewer) share ONE `memory`
-// preset knob — the cycle agents stay separate (cycle1/2/3-agent, distinct
-// slots and invokedBy) but resolve their model from `maint.memory` via the
-// `maintKey` override on their hidden-role entries.
+// Explore and Maintainer start without a route so they dynamically inherit the
+// Main route. Explicit `maintenance.explore` / `maintenance.memory` choices
+// remain supported. The memory cycles (chunker / re-scorer / core reviewer)
+// share the optional `memory` preset knob — the cycle agents stay separate
+// (cycle1/2/3-agent, distinct slots and invokedBy) but resolve their model from
+// `maint.memory` via the `maintKey` override on their hidden-role entries.
 // scheduler/webhook still let a per-entry config.json model win first (the
 // caller passes it explicitly via opts.preset); the haiku default below only
 // applies when an entry omits its own model.
@@ -129,8 +140,6 @@ const _HAIKU_ROUTE = Object.freeze({
     model: resolveAnthropicFamilyModel('haiku'),
 });
 export const DEFAULT_MAINTENANCE = Object.freeze({
-    explore: { ..._HAIKU_ROUTE },
-    memory: { ..._HAIKU_ROUTE },
     scheduler: { ..._HAIKU_ROUTE },
     webhook: { ..._HAIKU_ROUTE },
 });
@@ -201,12 +210,18 @@ function normalizeSearchRoute(route) {
 // is resolved against the config.presets array (the legacy lookup) and rewritten
 // to a route. Unresolvable strings are dropped so the DEFAULT_MAINTENANCE route
 // fills the slot. `presets` is the normalized preset array for legacy lookup.
-function migrateMaintenanceRoutes(rawMaint, presets) {
+function migrateMaintenanceRoutes(rawMaint, presets, defaultProvider) {
     const out = {};
     const list = Array.isArray(presets) ? presets : [];
+    const configuredProvider = String(defaultProvider || '').trim();
+    const fallbackProvider = isConfiguredProviderId(configuredProvider)
+        ? configuredProvider
+        : 'anthropic-oauth';
     for (const [slot, value] of Object.entries(rawMaint || {})) {
         if (value && typeof value === 'object' && !Array.isArray(value)) {
-            const provider = normalizeAgentProviderId(value.provider);
+            const provider = normalizeAgentProviderId(
+                value.provider || ((slot === 'explore' || slot === 'memory') ? fallbackProvider : ''),
+            );
             const model = String(value.model || '').trim();
             if (provider && model) {
                 const route = { provider, model };
@@ -437,7 +452,7 @@ export function loadConfig(options = {}) {
             delete workflowRoutes.search;
             // Migrate legacy preset-name maintenance slots to direct routes,
             // then overlay onto the route-shaped defaults.
-            const migratedMaint = migrateMaintenanceRoutes(rawMaint, normalizedPresets);
+            const migratedMaint = migrateMaintenanceRoutes(rawMaint, normalizedPresets, raw.defaultProvider);
             return {
                 providers: mergedProviders,
                 mcpServers,

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

@@ -15,7 +15,8 @@
  * no-tool role guard) — not a permission check. No gating is needed here.
  */
 
-import { isToolEnvelope, makeToolEnvelope } from './session/tool-envelope.mjs';
+import { isToolEnvelope, makeToolEnvelope, normalizeToolEnvelope } from './session/tool-envelope.mjs';
+import { classifyResultKind } from './session/result-classification.mjs';
 
 let _executor = null;
 let _tools = [];
@@ -62,12 +63,24 @@ function _normalize(result) {
     // JSON.stringify below and the loop would see the stringified envelope as
     // the tool_result (body inlined + duplicated, no newMessages).
     if (isToolEnvelope(result)) {
-        return makeToolEnvelope(_normalize(result.result), result.newMessages);
+        const normalized = normalizeToolEnvelope(_normalize(result.result));
+        return makeToolEnvelope(normalized.result, result.newMessages, {
+            explicitSuccess: normalized.explicitSuccess || result.explicitSuccess === true,
+        });
     }
     if (result && typeof result === 'object' && Array.isArray(result.content)) {
-        return result.content
+        const text = result.content
             .map((c) => (c?.type === 'text' ? c.text || '' : JSON.stringify(c)))
             .join('\n');
+        // Preserve MCP-style handler outcome metadata across the object→string
+        // boundary. Explicit failures retain the canonical Error: convention;
+        // explicit successes use a transient envelope so legitimate output
+        // beginning with Error: is not mistaken for a failed execution.
+        if (result.isError === true) return !text.startsWith('Error:') ? `Error: ${text}` : text;
+        if (result.isError === false && classifyResultKind(text) === 'error') {
+            return makeToolEnvelope(text, [], { explicitSuccess: true });
+        }
+        return text;
     }
     if (typeof result === 'string') return result;
     return JSON.stringify(result);