@demlik/tea 0.14.0 → 0.16.0

package/dist/{chunk-Z2L3LSNV.js → chunk-EHUDXAKC.js}

@@ -1,118 +1,129 @@
-import { createMonitoredRun } from './chunk-HYDWG35Q.js';
-import { createFanOut, initFanOut } from './chunk-MYXFNWAJ.js';
-import { MsgType, createResilientCall } from './chunk-AQ6ZIMEA.js';
-import { subscribeDeadline } from './chunk-F2US5BW6.js';
 import { describeError } from './chunk-G5E74IJB.js';
-import { Cmd, cmdEdgeOf, detachWorkOf, absurd, defineMachine, malformedResult, run, driveToDone } from './chunk-RQULHGYH.js';
-import { Result } from 'better-result';
-import { z } from 'zod';
+import { createMonitoredRun } from './chunk-7MGXQZPW.js';
+import { createFanOut, initFanOut } from './chunk-QNGYQMZB.js';
+import { createResilientCall } from './chunk-6NG4V5SB.js';
+import { rejectAll, unchecked } from './chunk-4LPY67E4.js';
+import { deadlinesSub, subscribeDeadline } from './chunk-IVJP3GKJ.js';
+import { run, driveToDone } from './chunk-WT5PBPLB.js';
+import { Cmd, Outcome, cmdEdgeOf, detachWorkOf, absurd, defineMachine, validateSync, malformedResult } from './chunk-CH5KTOEZ.js';
 
 // src/internal/llm-call/index.ts
-function plainModel(fn) {
-  return () => ({
-    withStructuredOutput(schema) {
-      return {
-        invoke: async (messages) => schema.parse(await fn(messages))
-      };
-    }
-  });
-}
-function isPlainModel(model) {
-  return Object.prototype.toString.call(model) === "[object AsyncFunction]";
-}
-var PLAIN_MODEL_MISROUTE_REASON = "model: a sync function returned a Promise where an Llm was expected \u2014 a promise-returning model that is not declared `async` must be wrapped in plainModel(fn) (see the llm-call module)";
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function asModelFactory(model) {
-  if (isPlainModel(model)) return plainModel(model);
-  return (modelId) => {
-    const llm = model(modelId);
-    if (isThenable(llm)) {
-      llm.then(void 0, () => void 0);
-      throw new Error(PLAIN_MODEL_MISROUTE_REASON);
-    }
-    return llm;
-  };
-}
 function createLlmCall(config, rng = Math.random) {
   const resilientConfig = {
     ...config.retry === void 0 ? {} : { retry: config.retry }
   };
   const rc = createResilientCall(resilientConfig, rng);
-  const modelOf = asModelFactory(config.model);
   function init() {
     return rc.init();
   }
   function attempt(s, input, at, key = input.purpose) {
     return rc.attempt(s, key, input, at);
   }
-  function succeed(s, key, msg) {
-    return rc.succeed(s, key, msg);
+  function succeed(s, msg) {
+    const { call, cmds } = rc.settle(s, msg);
+    return [call, cmds];
+  }
+  function errOf(msg) {
+    const error = msg.error;
+    const cause = "cause" in error ? error.cause : error;
+    return {
+      key: msg.cmd.key,
+      purpose: msg.cmd.input.purpose,
+      reason: describeError(cause),
+      error: cause
+    };
   }
-  function fail(s, key, msg) {
-    return rc.fail(s, key, msg);
+  function fail(s, msg) {
+    const { call, cmds } = rc.settle(s, { ...msg, error: errOf(msg) });
+    return [call, cmds];
   }
   function onTimer(s, msg) {
     return rc.onTimer(s, msg);
   }
-  function subs(s) {
-    return rc.subs(s);
-  }
-  async function invokeOne(input) {
-    const model = modelOf(input.model);
-    const messages = config.loadMessages ? await config.loadMessages(input) : [];
-    const schema = config.schemas[input.purpose];
-    const structured = model.withStructuredOutput(schema);
-    const raw = await structured.invoke(messages);
-    const output = schema.parse(raw);
-    return { key: input.purpose, purpose: input.purpose, output };
+  function deadlines(s) {
+    return rc.deadlines(s);
   }
-  const resilientRunHandler = rc.handlers({
-    run: (input) => invokeOne(input)
-  }).resilient_run;
-  async function settleOf(cmd) {
-    const settle = await resilientRunHandler(cmd, {});
-    if (settle.type === MsgType.ResilientOk) {
-      return { ...settle, result: { ...settle.result, key: cmd.key } };
+  function decode(cmd, raw) {
+    const { purpose } = cmd.input;
+    try {
+      const output = config.schemas[purpose].parse(raw);
+      return Outcome.ok({ key: cmd.key, purpose, output });
+    } catch (cause) {
+      return rejected2(cause);
     }
-    const rawError = settle.error;
-    const err = {
-      key: cmd.key,
-      purpose: cmd.input.purpose,
-      reason: describeError(rawError),
-      error: rawError
-    };
-    return {
-      type: MsgType.ResilientErr,
-      key: settle.key,
-      error: err,
-      at: settle.at
-    };
   }
-  function handlers(ports) {
-    if (ports === void 0) {
-      return { resilient_run: (cmd) => settleOf(cmd) };
-    }
-    return {
-      resilient_run: (cmd, ctx) => {
-        const fired = (async () => {
-          const settle = await settleOf(cmd);
-          if (settle.type === MsgType.ResilientOk) {
-            const msg2 = ports.onOk(settle.result);
-            if (msg2 !== void 0) await ctx.dispatch(msg2);
-            return;
-          }
-          const msg = ports.onErr(settle.error);
-          if (msg !== void 0) await ctx.dispatch(msg);
-        })();
-        ctx.waitUntil(fired);
-      }
-    };
+  function rejected2(cause) {
+    return Outcome.err({ _tag: "port_rejected", cause });
   }
-  return { init, attempt, succeed, fail, onTimer, subs, handlers, invokeOne };
+  return {
+    name: rc.name,
+    /** The `Cmd.define`d run Cmd — list it in the machine's `cmds`. */
+    run: rc.run,
+    init,
+    attempt,
+    succeed,
+    fail,
+    errOf,
+    onTimer,
+    deadlines,
+    /** The built-in `timer` Sub's deps — resilient-call's `timer`. */
+    timer: rc.timer,
+    decode,
+    rejected: rejected2,
+    /** The structured-output schema for `purpose`. */
+    schemaOf: (purpose) => config.schemas[purpose]
+  };
 }
 
+// src/protocol.ts
+var MsgType = {
+  // --- resilient-call: the run Cmd + its two settle Msgs -------------------
+  /** The "run the port for `key`" effect Cmd resilient-call emits. */
+  ResilientRun: "resilient_run",
+  /**
+   * PRIVATE success settle Msg (read only by `agentEvents`, #47). The engine
+   * mints it from the run Cmd's outcome (ADR 0021), so it is `<run>_ok`.
+   */
+  ResilientOk: "resilient_run_ok",
+  /** Failure settle Msg — routed to `settle` (back off via retry). */
+  ResilientErr: "resilient_run_err",
+  // --- agent: the wired machine's own entry-point Msgs ---------------------
+  /** Begin a run. */
+  AgentStart: "agent_start",
+  /** PRIVATE tool-fan-out success settle Msg (read only by `agentEvents`, #47). */
+  AgentToolOk: "agent_tool_ok",
+  /** Tool-fan-out failure settle Msg. */
+  AgentToolErr: "agent_tool_err",
+  /**
+   * Re-fire the one outstanding effect on rehydrate (the do↔agent seam). Fired
+   * by `do/host`'s `autoBoot` via the typed `agentBootMsg` constructor, matched
+   * by the agent reducer — see `AgentBootPort` in `../agent`.
+   */
+  AgentBoot: "agent_boot",
+  /**
+   * Stop the run from outside and settle it `cancelled` — what an `AbortSignal`
+   * handed to `driveToDone` / a defined agent's `run` dispatches on abort. A
+   * transition, never a throw: the outcome lands in the Model, so a reload reads
+   * a run that ended rather than one to resume.
+   */
+  AgentCancel: "agent_cancel",
+  // --- agent: the context-compaction round-trip (#85) ----------------------
+  /**
+   * The "summarize the oldest N turns" effect Cmd the agent emits when its
+   * `CompactionPolicy` asks to compact before a brain call. A DEDICATED
+   * round-trip (design B1), distinct from the brain call's `resilient_run`, so
+   * compaction is its own honest `Awaiting` state — see `../agent`.
+   */
+  CompactRun: "compact_run",
+  /** Compaction round-trip resolved — carries the summary text the fold-back folds. */
+  CompactOk: "compact_ok",
+  /** Compaction round-trip failed (exhausted retry) — surfaced as data, not a stall. */
+  CompactErr: "compact_err",
+  // --- authed-call: the 401 trigger ----------------------------------------
+  /** The 401 the consumer dispatches when a guarded call comes back unauthorized. */
+  Unauthorized: "unauthorized"
+};
+
 // src/agent/schema.ts
 function schemaFromGuard(guard, name) {
   return {
@@ -217,7 +228,7 @@ function agentEvents(opts) {
 function projectOwn(msg, events, refused) {
   switch (msg.type) {
     case MsgType.ResilientOk:
-      events.push({ type: "TurnSettled", turn: msg.result.output });
+      events.push({ type: "TurnSettled", turn: msg.value.output });
       break;
     case MsgType.AgentToolOk:
       if (!refused.has(msg.callId)) {
@@ -228,23 +239,6 @@ function projectOwn(msg, events, refused) {
         });
       }
       break;
-    // start / boot / cancel / timer / the *_err arms / the compaction settles
-    // carry no public event. (No `default`: the switch is exhaustive over the Msg
-    // discriminant, so a new Msg variant forces a decision here at compile
-    // time.) Compaction is an internal optimization, not a semantic lifecycle
-    // moment a UI folds — its settles are deliberately silent here. Cancel is
-    // silent for a stronger reason: the run the caller stopped owes the public
-    // channel nothing after the stop, so a `RunCancelled` would be one more
-    // late thing to have to ignore.
-    case MsgType.AgentStart:
-    case MsgType.AgentCancel:
-    case MsgType.AgentToolErr:
-    case MsgType.ResilientErr:
-    case MsgType.CompactOk:
-    case MsgType.CompactErr:
-    case "deadline_exceeded":
-    case MsgType.AgentBoot:
-      break;
   }
 }
 function mergeInterpret(a, b) {
@@ -253,6 +247,50 @@ function mergeInterpret(a, b) {
 function liftAgent(state, [slice, cmds]) {
   return [{ ...state, agent: slice }, cmds];
 }
+
+// src/agent/model.ts
+function plainModel(fn) {
+  return () => ({
+    withStructuredOutput(schema) {
+      return {
+        invoke: async (messages) => schema.parse(await fn(messages))
+      };
+    }
+  });
+}
+function isPlainModel(model) {
+  return Object.prototype.toString.call(model) === "[object AsyncFunction]";
+}
+var PLAIN_MODEL_MISROUTE_REASON = "model: a sync function returned a Promise where an Llm was expected \u2014 a promise-returning model that is not declared `async` must be wrapped in plainModel(fn) (see the agent's model ports)";
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function asModelFactory(model) {
+  if (isPlainModel(model)) return plainModel(model);
+  return (modelId) => {
+    const llm = model(modelId);
+    if (isThenable(llm)) {
+      llm.then(void 0, () => void 0);
+      throw new Error(PLAIN_MODEL_MISROUTE_REASON);
+    }
+    return llm;
+  };
+}
+function brainHandler(llm, ports) {
+  const modelOf = asModelFactory(ports.model);
+  return async (cmd) => {
+    try {
+      const model = modelOf(cmd.input.model);
+      const messages = ports.loadMessages ? await ports.loadMessages(cmd.input) : [];
+      const bound = model.withStructuredOutput(llm.schemaOf(cmd.input.purpose));
+      return llm.decode(cmd, await bound.invoke(messages));
+    } catch (cause) {
+      return llm.rejected(cause);
+    }
+  };
+}
+
+// src/agent/tool.ts
 var REJECTED_TYPE = "tool_rejected";
 var SNAPSHOT_WRITE_TYPE = "snapshot_write";
 var SETTLE_SUFFIX = /_(?:ok|err|run)$/;
@@ -275,41 +313,27 @@ function tool(name, spec, handler) {
     );
   }
   const def = Cmd.define(name, {
-    input: z.object({
-      callId: z.string(),
-      args: spec.input
-    }),
+    // The router parses `args` against `spec.input` before it builds the Cmd,
+    // so the Cmd's own input schema only names the type.
+    input: unchecked(),
     ok: spec.ok,
-    err: [...spec.err, "thrown"],
-    requirements: spec.requirements
+    err: [...spec.err, "thrown"]
   });
   const declared = new Set(spec.err);
   const settle = {
-    ok: (value) => Result.ok(value),
-    fail: (error) => Result.err(error)
+    ok: Outcome.ok,
+    fail: Outcome.err
   };
   const asDeclared = (thrown) => {
     if (isTagged(thrown) && declared.has(thrown._tag)) return thrown;
     return { _tag: "thrown", message: describeError(thrown) };
   };
   const interpret = async (cmd, ctx) => {
-    let result;
     try {
-      result = await handler(cmd.args, ctx, settle);
+      return await handler(cmd.args, ctx, settle);
     } catch (thrown) {
-      return def.err(cmd, asDeclared(thrown));
+      return Outcome.err(asDeclared(thrown));
     }
-    return result.match({
-      ok: (value) => {
-        const parsed = spec.ok.safeParse(value);
-        return parsed.success ? def.ok(cmd, parsed.data) : {
-          type: def.errType,
-          cmd,
-          error: malformedResult(parsed.error.issues)
-        };
-      },
-      err: (error) => def.err(cmd, error)
-    });
   };
   return Object.assign(def, {
     description: spec.description,
@@ -329,10 +353,8 @@ function isTagged(value) {
   return typeof value === "object" && value !== null && typeof value._tag === "string";
 }
 var rejected = Cmd.define(REJECTED_TYPE, {
-  input: z.custom(
-    () => true
-  ),
-  ok: z.never(),
+  input: unchecked(),
+  ok: rejectAll,
   err: ["unknown_tool", "malformed_args"]
 });
 function toolRouter(tools) {
@@ -354,22 +376,26 @@ function toolRouter(tools) {
         error: { _tag: "unknown_tool", name: call.name }
       });
     }
-    const parsed = t.args.safeParse(call.args);
-    if (!parsed.success) {
+    const parsed = validateSync(
+      t.args,
+      call.args,
+      `the "${call.name}" tool's input schema`
+    );
+    if (parsed.issues !== void 0) {
       return rejected({
         callId: call.callId,
         error: {
           _tag: "malformed_args",
           name: call.name,
-          issues: malformedResult(parsed.error.issues).issues
+          issues: malformedResult(parsed.issues).issues
         }
       });
     }
     const build = t;
-    return build({ callId: call.callId, args: parsed.data });
+    return build({ callId: call.callId, args: parsed.value });
   };
   const handlers = {
-    [rejected.cmdType]: async (cmd) => rejected.err(cmd, cmd.error)
+    [rejected.cmdType]: async (cmd) => Outcome.err(cmd.error)
   };
   for (const t of tools) handlers[t.cmdType] = t.interpret;
   const interpret = handlers;
@@ -564,10 +590,9 @@ function createToolLadder(resilienceOf2, toolOf, rng) {
     const rc = rcFor(call);
     if (rc === null) return s;
     const key = toolCallKey(call.name, call.callId);
-    const [slice] = rc.succeed(sliceOf(s, call.name, rc), key, {
-      type: MsgType.ResilientOk,
-      key,
-      result: null,
+    const { call: slice } = rc.settle(sliceOf(s, call.name, rc), {
+      cmd: { key },
+      value: null,
       at
     });
     return { ...s, [call.name]: forget(slice, key) };
@@ -577,13 +602,12 @@ function createToolLadder(resilienceOf2, toolOf, rng) {
     if (rc === null) return [s, failure];
     const key = toolCallKey(call.name, call.callId);
     const before = sliceOf(s, call.name, rc);
-    const [slice] = rc.fail(before, key, {
-      type: MsgType.ResilientErr,
-      key,
+    const { call: slice, outcome } = rc.settle(before, {
+      cmd: { key },
       error: failure,
       at
     });
-    if (slice.calls[key]?.phase === "waiting_retry") {
+    if (outcome.kind === "retrying") {
       return [{ ...s, [call.name]: slice }, null];
     }
     const attempts = before.retry[key]?.attempt;
@@ -654,7 +678,7 @@ function createToolLadder(resilienceOf2, toolOf, rng) {
     for (const slice of Object.values(s)) {
       const sample = firstInput(slice);
       const rc = sample === null ? null : rcFor(sample);
-      if (rc !== null) out.push(...rc.subs(slice));
+      if (rc !== null) out.push(...rc.deadlines(slice));
     }
     return out;
   };
@@ -735,12 +759,14 @@ function definedAgent(config, wiring, overlays) {
     };
     const compaction = config.compaction;
     const agent = compaction === void 0 ? (
-      // The one assertion in the pair, and it widens the Cmd union rather
-      // than the interpret obligation: this machine's `AgentCmd` fixes
-      // compaction OFF, `DefinedAgentMachine` names the ON superset, and the
-      // gap is the `compact_run` Cmd a policy-less reducer provably never
-      // emits. Widening a union nothing can produce is sound; the reverse —
-      // claiming a cell that is not wired — is what the discriminant refuses.
+      // The one assertion in the pair, and it widens the Cmd union: this
+      // machine's `AgentCmd` fixes compaction OFF, `DefinedAgentMachine`
+      // names the ON superset, and the gap is the `compact_run` Cmd a
+      // policy-less reducer provably never emits. Widening a union nothing
+      // can produce is sound. The table beside it is read at that same
+      // superset type, and it holds no `compact_run` cell — the Cmd it would
+      // serve never fires, and `overlaid` reads the table's own keys, so an
+      // overlay naming that cell still gets the "has none" throw.
       createAgent(core).toMachine({
         tools
       })
@@ -750,8 +776,11 @@ function definedAgent(config, wiring, overlays) {
   const machine = (input) => machineWith(input, void 0);
   const drive = (input, ...[opts = noHost()]) => {
     const { onEvent, onChunk } = opts;
-    const handle = run(machineWith(input, onChunk), {
+    const wired = machineWith(input, onChunk);
+    const handle = run(wired.machine, {
       ...opts,
+      interpret: wired.interpret,
+      subscribe: wired.subscribe,
       terminal: isEnded,
       events: onEvent === void 0 ? void 0 : agentEvents({
         tools
@@ -784,9 +813,9 @@ function definedAgent(config, wiring, overlays) {
     with: (overlay) => definedAgent(config, wiring, [...overlays, overlay.interpret])
   };
 }
-function overlaid(machine, overlays) {
-  if (overlays.length === 0) return machine;
-  const cells = { ...machine.interpret };
+function overlaid(wired, overlays) {
+  if (overlays.length === 0) return wired;
+  const cells = { ...wired.interpret };
   for (const overlay of overlays) {
     const wrappers = overlay;
     for (const [type, wrap] of Object.entries(wrappers)) {
@@ -799,10 +828,7 @@ function overlaid(machine, overlays) {
       cells[type] = wrap(cell);
     }
   }
-  return defineMachine({
-    ...machine,
-    interpret: cells
-  });
+  return { ...wired, interpret: cells };
 }
 function brainOf(model, onChunk) {
   if (!isStreamingModel(model)) {
@@ -831,7 +857,9 @@ function compactingMachine(core, knob, brain, tools) {
     tools,
     toolInterpret: { compact_run: summarizeWith(brain) }
   };
-  return agent.toMachine(wiring);
+  return agent.toMachine(
+    wiring
+  );
 }
 var SUMMARIZE_INSTRUCTION = "Summarize the conversation so far. Preserve the facts, decisions and tool results a continuation would need, and drop everything else. Reply with the summary as your message content and request no tools.";
 function compactionPolicyOf(knob) {
@@ -930,11 +958,12 @@ function withToolErrorHook(router, onToolError) {
   const wrapped = {};
   for (const [type, handler] of Object.entries(handlers)) {
     wrapped[type] = async (cmd, ctx) => {
-      const msg = await handler(cmd, ctx);
-      if (msg === void 0) return msg;
+      const returned = await handler(cmd, ctx);
+      const msg = cmdEdgeOf(ctx)(cmd, returned);
+      if (typeof msg !== "object" || msg === null) return returned;
       const settled = router.outcomeOf(msg);
-      if (settled === null || settled.outcome.kind === "ok") return msg;
-      if (ownedByLadder(router, cmd, settled.callId)) return msg;
+      if (settled === null || settled.outcome.kind === "ok") return returned;
+      if (ownedByLadder(router, cmd, settled.callId)) return returned;
       try {
         await onToolError(settled.outcome, {
           callId: settled.callId,
@@ -943,7 +972,7 @@ function withToolErrorHook(router, onToolError) {
       } catch (err) {
         console.warn("@demlik/tea: a run's onToolError hook threw", err);
       }
-      return msg;
+      return returned;
     };
   }
   return {
@@ -1010,13 +1039,15 @@ function createAgent(config) {
   });
   const llm = createLlmCall(
     {
-      model: config.model,
       schemas: config.schemas,
-      ...config.retry !== void 0 ? { retry: config.retry } : {},
-      ...config.loadMessages !== void 0 ? { loadMessages: config.loadMessages } : {}
+      ...config.retry !== void 0 ? { retry: config.retry } : {}
     },
     rng
   );
+  const invokeBrain = brainHandler(llm, {
+    model: config.model,
+    ...config.loadMessages !== void 0 ? { loadMessages: config.loadMessages } : {}
+  });
   const compactRc = createResilientCall({ ...config.retry !== void 0 ? { retry: config.retry } : {} }, rng);
   const fan = createFanOut({
     concurrency: config.toolConcurrency ?? 1,
@@ -1071,8 +1102,10 @@ function createAgent(config) {
   }
   const compact = {
     attempt: (slice, key, input, at) => reKeyCompactCmds(compactRc.attempt(slice, key, input, at)),
-    succeed: (slice, key, msg) => reKeyCompactCmds(compactRc.succeed(slice, key, msg)),
-    fail: (slice, key, msg) => reKeyCompactCmds(compactRc.fail(slice, key, msg)),
+    settle: (slice, msg) => {
+      const { call, cmds, outcome } = compactRc.settle(slice, msg);
+      return { call, cmds: cmds.map(toCompactRunCmd), outcome };
+    },
     onTimer: (slice, msg) => reKeyCompactCmds(compactRc.onTimer(slice, msg))
   };
   function start(s, runId, at) {
@@ -1265,23 +1298,22 @@ function createAgent(config) {
     if (config.stopWhen?.(s) === true) return cancel(s, at);
     return null;
   }
-  function succeed(s, key, msg, at) {
-    const [resilience, retryCmds] = llm.succeed(s.resilience, key, msg);
+  function succeed(s, msg, at) {
+    const [resilience, retryCmds] = llm.succeed(s.resilience, msg);
     const settled = { ...s, resilience };
-    const [withTurn, turnCmds] = turn(settled, msg.result.output, at);
+    const [withTurn, turnCmds] = turn(settled, msg.value.output, at);
     return [withTurn, [...retryCmds, ...turnCmds]];
   }
-  function fail(s, key, msg, at) {
-    const [resilience, cmds] = llm.fail(s.resilience, key, msg);
-    const call = resilience.calls[key];
-    const failure = call?.phase === "failed" ? { reason: "llm", error: msg.error, at } : s.failure;
+  function fail(s, msg, at) {
+    const [resilience, cmds] = llm.fail(s.resilience, msg);
+    const call = resilience.calls[msg.cmd.key];
+    const failure = call?.phase === "failed" ? { reason: "llm", error: llm.errOf(msg), at } : s.failure;
     return [{ ...s, resilience, failure }, cmds];
   }
   function compactOk(s, key, msg, at) {
-    const [compaction, retryCmds] = compact.succeed(s.compaction, key, {
-      type: MsgType.ResilientOk,
-      key: msg.key,
-      result: msg.result,
+    const { call: compaction, cmds: retryCmds } = compact.settle(s.compaction, {
+      cmd: { key },
+      value: msg.result,
       at: msg.at
     });
     const settledRetry = { ...s, compaction };
@@ -1300,15 +1332,17 @@ function createAgent(config) {
     return [fired, [...retryCmds, ...llmCmds]];
   }
   function compactErr(s, key, msg, at) {
-    const [compaction, cmds] = compact.fail(s.compaction, key, {
-      type: MsgType.ResilientErr,
-      key: msg.key,
+    const {
+      call: compaction,
+      cmds,
+      outcome
+    } = compact.settle(s.compaction, {
+      cmd: { key },
       error: msg.error,
       at: msg.at
     });
     const settledRetry = { ...s, compaction };
-    const call = compaction.calls[key];
-    if (call?.phase === "waiting_retry") {
+    if (outcome.kind === "retrying") {
       return [settledRetry, cmds];
     }
     const conv = requireAwaiting(settledRetry, "compacting");
@@ -1379,17 +1413,14 @@ function createAgent(config) {
   }
   function subs(s) {
     return [
-      ...llm.subs(s.resilience),
-      ...compactRc.subs(s.compaction),
+      ...llm.deadlines(s.resilience),
+      ...compactRc.deadlines(s.compaction),
       ...ladder.subs(toolSlice(s)),
-      ...run2.subs(s.run)
+      ...run2.deadlines(s.run)
     ];
   }
-  function unsafeDetachedHandlers(ports) {
-    return llm.handlers(ports);
-  }
   function brainHandlers() {
-    return llm.handlers();
+    return { resilient_run: invokeBrain };
   }
   function toMachine(opts) {
     const tools = opts?.tools;
@@ -1416,10 +1447,10 @@ function createAgent(config) {
       // shape is a bare `reason` string — a consumer routing their own interpret
       // through it never declared a tag, so the failure it mints carries none.
       [MsgType.AgentToolErr]: (s, m) => toolErr(s, m.callId, m.reason, m.at),
-      // The re-entered brain-call settle Msgs (from `brainHandlers`): success
-      // runs `succeed` (reset retry + fold the turn), failure runs `fail`.
-      [MsgType.ResilientOk]: (s, m) => succeed(s, m.key, m, m.at),
-      [MsgType.ResilientErr]: (s, m) => fail(s, m.key, m, m.at),
+      // The engine-minted brain-call settle Msgs (from `brainHandlers`' outcome):
+      // success runs `succeed` (reset retry + fold the turn), failure runs `fail`.
+      [MsgType.ResilientOk]: (s, m) => succeed(s, m, m.at),
+      [MsgType.ResilientErr]: (s, m) => fail(s, m, m.at),
       // The re-entered compaction settle Msgs (from the consumer's `compact_run`
       // cell, #85): `compact_ok` folds the summary back (drop oldest turns +
       // their records, fire the next brain call), `compact_err` backs off via the
@@ -1434,12 +1465,17 @@ function createAgent(config) {
     const machine = {
       init: (loaded) => loaded !== null ? [loaded, []] : [init(), []],
       update,
-      subscriptions: (s) => subs(s),
-      subscribe: { deadline: subscribeDeadline },
+      subs: [deadlinesSub(subs)],
+      // The brain run Cmd is `Cmd.define`d: listing it is what makes the
+      // engine mint `resilient_run_ok` / `resilient_run_err` from the brain
+      // handler's outcome. The router's defs ride beside it.
+      cmds: [llm.run, ...tools?.defs ?? []]
+    };
+    return {
+      machine: defineMachine(machine),
       interpret,
-      ...tools !== void 0 ? { cmds: tools.defs } : {}
+      subscribe: { deadline: subscribeDeadline }
     };
-    return defineMachine(machine);
   }
   return {
     init,
@@ -1457,14 +1493,14 @@ function createAgent(config) {
     currentStage,
     brainCall,
     subs,
-    // `toMachine` is THE wired path. `unsafeDetachedHandlers` is the
-    // hand-wiring escape hatch — named to advertise the retry-loop gap so it is
-    // never mistaken for the loop driver (#54).
+    // `toMachine` is THE wired path; `brainInterpret` / `brain` are the two
+    // pieces a consumer wiring the verbs by hand needs.
     toMachine,
-    unsafeDetachedHandlers
+    brainInterpret: brainHandlers,
+    brain: llm.run
   };
 }
 
 export { COMPACTION_PURPOSE, PLAIN_MODEL_MISROUTE_REASON, TOOL_RETRY_EXHAUSTED_TAG, TOOL_TIMEOUT_TAG, agentBootMsg, agentCancelMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, defineAgent, fanOutInterpret, isAgentTurn, isCompactionSummary, isReservedToolName, isStreamingModel, liftAgent, mergeInterpret, plainModel, renderPrompt, status, tool, toolErrorReason, toolRouter, transcript };
-//# sourceMappingURL=chunk-Z2L3LSNV.js.map
-//# sourceMappingURL=chunk-Z2L3LSNV.js.map
+//# sourceMappingURL=chunk-EHUDXAKC.js.map
+//# sourceMappingURL=chunk-EHUDXAKC.js.map