mixdog 0.8.0 → 0.9.0

package/scripts/toolcall-args-test.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+// Regression tests pinning the native-provider (OpenAI-compat / claude-code / opencode)
+// tool_call arguments contract: completed-but-malformed arguments JSON is NEVER
+// thrown (which would kill the turn) NOR silently swallowed to {}. With a finish
+// signal observed it is surfaced as an invalid-args MARKER carried on the
+// arguments slot, so the dispatch loop feeds the parse error back to the model
+// as an is_error tool_result and the model self-corrects in the SAME turn.
+// Without a finish signal (mid-stream truncation) it remains a retryable
+// TruncatedStreamError — that transient behavior is deliberately preserved.
+// Unit-test style: synthetic inputs fed
+// directly to the exported parser, asserting the resulting outcome — no
+// network, no model.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import {
+    parseCompletedToolCallArgumentsJson,
+    toolCallsFromStreamAcc,
+    isInvalidToolArgsMarker,
+    formatInvalidToolArgsResult,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import { classifyError } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const STREAM_SRC = resolve(__dirname, '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs');
+
+// Captures the synchronous throw of `fn` and returns the Error, failing if none.
+function captureThrow(fn) {
+    try {
+        const v = fn();
+        assert.fail(`expected throw, got resolved value: ${JSON.stringify(v)}`);
+    } catch (err) {
+        assert.ok(err instanceof Error, 'thrown value must be an Error');
+        return err;
+    }
+}
+
+test('A: valid arguments JSON parses to the intended object', () => {
+    const out = parseCompletedToolCallArgumentsJson(
+        '{"pattern":"x","path":"src"}', 'test', { finishReason: 'stop' });
+    assert.deepEqual(out, { pattern: 'x', path: 'src' });
+});
+
+test('B: empty/missing arguments default to {}', () => {
+    assert.deepEqual(parseCompletedToolCallArgumentsJson('', 'test', { finishReason: 'stop' }), {});
+    assert.deepEqual(parseCompletedToolCallArgumentsJson(null, 'test', { finishReason: 'stop' }), {});
+    assert.deepEqual(parseCompletedToolCallArgumentsJson(undefined, 'test'), {});
+});
+
+test('C: bareword JSON with finishReason → invalid-args marker (no throw, no salvage)', () => {
+    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
+    const out = parseCompletedToolCallArgumentsJson(bareword, 'test', { finishReason: 'stop' });
+    assert.equal(isInvalidToolArgsMarker(out), true);
+    assert.equal(out.__invalidToolArgs, true);
+    assert.equal(out.__rawArguments, bareword);
+    assert.equal(typeof out.__parseError, 'string');
+    assert.ok(out.__parseError.length > 0, 'parse error message must be carried');
+    // Model-facing tool_result text uses the shared invalid-args template.
+    const msg = formatInvalidToolArgsResult({ name: 'grep', arguments: out });
+    assert.match(msg, /invalid JSON/);
+    assert.match(msg, /Re-issue this tool call with valid JSON arguments/);
+});
+
+test('C: bareword JSON without finishReason → retryable TruncatedStreamError', () => {
+    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
+    // meta omitted entirely
+    const err1 = captureThrow(() => parseCompletedToolCallArgumentsJson(bareword, 'test'));
+    assert.equal(err1.name, 'TruncatedStreamError');
+    assert.equal(err1.code, 'TRUNCATED_STREAM');
+    assert.equal(err1.truncatedStream, true);
+    // meta present but finishReason unset
+    const err2 = captureThrow(() =>
+        parseCompletedToolCallArgumentsJson(bareword, 'test', { id: 'call_1', name: 'grep' }));
+    assert.equal(err2.name, 'TruncatedStreamError');
+    assert.equal(err2.code, 'TRUNCATED_STREAM');
+    assert.equal(err2.truncatedStream, true);
+});
+
+test('D: fully malformed "{" splits on finishReason just like bareword', () => {
+    const marker = parseCompletedToolCallArgumentsJson('{', 'test', { finishReason: 'stop' });
+    assert.equal(isInvalidToolArgsMarker(marker), true);
+    assert.equal(marker.__rawArguments, '{');
+
+    const transient = captureThrow(() =>
+        parseCompletedToolCallArgumentsJson('{', 'test'));
+    assert.equal(transient.name, 'TruncatedStreamError');
+    assert.equal(transient.code, 'TRUNCATED_STREAM');
+    assert.equal(transient.truncatedStream, true);
+});
+
+test('E: source no longer contains any salvageBarewordJson reference', () => {
+    const src = readFileSync(STREAM_SRC, 'utf8');
+    assert.equal(src.includes('salvageBarewordJson'), false,
+        'salvage helper must be fully removed');
+});
+
+// Stream-accumulation path: synthetic per-index accumulator + a parseToolCalls
+// shim that delegates to the real parser (same wiring as openai-compat.mjs).
+function parseToolCallsShim(choice, label) {
+    const calls = choice.message?.tool_calls;
+    if (!calls?.length) return undefined;
+    const finishReason = choice.finish_reason || null;
+    return calls
+        .filter((tc) => tc.type === 'function')
+        .map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: parseCompletedToolCallArgumentsJson(
+                tc.function.arguments, label,
+                { id: tc.id, name: tc.function.name, finishReason }),
+        }));
+}
+
+test('stream acc: valid accumulated arguments parse through to a tool call', () => {
+    const acc = new Map();
+    acc.set('n:0', {
+        id: 'call_a', type: 'function',
+        function: { name: 'grep', arguments: '{"pattern":"x","path":"src"}' },
+        _order: 1,
+    });
+    const out = toolCallsFromStreamAcc(acc, parseToolCallsShim, 'test', 'stop');
+    assert.deepEqual(out, [{ id: 'call_a', name: 'grep', arguments: { pattern: 'x', path: 'src' } }]);
+});
+
+test('stream acc: bareword with finish_reason → invalid-args marker on the call (no throw)', () => {
+    const acc = new Map();
+    acc.set('n:0', {
+        id: 'call_b', type: 'function',
+        function: { name: 'grep', arguments: '{"pattern": dispatchAiWrapped, "path": "src/agent"}' },
+        _order: 1,
+    });
+    const out = toolCallsFromStreamAcc(acc, parseToolCallsShim, 'test', 'stop');
+    assert.equal(Array.isArray(out), true);
+    assert.equal(out.length, 1);
+    assert.equal(out[0].id, 'call_b');
+    assert.equal(out[0].name, 'grep');
+    assert.equal(isInvalidToolArgsMarker(out[0].arguments), true);
+});
+
+test('retry-classifier: truncated stream (no finish) → transient (preserved behavior)', () => {
+    // The invalid-args marker is no longer a thrown Error, so there is nothing
+    // for classifyError to route — the dispatch loop handles it as a
+    // tool_result. Only the mid-stream truncation path still throws, and it
+    // must remain transient/retryable.
+    const transient = captureThrow(() =>
+        parseCompletedToolCallArgumentsJson('{', 'test'));
+    assert.equal(classifyError(transient), 'transient');
+});

package/scripts/tui-background-failure-smoke.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { backgroundTaskFailureStatusLabel, isBackgroundErrorOnlyBody } from '../src/runtime/shared/err-text.mjs';
+import { parseBackgroundTaskEnvelope } from '../src/tui/engine.mjs';
+
+function assertEq(label, got, want) {
+  if (got !== want) throw new Error(`${label}: expected ${JSON.stringify(want)}, got ${JSON.stringify(got)}`);
+}
+
+assertEq('context overflow', backgroundTaskFailureStatusLabel('failed', 'AGENT_CONTEXT_OVERFLOW', { surface: 'agent' }), 'Failed · Context too large');
+assertEq('first response timeout', backgroundTaskFailureStatusLabel('failed', 'agent first response stale (120000ms)', { surface: 'agent' }), 'Timeout · No first response 120s');
+assertEq('task stale', backgroundTaskFailureStatusLabel('failed', 'agent task stale (1800000ms)', { surface: 'agent' }), 'Stale · No progress 30m');
+assertEq('tool running stale', backgroundTaskFailureStatusLabel('failed', 'agent tool running stale (180000ms)', { surface: 'agent' }), 'Stale · No progress 3m');
+assertEq(
+  'normalized first response',
+  backgroundTaskFailureStatusLabel('failed', 'No first response from the agent within 120s.', { surface: 'agent' }),
+  'Timeout · No first response 120s',
+);
+assertEq(
+  'normalized stale',
+  backgroundTaskFailureStatusLabel('failed', 'The agent went stale after 30m without new stream/tool progress.', { surface: 'agent' }),
+  'Stale · No progress 30m',
+);
+
+assertEq('error-only body', isBackgroundErrorOnlyBody('Error: Context too large.', 'Context too large.'), true);
+assertEq('real body', isBackgroundErrorOnlyBody('found 3 files\nsrc/a.mjs', ''), false);
+
+function showRawResultForBackgroundMetadata(expanded, isBackgroundMetadataResult, hasDisplayResult, hasRawResult) {
+  return expanded && (hasDisplayResult || hasRawResult) && (!isBackgroundMetadataResult || hasRawResult);
+}
+
+function collapsedFailureUsesHeaderNotDetail(headerFailureStatus, showRawResult) {
+  return Boolean(headerFailureStatus) && !showRawResult;
+}
+
+assertEq('metadata expand with raw', showRawResultForBackgroundMetadata(true, true, false, true), true);
+assertEq('metadata blocked without raw', showRawResultForBackgroundMetadata(true, true, false, false), false);
+
+const headerFailure = backgroundTaskFailureStatusLabel(
+  'failed',
+  'No first response from the agent within 120s.',
+  { surface: 'agent' },
+);
+assertEq('header failure label', headerFailure, 'Timeout · No first response 120s');
+assertEq('failure in header not detail', collapsedFailureUsesHeaderNotDetail(headerFailure, false), true);
+assertEq('expanded raw keeps detail path', collapsedFailureUsesHeaderNotDetail(headerFailure, true), false);
+
+const failedEnvelope = [
+  'background task',
+  'task_id: task_fail_smoke',
+  'surface: explore',
+  'operation: explore',
+  'status: failed',
+  'error: No first response from the agent within 120s.',
+].join('\n');
+const parsed = parseBackgroundTaskEnvelope(failedEnvelope);
+if (!parsed?.rawResult || String(parsed.result || '').trim()) {
+  throw new Error(`failed envelope should keep rawResult and empty display result: ${JSON.stringify(parsed)}`);
+}
+if (!parsed.args?.error) {
+  throw new Error('failed envelope should preserve args.error');
+}
+
+const failedEnvelopeWithErrorBody = [
+  failedEnvelope,
+  '',
+  'Error: No first response from the agent within 120s.',
+].join('\n');
+const parsedWithErrorBody = parseBackgroundTaskEnvelope(failedEnvelopeWithErrorBody);
+if (!parsedWithErrorBody?.rawResult || String(parsedWithErrorBody.result || '').trim()) {
+  throw new Error(`failed envelope with error-only body should keep rawResult and empty display result: ${JSON.stringify(parsedWithErrorBody)}`);
+}
+
+console.log('tui-background-failure-smoke: ok');

package/scripts/usage-metrics-epoch-smoke.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+    bumpUsageMetricsEpoch,
+    bumpUsageMetricsTurnId,
+    resolveUsageMetricsEpoch,
+    usageMetricsIdempotencyKey,
+    applyAskTerminalUsageTotals,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+
+function applyDelta(sessionId, session, delta, seen) {
+    const epoch = resolveUsageMetricsEpoch(session, delta);
+    session.usageMetricsEpoch = epoch;
+    const ikey = usageMetricsIdempotencyKey(sessionId, session, delta);
+    const isReplay = seen.has(ikey);
+    seen.add(ikey);
+    if (!isReplay) {
+        session.totalInputTokens = (session.totalInputTokens || 0) + (delta.deltaInput || 0);
+    }
+    session.lastIterationIndex = delta.iterationIndex;
+    return isReplay;
+}
+
+const sessionId = 'smoke-sess';
+const session = { usageMetricsEpoch: 0, lastIterationIndex: null, totalInputTokens: 0 };
+const seen = new Set();
+
+assert(
+    applyDelta(sessionId, session, { iterationIndex: 1, deltaInput: 100 }, seen) === false,
+    'first iteration should count',
+);
+assert(session.totalInputTokens === 100, 'first iteration tokens');
+
+bumpUsageMetricsEpoch(session);
+assert(session.usageMetricsEpoch === 1, 'compact reset should bump epoch');
+
+const replay = applyDelta(sessionId, session, {
+    iterationIndex: 1,
+    usageMetricsEpoch: session.usageMetricsEpoch,
+    deltaInput: 50,
+}, seen);
+assert(replay === false, 'equal index after compact reset must not be treated as replay');
+assert(session.totalInputTokens === 150, 'post-compact iteration must add tokens');
+
+assert(
+    applyDelta(sessionId, session, {
+        iterationIndex: 1,
+        usageMetricsEpoch: 1,
+        deltaInput: 999,
+    }, seen) === true,
+    'retry of same epoch+index should replay',
+);
+assert(session.totalInputTokens === 150, 'replay must not double-count');
+
+// Semantic compact + provider send at same iteration/epoch (no_change compact path)
+const collisionSeen = new Set();
+const collisionSession = { usageMetricsEpoch: 0, lastIterationIndex: null, totalInputTokens: 0 };
+assert(
+    applyDelta(sessionId, collisionSession, {
+        iterationIndex: 1,
+        source: 'semantic_compact',
+        deltaInput: 20,
+    }, collisionSeen) === false,
+    'semantic compact usage should count',
+);
+assert(
+    applyDelta(sessionId, collisionSession, {
+        iterationIndex: 1,
+        source: 'provider_send',
+        deltaInput: 80,
+    }, collisionSeen) === false,
+    'provider send at same iteration must not replay semantic compact key',
+);
+assert(collisionSession.totalInputTokens === 100, 'semantic + provider usage both counted');
+
+// Integrated incremental + terminal: totals applied once when incremental flag set
+const integrated = { totalInputTokens: 1000, totalOutputTokens: 0, tokensCumulative: 1000 };
+integrated.totalInputTokens += 40;
+integrated.totalOutputTokens += 6;
+integrated.tokensCumulative += 46;
+applyAskTerminalUsageTotals(integrated, {
+    usage: { inputTokens: 40, outputTokens: 6 },
+    lastTurnUsage: { inputTokens: 40, outputTokens: 6 },
+}, { skipTotalsIfIncremental: true });
+assert(integrated.totalInputTokens === 1040, 'terminal must not double-count incremental turn totals');
+assert(integrated.totalOutputTokens === 6, 'terminal must not double-count output');
+assert(integrated.lastInputTokens === 40, 'terminal still updates last-turn window snapshot');
+
+// Cross-ask collision (reviewer07): ask #2 reuses iteration indices 1-2
+const crossSeen = new Set();
+const crossSession = { usageMetricsEpoch: 0, usageMetricsTurnId: 0, lastIterationIndex: null, totalInputTokens: 0 };
+bumpUsageMetricsTurnId(crossSession);
+assert(crossSession.usageMetricsTurnId === 1, 'ask #1 turn id');
+assert(applyDelta(sessionId, crossSession, { iterationIndex: 1, source: 'provider_send', deltaInput: 100 }, crossSeen) === false);
+assert(applyDelta(sessionId, crossSession, { iterationIndex: 2, source: 'provider_send', deltaInput: 200 }, crossSeen) === false);
+assert(crossSession.totalInputTokens === 300, 'ask #1 iterations counted');
+bumpUsageMetricsTurnId(crossSession);
+assert(crossSession.usageMetricsTurnId === 2, 'ask #2 turn id');
+assert(
+    applyDelta(sessionId, crossSession, { iterationIndex: 1, source: 'provider_send', deltaInput: 10 }, crossSeen) === false,
+    'ask #2 iteration 1 must not replay ask #1 key',
+);
+assert(
+    applyDelta(sessionId, crossSession, { iterationIndex: 2, source: 'provider_send', deltaInput: 20 }, crossSeen) === false,
+    'ask #2 iteration 2 must not replay ask #1 key',
+);
+assert(applyDelta(sessionId, crossSession, { iterationIndex: 3, source: 'provider_send', deltaInput: 30 }, crossSeen) === false);
+assert(crossSession.totalInputTokens === 360, 'ask #2 tokens must include iter 1-3 without undercount');
+
+process.stdout.write('usage-metrics-epoch-smoke: ok\n');
+

package/src/agents/debugger/AGENT.md

@@ -1,3 +1,11 @@
+---
+permission: read
+---
+
 # Debugger
 
 Bug tracking and analysis agent.
+
+Return the most likely cause, supporting evidence, and the smallest useful next
+check or fix path. Avoid broad speculation; distinguish confirmed facts from
+inferences.

package/src/agents/explore/AGENT.md

@@ -1,3 +1,7 @@
+---
+permission: read
+---
+
 # Explore
 
 Repository exploration agent that finds relevant surfaces and summarizes them

package/src/agents/heavy-worker/AGENT.md

@@ -1,3 +1,9 @@
-# Heavy Worker
-
-Complex implementation agent.
+---
+permission: read-write
+---
+
+# Heavy Worker
+Complex implementation agent.
+
+Reviewer/Lead verification follows your delivery; avoid broad build/test loops and focus on minimal checks plus how to verify. Scope confirmation, obvious-error checks, and static review are fine.
+

package/src/agents/maintainer/AGENT.md

@@ -1,3 +1,7 @@
+---
+permission: read-write
+---
+
 # Maintainer
 
 Maintenance and cleanup agent.

package/src/agents/reviewer/AGENT.md

@@ -1,3 +1,11 @@
+---
+permission: read
+---
+
 # Reviewer
 
 Cross-checking review agent.
+
+Return findings first, ordered by severity, with precise file references when
+available. If no actionable issues are found, say so clearly and note only
+material residual risk or missing verification.

package/src/agents/scheduler-task/AGENT.md

@@ -0,0 +1,12 @@
+---
+permission: read-write
+toolSchemaProfile: read-write-search
+---
+
+# Scheduler Task
+
+Scheduled task execution agent.
+
+Output a concise English handoff for Lead: outcome, action taken or skipped,
+notable evidence, and any remaining risk. If there is nothing actionable, use
+the skip protocol.

package/src/agents/scheduler-task/agent.json

@@ -0,0 +1,6 @@
+{
+  "id": "scheduler-task",
+  "name": "Scheduler Task",
+  "description": "Scheduled-task executor invoked by scheduler tick.",
+  "entry": "AGENT.md"
+}

package/src/agents/webhook-handler/AGENT.md

@@ -0,0 +1,12 @@
+---
+permission: read-write
+toolSchemaProfile: read-write-search
+---
+
+# Webhook Handler
+
+Inbound webhook event analysis agent.
+
+Output a concise English handoff for Lead: event outcome, action taken or
+skipped, notable evidence, and any remaining risk. If there is nothing
+actionable, use the skip protocol.

package/src/agents/webhook-handler/agent.json

@@ -0,0 +1,6 @@
+{
+  "id": "webhook-handler",
+  "name": "Webhook Handler",
+  "description": "Webhook payload handler invoked by inbound webhook events.",
+  "entry": "AGENT.md"
+}

package/src/agents/worker/AGENT.md

@@ -1,3 +1,9 @@
-# Worker
-
-Basic implementation agent.
+---
+permission: read-write
+---
+
+# Worker
+Basic implementation agent.
+
+Reviewer/Lead verification follows your delivery; keep self-checks minimal (scope confirmation and obvious-error checks). Static review, change summaries, and manual verification notes are fine.
+

package/src/app.mjs

@@ -6,9 +6,33 @@ import { performance } from 'node:perf_hooks';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VALUE_OPTIONS = new Set(['--provider', '--model']);
 const FLAG_OPTIONS = new Set(['--readonly', '--help', '-h', '--plain', '--react']);
+const HEADLESS_ROLE_ALIASES = new Map([
+  ['explorer', 'explore'],
+  ['explore', 'explore'],
+  ['maint', 'maintainer'],
+  ['maintenance', 'maintainer'],
+  ['maintainer', 'maintainer'],
+  ['worker', 'worker'],
+  ['heavy', 'heavy-worker'],
+  ['heavyworker', 'heavy-worker'],
+  ['heavy-worker', 'heavy-worker'],
+  ['review', 'reviewer'],
+  ['reviewer', 'reviewer'],
+  ['debug', 'debugger'],
+  ['debugger', 'debugger'],
+  ['web', 'web-researcher'],
+  ['web-researcher', 'web-researcher'],
+]);
 const BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ''));
 const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
 
+// Many independent singletons self-register a process 'exit' drain (session
+// store, bash sessions, search/memory state, bridge trace, channel worker, …),
+// which legitimately exceeds Node's default 10-listener warning threshold in a
+// fully-loaded runtime. Raise the cap once at the CLI entry so a benign
+// MaxListenersExceededWarning never leaks into the user's terminal.
+try { process.setMaxListeners(Math.max(process.getMaxListeners(), 64)); } catch { /* ignore */ }
+
 function bootProfile(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED) return;
   const elapsedMs = performance.now() - BOOT_PROFILE_START;
@@ -33,6 +57,41 @@ function unknownOption(argv) {
   return null;
 }
 
+function positionalArgs(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (VALUE_OPTIONS.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (FLAG_OPTIONS.has(arg)) continue;
+    if (String(arg || '').startsWith('-')) continue;
+    out.push(arg);
+  }
+  return out;
+}
+
+function normalizeHeadlessRole(value) {
+  const key = String(value || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+  return HEADLESS_ROLE_ALIASES.get(key) || null;
+}
+
+export function parseHeadlessRoleCommand(argv = []) {
+  const args = positionalArgs(argv);
+  if (args.length === 0) return null;
+
+  if (String(args[0] || '').toLowerCase() === 'role') {
+    return { error: 'usage: mixdog <role> <message...>' };
+  }
+
+  const role = normalizeHeadlessRole(args[0]);
+  if (!role) return null;
+  const message = args.slice(1).join(' ').trim();
+  if (!message) return { error: `usage: mixdog ${args[0]} <message...>` };
+  return { role, message };
+}
+
 /**
  * mixdog launcher.
  *
@@ -57,10 +116,9 @@ export async function run(argv = []) {
     toolMode,
   };
 
-  // `--help` / `-h`: print the help text and exit 0. The help source lives in
-  // repl.mjs (single source of truth) and is exported as printHelp().
+  // `--help` / `-h`: keep this path tiny; do not import the REPL/runtime stack.
   if (argv.includes('--help') || argv.includes('-h')) {
-    const { printHelp } = await import('./repl.mjs');
+    const { printHelp } = await import('./help.mjs');
     printHelp();
     return 0;
   }
@@ -76,6 +134,22 @@ export async function run(argv = []) {
     return 1;
   }
 
+  const headless = parseHeadlessRoleCommand(argv);
+  if (headless?.error) {
+    process.stderr.write(`mixdog: ${headless.error}\n`);
+    return 1;
+  }
+  if (headless) {
+    const { runHeadlessRole } = await import('./headless-role.mjs');
+    return await runHeadlessRole({
+      role: headless.role,
+      message: headless.message,
+      provider: opts.provider,
+      model: opts.model,
+      cwd: process.cwd(),
+    });
+  }
+
   // Default: the canonical React/Ink TUI over the mixdog session runtime.
   const bundle = join(__dirname, 'tui', 'dist', 'index.mjs');
   if (!existsSync(bundle)) {

package/src/defaults/hidden-roles.json

@@ -3,10 +3,10 @@
     {
       "name": "explorer",
       "slot": "explore",
-      "systemFile": "rules/bridge/30-explorer.md",
+      "systemFile": "rules/agent/30-explorer.md",
       "description": "Filesystem navigation agent invoked by the `explore` MCP tool",
       "invokedBy": "explore",
-      "toolSchemaProfile": "filesystem-read",
+      "toolSchemaProfile": "read",
       "kind": "retrieval",
       "permission": "read",
       "stallCap": { "idleSeconds": 240, "toolRunningSeconds": 180 }
@@ -14,43 +14,47 @@
     {
       "name": "cycle1-agent",
       "slot": "cycle1",
-      "systemFile": "rules/bridge/40-cycle1-agent.md",
+      "systemFile": "rules/agent/40-cycle1-agent.md",
       "description": "Chunker/classifier invoked by memory-cycle runCycle1",
       "invokedBy": "cycle1",
       "maintKey": "memory",
-      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "toolSchemaProfile": "none",
+      "kind": "maintenance",
       "permission": "read",
       "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
     },
     {
       "name": "cycle2-agent",
       "slot": "cycle2",
-      "systemFile": "rules/bridge/41-cycle2-agent.md",
+      "systemFile": "rules/agent/41-cycle2-agent.md",
       "description": "Root re-scorer invoked by memory-cycle runCycle2",
       "invokedBy": "cycle2",
       "maintKey": "memory",
-      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "toolSchemaProfile": "none",
+      "kind": "maintenance",
       "permission": "read",
       "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
     },
     {
       "name": "cycle3-agent",
       "slot": "cycle3",
-      "systemFile": "rules/bridge/42-cycle3-agent.md",
+      "systemFile": "rules/agent/42-cycle3-agent.md",
       "description": "Core memory reviewer invoked by memory-cycle runCycle3",
       "invokedBy": "cycle3",
       "maintKey": "memory",
-      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "toolSchemaProfile": "none",
+      "kind": "maintenance",
       "permission": "read",
       "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
     },
     {
       "name": "scheduler-task",
       "slot": "scheduler",
-      "systemFile": "agents/scheduler-task.md",
+      "systemFile": "agents/scheduler-task/AGENT.md",
       "description": "Scheduled-task executor invoked by scheduler tick",
       "invokedBy": "scheduler",
-      "toolSchemaProfile": "unified",      "kind": "maintenance",
+      "toolSchemaProfile": "read-write-search",
+      "kind": "maintenance",
       "permission": "read-write",
       "inboundEvent": true,
       "instructionDir": "schedules",
@@ -59,10 +63,11 @@
     {
       "name": "webhook-handler",
       "slot": "webhook",
-      "systemFile": "agents/webhook-handler.md",
+      "systemFile": "agents/webhook-handler/AGENT.md",
       "description": "Webhook payload handler invoked by inbound webhook events",
       "invokedBy": "webhook",
-      "toolSchemaProfile": "unified",      "kind": "maintenance",
+      "toolSchemaProfile": "read-write-search",
+      "kind": "maintenance",
       "permission": "read-write",
       "inboundEvent": true,
       "instructionDir": "webhooks",