@jr2/orchestrator 0.4.1 → 0.6.0

package/src/setup.ts

@@ -29,6 +29,7 @@ import { randomUUID } from "node:crypto";
 import {
   setup,
   type ActionFunction,
+  type ActorLogic,
   type AnyActorRef,
   type AnyStateMachine,
   type DelayConfig,
@@ -39,6 +40,7 @@ import {
   type NonReducibleUnknown,
   type ParameterizedObject,
   type SetupReturn,
+  type Snapshot,
   type UnknownActorLogic,
 } from "xstate";
 import type { z } from "zod";
@@ -46,38 +48,65 @@ import { eventMap, type EventDef, type EventFrom, type Sender } from "@jr2/agent
 import type { AgentRunInput, AgentTurnInput, FaultTelemetry } from "./actor.ts";
 import { isAgent } from "./agent.ts";
 import { isEffect } from "./effect.ts";
-import { effectChecks } from "./effect-checks.ts";
+import type { AnyFramePath, FramePath, WorktreePath, WorktreeReady } from "./worktree.ts";
+import { effectChecks, refuseUnroutedOutcome } from "./effect-checks.ts";
 import { gate } from "./gate.ts";
 import { attachLent, isOpenBody, openBodyDeclarationOf, type LentParts } from "./open-body.ts";
 import { refuseInlineParts } from "./parts.ts";
-import { partyWarnings, refuseUnknownSentBy, SENT_BY, sentByGuard } from "./party.ts";
+import { partyWarnings, refuseSlotActiveTwice, refuseUnknownSentBy, SENT_BY, sentByGuard } from "./party.ts";
+import { refuseLostOutput } from "./run-output.ts";
+import { refuseUnroutedAgentFault } from "./mechanism-routes.ts";
 import { boundEpoch, boundRunId, continuedIid } from "./registration.ts";
 import { attachInputSchema, attachLoadWarnings, attachSeats, attachVocabulary } from "./vocabulary.ts";
 
 /**
- * The events jr2's own mechanism delivers into any workflow machine, injected into every jr2Setup
- * union. Dotted names by construction (`NAME_RE` forbids dots in workflow event names), so they
- * can never collide with a def.
+ * The marker that `compileChart` puts on the config of a Chart's Machine (ADR-0070). In a Chart the
+ * `agent.fault` route is optional: the Open body sends an `agent.fault` that no transition takes to
+ * the Machine that invoked it, so `createMachine` does not refuse a Chart state with no route. Not on the Authoring
+ * surface (index.ts). The load walk (`partsOf`) refuses an author's Machine with no route, with or
+ * without the marker (ADR-0074).
  */
+export const COMPILED_CHART: unique symbol = Symbol("jr2.compiledChart");
+
+// Injected into every jr2Setup union. Dotted names by construction (`NAME_RE` forbids dots in
+// workflow event names), so they can never collide with a def.
+/** The events that jr2 itself sends into each Machine that `jr2Setup` makes. A Mechanism event's
+ * name has a dot, and a workflow event's name cannot, so the two never collide. */
 export type MechanismEvent = FaultTelemetry | WorkspaceLost;
 
+// A Workspace's Continuity broke (ADR-0021): its Sandbox is gone, or Lost. `reason` and `message`
+// are for a body whose policy tells the causes apart, or only reports them; no policy needs them.
 /**
- * A Workspace's Continuity broke (ADR-0021): its Sandbox is gone, or Lost. `reason` and `message`
- * say why — the pod's own reason (`Evicted`, `NodeShutdown`, ...) or the operator's (`PodDeleted`,
- * `NodeLost`), or `Deleted` for a Sandbox that is gone — for a body whose policy tells them apart,
- * or only reports them. Optional: the body's policy never needs them to act.
+ * jr2 sends `workspace.lost` to the body of a `workspace()` when its Sandbox is gone: its pod was
+ * evicted or deleted, or its node went. jr2 does not make the Sandbox again, and the commits that
+ * were not pushed go with it. The body decides what to do next: route the event with
+ * `on: { "workspace.lost": … }`, usually once, on the body's root. `workspace()` refuses a body
+ * with a state that is not final and has no route for it on itself or on a state above. When the
+ * event comes and no transition takes it (the route's guard is false), the run ends `error`, with
+ * the event, the state and the reason in its fault.
  */
-export type WorkspaceLost = { type: "workspace.lost"; reason?: string; message?: string };
+export type WorkspaceLost = {
+  type: "workspace.lost";
+  /** Why the Sandbox is gone, for a person or a log: the pod's reason (`Evicted`, `NodeShutdown`),
+   * the operator's (`PodDeleted`, `NodeLost`), or `Deleted`. A body can act without it. */
+  reason?: string;
+  /** More text about the loss, when jr2 has it. */
+  message?: string;
+};
 
-/** The full event union a jr2Setup machine sees: the defs' derived types plus the mechanism's. A
- * workflow event a party delivered carries its `sender` (ADR-0015); the Machine's own events
- * (`raise`, `sendTo` itself) carry none. */
+// The defs' derived types plus the mechanism's (ADR-0015).
+/** The type of `event` in a Machine that `jr2Setup` makes: each workflow event in its `events`,
+ * and each Mechanism event. A workflow event that an Agent or a Gate sent has `event.sender`. An
+ * event that the Machine sent to itself (`raise`, `sendTo`) has no `sender`. */
 export type WorkflowEvent<TDefs extends readonly EventDef[]> =
   | (EventFrom<TDefs[number]> & { readonly sender?: Sender })
   | MechanismEvent;
 
 /** The guard jr2Setup registers for every Machine — `sentBy(id)` (ADR-0015) — in the typed guard
- * map, so `sentBy("coder")` and `and([sentBy("coder"), "ready"])` type-check with no cast. */
+ * map, so `sentBy("coder")` and `and([sentBy("coder"), "ready"])` type-check with no cast.
+ *
+ * @internal
+ */
 type SentByGuards = { [SENT_BY]: { id: string } };
 
 /** The jr2 actor every workflow can invoke by name without listing it (ADR-0015). `gate` is the
@@ -86,25 +115,222 @@ type SentByGuards = { [SENT_BY]: { id: string } };
 const jr2Actors = { gate };
 type JR2Actors = typeof jr2Actors;
 
-/** Consumer actors merge OVER the pre-registered set: same name → the consumer's logic wins. */
+/**
+ * Consumer actors merge OVER the pre-registered set: same name → the consumer's logic wins.
+ *
+ * @internal
+ */
 type MergedActors<TActors extends Record<string, UnknownActorLogic>> = Omit<JR2Actors, keyof TActors> & TActors;
 
 // Local equivalents of xstate's non-exported setup() mapped helpers (setup.d.ts) — same shapes,
 // so the declared signature below composes with the public `ActionFunction`/`GuardPredicate`.
+/** @internal */
 type ToParameterizedObject<T extends Record<string, ParameterizedObject["params"] | undefined>> = {
   [K in keyof T & string]: { type: K; params: T[K] };
 }[keyof T & string];
+/** @internal */
 type ToProvidedActor<TActors extends Record<string, UnknownActorLogic>> = {
   [K in keyof TActors & string]: { src: K; logic: TActors[K]; id: string | undefined };
 }[keyof TActors & string];
 
+// The types below carry the body's Repo Slots to every Worktree input.
+/** @internal */
+type NoHandles = { readonly noHandles: true };
+/** `S`, the slots of the body, or {@link NoHandles} when its input and context hold no handles.
+ * @internal */
+type RepoSlotsOf<TInput, TContext> = TInput extends { workspace: { repos: infer R } }
+  ? keyof R & string
+  : TContext extends { workspace: { repos: infer R } }
+    ? keyof R & string
+    : NoHandles;
+/** The Worktrees of the slots `S` that this key takes: a `push({ slot })` keeps to its own slot.
+ * @internal */
+type PathIn<W, S> = S extends string ? (`/work/${S}/x` extends NonNullable<W> ? WorktreePath<S> : never) : never;
+/** One arm of an input. A key that names a Worktree or a Frame is REQUIRED under a body with Repo
+ * Slots, so that no mix of `cwd`, `worktree` and `path` lands in `/work`. Under a body with none,
+ * `worktree` goes: there is no Worktree. A Turn's arm that carries no kit path (the run's own form)
+ * and every other key stay.
+ * @internal */
+type BindArm<I, S> = I extends object
+  ? "worktree" extends keyof I
+    ? [S] extends [never]
+      ? Omit<I, "worktree"> & { worktree?: never }
+      : Omit<I, "worktree"> & { worktree: PathIn<I["worktree"], S> }
+    : "cwd" extends keyof I
+      ? [NonNullable<I["cwd"]>] extends [AnyFramePath]
+        ? [S] extends [never]
+          ? I
+          : Omit<I, "cwd"> & { cwd: FramePath<S & string> }
+        : I
+      : "path" extends keyof I
+        ? [S] extends [never]
+          ? I
+          : Omit<I, "path"> & { path: PathIn<I["path"], S> }
+        : I
+  : I;
+/** Does this input name a Worktree? @internal */
+type NamesWorktree<I> = I extends object ? ("worktree" extends keyof I ? true : never) : never;
+/** @internal */
+type BindInput<I, S> = [NamesWorktree<I>] extends [never]
+  ? BindArm<I, S>
+  : [S] extends [never]
+    ? BindArm<I, S>
+    : Exclude<BindArm<I, S>, void | undefined>;
+/** A cut's `ready` output with the body's slots. @internal */
+type BindOutput<O, S> = O extends WorktreeReady ? WorktreeReady<S & string> : O;
+/** @internal */
+type BindSnapshot<Snap, S> = Snap extends { output: infer O }
+  ? [O] extends [BindOutput<O, S>]
+    ? Snap
+    : Omit<Snap, "output"> & { output: BindOutput<O, S> }
+  : Snap;
+/** @internal */
+type BindLogic<L extends UnknownActorLogic, S> = L extends AnyStateMachine
+  ? L
+  : ([S] extends [never] ? false : [S] extends [NoHandles] ? true : false) extends true
+    ? L
+    : L extends { readonly definition: { readonly workspace: "none" } }
+      ? L
+      : L extends ActorLogic<infer Snap, infer Ev, infer I, infer Sys, infer Em>
+        ? BindSnapshot<Snap, S> extends infer B extends Snapshot<unknown>
+          ? Omit<L, keyof ActorLogic<Snap, Ev, I, Sys, Em>> & ActorLogic<B, Ev, BindInput<I, S>, any, Em>
+          : never
+        : L;
+/** @internal */
+type BindActors<A extends Record<string, UnknownActorLogic>, TInput, TContext> = {
+  [K in keyof A]: BindLogic<A[K], RepoSlotsOf<TInput, TContext>>;
+};
+
 /**
- * Author a workflow machine (ADR-0015). Like `setup()`, but `types.events` is gone: the event
- * union derives from `events` (defineEvent defs, taken as values) plus the mechanism events.
+ * Set up a Machine that takes workflow events: the jr2 form of xstate's `setup()`. Write a Machine
+ * with it when an Agent or a Gate sends events into the Machine, or when the Machine declares a
+ * door. Call `.createMachine(config)` on the result, as with `setup()`. The Machine you get is a
+ * plain xstate Machine.
+ *
+ * What it adds to `setup()`:
+ * - `events` replaces `types.events`. The event type of the Machine comes from the
+ *   `defineEvent` events you list, plus the events jr2 itself sends (`agent.fault`,
+ *   `workspace.lost`). An event that a party sent has `event.sender`. A Machine that takes no
+ *   workflow event leaves out `events`.
+ * - The `gate` actor is ready to invoke by name: `invoke: { src: "gate" }`.
+ * - Each Agent slot (`actors: { coder: agent(…) }`) gets its Menu from the states that invoke it.
+ * - The `sentBy(id)` guard is ready to use.
+ * - `createMachine` also takes `input`: a zod object for the input that starts a run. jr2 checks
+ *   each start against it. Without it, a run can start with any input. The `setup()` of xstate
+ *   does not read this `input`, so a Machine with a door uses `jr2Setup`, also when it takes no
+ *   workflow event. `jr2 up` and the publish door refuse a registered Machine that has a zod
+ *   `input` if `jr2Setup` did not make the Machine: ``workflow "<name>": machine "<id>" has a zod `input` on
+ *   createMachine, but jr2Setup did not make this Machine, so no door reads that input …``
+ *
+ * The output of a run is the root `output` of `createMachine`, beside `id` and `states`, as in
+ * xstate v5. xstate does not read the `output` of a final state as the output of the Machine. It
+ * gives that output to the root `output` as `event.output`. Write
+ * `output: ({ event }) => event.output as Output` at the root, or make the output from `context`
+ * there. `createMachine` refuses an `output` on a final state directly below the root when the root
+ * has no `output` (see the list below).
+ *
+ * `createMachine` refuses a Machine that it cannot run as written. Among the refusals:
+ * - an `on` key that no listed event has: ``machine "<id>" handles event "<key>", which no def in
+ *   jr2Setup({ events }) declares (declared: <names>) — a typo, or a missing defineEvent``
+ * - a listed event that no state takes: ``machine "<id>" declares "<name>", which no state handles
+ *   — a pick no state takes is on no Menu and no Gate: handle it, or drop it from
+ *   jr2Setup({ events })``
+ * - an entry of `events` that `defineEvent` did not make, or one name listed twice:
+ *   ``machine "<id>": `events` entry is not a defineEvent() def: <entry>``,
+ *   ``machine "<id>": duplicate event "<name>" in `events` ``
+ * - an `agent()`, an Effect or a `workspace()` written on `invoke.src` instead of under `actors`:
+ *   ``machine "<id>": state "<state>" invokes <part> inline — a Part is a key of actors, so it has
+ *   a name that the ledger, the report and customize() share: actors: { <name>: <factory>(...) },
+ *   then invoke: { src: "<name>" }``. `<part>` is `an Agent`, `an Effect` or `a Workspace`.
+ *   `<factory>` is `agent`, the Effect's kind (such as `command`), or `workspace`.
+ * - an `output` on a final state directly below the root, when the root has no `output`:
+ *   ``machine "<id>": final state "<state>" declares an output, and the root has no output — xstate
+ *   v5 gives a run only its root output, so this output reaches nothing and the run ends with none:
+ *   write it at the root, as output: ({ context }) => ..., or keep it on the final state and pass it
+ *   on with output: ({ event }) => event.output at the root``. With more than one such final state,
+ *   it names each one and puts the words in the plural: ``final states "<state>", "<state>"
+ *   declare an output``, ``these outputs reach nothing``, ``write one at the root`` and ``keep
+ *   them on the final states and pass them on``. An `output` on a
+ *   final state inside a compound state is legal: the `onDone` of that compound state gets it as
+ *   `event.output`.
+ * - a parallel state at or below a state that invokes an Agent: ``machine "<id>": state "<state>"
+ *   is parallel, at or below Agent "<slot>"'s state "<state>" — a parallel region below an Agent's
+ *   state is reserved for picks the Agent does not wait for, which jr2 does not build; background
+ *   work goes above the Agent's state``
+ * - a state below an Agent's state that invokes something and that nothing enters: ``machine
+ *   "<id>": state "<state>" below Agent "<slot>"'s state "<state>" is entered by nothing, so what
+ *   it invokes (<src>) never runs — target it from a pick or a route, or delete it``
+ * - a state that invokes an Agent when that state and each state above it have no `agent.fault`
+ *   route: ``machine "<id>": state "<state>" invokes an Agent, and no route for "agent.fault" is
+ *   on it or on a state above — jr2 sends agent.fault when the Agent's Turn cannot go on, and with
+ *   no route the run faults: route it on that state or on a state above it, as on: {
+ *   "agent.fault": "<the state that handles it>" } (ADR-0074)``. A state that invokes an Open body
+ *   that lends an Agent or allows a model gets the same line, with `invokes an Open body that can
+ *   run an Agent`: the body sends it a Chart's unrouted `agent.fault`. When both kinds have no route,
+ *   one line names both, joined by `, and`. One route on the root is a route for each state. A
+ *   Chart's Machine does not get this refusal: in a Chart the route is optional (ADR-0070).
+ *
+ * It also refuses a `sentBy` that names no party (see `sentBy`). It refuses a pick param that
+ * nothing reads, where the pick enters a state that invokes an Effect (see `fromPick`). Shapes that
+ * are legal but probably not what you mean, such as a mode that nothing enters, are warnings that
+ * `jr2 up` prints.
+ *
+ * @param def - What `setup()` takes, with `events` in place of `types.events`. A Machine that
+ *   needs none of it calls `jr2Setup()`.
+ * @returns What `setup()` returns. Call `.createMachine(config)` on it.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { agent, defineEvent, fail, jr2Setup } from "@jr2/orchestrator";
+ *
+ * const proposed = defineEvent({
+ *   name: "proposed",
+ *   description: "Call this with your plan.",
+ *   input: z.object({ plan: z.string() }),
+ * });
+ * const approve = defineEvent({ name: "approve", input: z.object({}) });
+ * const reject = defineEvent({ name: "reject", input: z.object({ reason: z.string() }) });
+ *
+ * export const machine = jr2Setup({
+ *   types: {} as { input: { goal: string }; context: { goal: string } },
+ *   events: [proposed, approve, reject],
+ *   actors: {
+ *     planner: agent({
+ *       model: "anthropic/claude-haiku-5-5",
+ *       instructions: "You plan small releases.",
+ *       workspace: "none",
+ *     }),
+ *     fail: fail(),
+ *   },
+ * }).createMachine({
+ *   id: "plan",
+ *   input: z.object({ goal: z.string() }),
+ *   context: ({ input }) => ({ goal: input.goal }),
+ *   on: { "agent.fault": ".failed" },
+ *   initial: "planning",
+ *   states: {
+ *     planning: {
+ *       invoke: { src: "planner", input: ({ context }) => ({ prompt: `Plan this: ${context.goal}` }) },
+ *       on: { proposed: "review" },
+ *     },
+ *     review: {
+ *       invoke: { src: "gate" },
+ *       on: { approve: "approved", reject: "planning" },
+ *     },
+ *     approved: { type: "final" },
+ *     failed: { invoke: { src: "fail", input: { reason: "the Agent's Turn could not go on" } } },
+ *   },
+ * });
+ * ```
+ *
+ * @see docs/guides/write-a-workflow.md
+ * @see docs/concepts/machines-and-workflows.md
+ * @see docs/reference/decisions/0015-authoring-surface-absorbs-the-mechanism.md
  */
 export function jr2Setup<
   TContext extends MachineContext = MachineContext,
-  const TDefs extends readonly EventDef[] = readonly EventDef[],
+  const TDefs extends readonly EventDef[] = readonly [],
   TActors extends Record<string, UnknownActorLogic> = {},
   TActions extends Record<string, ParameterizedObject["params"] | undefined> = {},
   TGuards extends Record<string, ParameterizedObject["params"] | undefined> = {},
@@ -114,47 +340,59 @@ export function jr2Setup<
   TOutput extends NonReducibleUnknown = NonReducibleUnknown,
   TEmitted extends EventObject = EventObject,
   TMeta extends MetaObject = MetaObject,
->(def: {
-  /** context/input/output/tags/emitted/meta — never `events`; the union is derived. */
-  types?: {
-    context?: TContext;
-    input?: TInput;
-    output?: TOutput;
-    tags?: TTag;
-    emitted?: TEmitted;
-    meta?: TMeta;
-  };
-  /** This Machine's vocabulary, as values — the single source for types, validation, delivery. */
-  events: TDefs;
-  actors?: TActors;
-  actions?: {
-    [K in keyof TActions]: ActionFunction<
-      TContext,
-      WorkflowEvent<TDefs>,
-      WorkflowEvent<TDefs>,
-      TActions[K],
-      ToProvidedActor<MergedActors<TActors>>,
-      ToParameterizedObject<TActions>,
-      ToParameterizedObject<TGuards>,
-      TDelay,
-      TEmitted
-    >;
-  };
-  guards?: {
-    [K in keyof TGuards]: GuardPredicate<TContext, WorkflowEvent<TDefs>, TGuards[K], ToParameterizedObject<TGuards>>;
-  };
-  delays?: {
-    [K in TDelay]: DelayConfig<
-      TContext,
-      WorkflowEvent<TDefs>,
-      ToParameterizedObject<TActions>["params"],
-      WorkflowEvent<TDefs>
-    >;
-  };
-}): SetupReturn<
+>(
+  def: {
+    /** The types of the Machine, as in `setup()`: `context`, `input`, `output`, `tags`, `emitted`
+     * and `meta`. Not `events`: the event type comes from `events`. */
+    types?: {
+      context?: TContext;
+      input?: TInput;
+      output?: TOutput;
+      tags?: TTag;
+      emitted?: TEmitted;
+      meta?: TMeta;
+    };
+    // The single source for types, validation and delivery.
+    /** The workflow events this Machine takes: each one made by `defineEvent`. Leave it out when the
+     * Machine takes none. Each listed event must be the name of an `on` key. Each `on` key must be
+     * listed, if it is not a jr2 or xstate event (an event with a `.` in its name). */
+    events?: TDefs;
+    /** The actors the states invoke by name, as in `setup()`: Agent slots (`agent(…)`), Effects
+     * (`command(…)`, `http(…)`, `push(…)`), child Machines, `workspace(…)` and plain xstate logic.
+     * The key is the slot's name. An actor named `gate` replaces jr2's Gate. */
+    actors?: TActors;
+    /** Named actions, as in `setup()`. Their `event` has the type of this Machine's events. */
+    actions?: {
+      [K in keyof TActions]: ActionFunction<
+        TContext,
+        WorkflowEvent<TDefs>,
+        WorkflowEvent<TDefs>,
+        TActions[K],
+        ToProvidedActor<MergedActors<TActors>>,
+        ToParameterizedObject<TActions>,
+        ToParameterizedObject<TGuards>,
+        TDelay,
+        TEmitted
+      >;
+    };
+    /** Named guards, as in `setup()`. `sentBy` is there already; do not name a guard `jr2.sentBy`. */
+    guards?: {
+      [K in keyof TGuards]: GuardPredicate<TContext, WorkflowEvent<TDefs>, TGuards[K], ToParameterizedObject<TGuards>>;
+    };
+    /** Named delays, as in `setup()`. */
+    delays?: {
+      [K in TDelay]: DelayConfig<
+        TContext,
+        WorkflowEvent<TDefs>,
+        ToParameterizedObject<TActions>["params"],
+        WorkflowEvent<TDefs>
+      >;
+    };
+  } = {},
+): SetupReturn<
   TContext,
   WorkflowEvent<TDefs>,
-  MergedActors<TActors>,
+  MergedActors<BindActors<TActors, TInput, TContext>>,
   {},
   TActions,
   TGuards & SentByGuards,
@@ -165,6 +403,8 @@ export function jr2Setup<
   TEmitted,
   TMeta
 > {
+  // Like `setup()`, but `types.events` is gone (ADR-0015): the event union derives from `events`
+  // (defineEvent defs, taken as values) plus the mechanism events.
   const inner = setup({
     types: def.types,
     actors: { ...jr2Actors, ...(def.actors ?? {}) },
@@ -179,11 +419,16 @@ export function jr2Setup<
     // machine receives at creation — and is pulled OFF before xstate sees it: a zod schema is
     // not machine structure, and it must never reach the fingerprint/serialization paths that
     // read `machine.config`. It is attached beside the vocabulary below.
-    const { input: inputSchema, ...machineConfig } = config as { input?: z.ZodObject } & Record<string, unknown>;
+    // A compiled Chart (ADR-0070) is marked, and the marker is pulled off as `input` is.
+    const {
+      input: inputSchema,
+      [COMPILED_CHART]: compiledChart,
+      ...machineConfig
+    } = config as { input?: z.ZodObject; [COMPILED_CHART]?: true } & Record<string, unknown>;
 
     // Resolve the defs first (duplicates and reserved semantics fail HERE, naming the machine —
     // the same loud failure `eventMap` gave the manifest, moved to machine-build time)…
-    const defs = eventMap((machineConfig as { id?: string }).id ?? "(machine)", def.events);
+    const defs = eventMap((machineConfig as { id?: string }).id ?? "(machine)", def.events ?? []);
 
     // Every Open body slot (ADR-0070), found by its brand: each name it lends resolves against THIS
     // setup's own parts, or the Machine is refused naming it. The resolved set is stamped on the slot,
@@ -231,13 +476,26 @@ export function jr2Setup<
 
     // A Part written inline has no name (ADR-0049, ADR-0067): refused, with the slot form.
     refuseInlineParts(machine);
+    // A final state's output with no root output (ADR-0015): the run would end with none.
+    refuseLostOutput(machine);
+    // A state that invokes an Agent, or an Open body that can run one, with no `agent.fault` route
+    // (ADR-0074): the run would wait for ever. Not in a compiled Chart: there the route is optional,
+    // and the Open body sends the event that no transition takes to the Machine that invoked it (ADR-0070).
+    if (compiledChart !== true) refuseUnroutedAgentFault(machine);
+    // An Effect's `onDone` with no last arm that always matches (ADR-0075): the run would stay in the
+    // state and show no fault. A compiled Chart comes here too, so the door refuses it.
+    refuseUnroutedOutcome(machine);
     refuseParallelBelowAgents(machine, def.actors ?? {});
+    // One slot, two Turns at once (ADR-0015): one sender and one conversation cannot hold both.
+    refuseSlotActiveTwice(machine);
     refuseUnknownSentBy(machine);
     // Before the Effect checks: they ask who may send a writing (`mayTake`), which reads its audience.
     attachVocabulary(machine, defs);
     // The Effect checks (ADR-0067): a pick param nothing reads, a `fill` that overwrites one, a
     // `fromPick` of another pick — refused; a mapper the probe cannot run — warned.
-    const effects = effectChecks(machine, def.actors ?? {}, defs);
+    // A Chart's door reads each reference itself (rule 7), and it refuses every load warning: the
+    // walk's "I could not run this" says nothing of a Chart's `{{...}}` mapper or its `set`.
+    const effects = effectChecks(machine, def.actors ?? {}, defs, compiledChart === true);
     if (effects.errors.length) throw new Error(`machine "${machine.id}": ${effects.errors.join("; ")}`);
 
     const idOf = (path: readonly string[]): string => stateAt(machine, path).id;
@@ -261,7 +519,7 @@ export function jr2Setup<
   return { ...inner, createMachine } as unknown as SetupReturn<
     TContext,
     WorkflowEvent<TDefs>,
-    MergedActors<TActors>,
+    MergedActors<BindActors<TActors, TInput, TContext>>,
     {},
     TActions,
     TGuards & SentByGuards,
@@ -886,7 +1144,7 @@ function refuseUnknownKeys(consumer: object, agentName: string): void {
 /** Wrap an Agent slot's invoke input: name the Agent (the slot key), append the state's derived set
  * and the Agent's Menu, and finalize the mechanism fields. */
 function wrapAgentInput(orig: unknown, derived: string[], agentName: string, menuOf: (agentName: string) => string[]) {
-  return (args: InputArgs): AgentRunInput => {
+  const wrapped = (args: InputArgs): AgentRunInput => {
     const consumer = resolveInput(orig, args) as Partial<AgentTurnInput & AgentRunInput>;
     refuseUnknownKeys(consumer, agentName);
     return {
@@ -894,6 +1152,9 @@ function wrapAgentInput(orig: unknown, derived: string[], agentName: string, men
       // jr2 mints every id (ADR-0016, ADR-0057): the Turn's input carries no id to honor, so
       // nothing a Machine writes can address a conversation jr2 did not derive.
       instanceId: mintIid(consumer, agentName, args.self),
+      // One per invocation (ADR-0016): two Turns that continue one conversation share the iid, the
+      // admission ledger's key, and a restore must not re-attach one Turn to the other's admission.
+      turnId: randomUUID(),
       endpoint: consumer.endpoint,
       sandbox: consumer.sandbox,
       prompt: consumer.prompt,
@@ -914,6 +1175,8 @@ function wrapAgentInput(orig: unknown, derived: string[], agentName: string, men
       menu: menuOf(agentName),
     };
   };
+  // The walk reads what the author wrote: `workspace()`, for a literal `cwd`.
+  return Object.assign(wrapped, { consumerInput: orig });
 }
 
 /** Wrap a gate invoke input: append the derived accepted set. */