@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/workflows/record.d.ts

@@ -0,0 +1,2863 @@
+import { z } from 'zod';
+import type { ToolResult } from '../../models/index.js';
+import { JsonValueSchema, type DeepReadonly } from '../../util/json.js';
+import type { CanonicalDefinition, WorkflowDefinition } from './definition.js';
+/**
+ * The constraint owner a workflow's root requires (`requires` in its creation): the root is held
+ * until this plugin is mounted and has repaired what a crash left, so nothing runs it without the
+ * workflow's authority, and no follow-up a crash missed is skipped.
+ */
+export declare const WORKFLOWS_OWNER = "lagent:workflows";
+/** Whether a thread was created as a workflow's root: what every reader of its instance checks first. */
+export declare const requiresWorkflows: (summary: {
+    readonly requires: readonly string[];
+}) => boolean;
+/** The one protocol tool: its result, concluding the turn, is a candidate answer for an assignment. */
+export declare const SUBMIT_TOOL = "submit_workflow_output";
+/**
+ * What an input of an attempt was bound to at entry: the instance's input, one accepted result
+ * revision (one participant's output in it, or the whole result) with the decision it carried then,
+ * or evidence a provider acquired, whose value the entry records beside it. `null` in its place is
+ * an optional binding with nothing to bind.
+ */
+declare const CitationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"input">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"evidence">;
+    provider: z.ZodString;
+    immutable: z.ZodBoolean;
+    detail: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"result">;
+    result: z.ZodString;
+    participant: z.ZodNullable<z.ZodString>;
+    decision: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        current: "current";
+        historical: "historical";
+    }>;
+}, z.core.$strict>], "kind">;
+export type Citation = z.output<typeof CitationSchema>;
+/** A citation as a public result hands it out: a copy, since the recorded one is the fold's. */
+export declare const copyCitation: (citation: DeepReadonly<Citation> | null) => Citation | null;
+/**
+ * What an instance runs on besides its definition, resolved and pinned at its opening: each
+ * participant's configuration, `null` for the conversation participant, which runs on the
+ * conversation's own, and complete for an isolated one (agent, route, environment and defining
+ * installations, exactly as its conversation is created on them); each check provider's pin, by
+ * the participant whose assignments list it; and each evidence provider's pin.
+ */
+declare const PinsSchema: z.ZodObject<{
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        configuration: z.ZodNullable<z.ZodObject<{
+            agent: z.ZodString;
+            route: z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                thinking_effort: z.ZodNullable<z.ZodEnum<{
+                    low: "low";
+                    high: "high";
+                    none: "none";
+                    medium: "medium";
+                    max: "max";
+                }>>;
+            }, z.core.$strip>;
+            environment: z.ZodObject<{
+                cwd: z.ZodString;
+                read_roots: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            installations: z.ZodArray<z.ZodObject<{
+                installation_id: z.ZodString;
+                preset_id: z.ZodString;
+                config: z.ZodJSONSchema;
+                lifetime: z.ZodEnum<{
+                    defining: "defining";
+                    configurable: "configurable";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        checks: z.ZodRecord<z.ZodString, z.ZodObject<{
+            config: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    evidence: z.ZodRecord<z.ZodString, z.ZodObject<{
+        config: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Pins = z.output<typeof PinsSchema>;
+export type ParticipantPin = Pins['participants'][string];
+/**
+ * One assignment an entry opens, by where it runs. The conversation participant's runs on the root
+ * and is activated by the claim of a root input: the host's first, or its transition's scheduling
+ * input. An isolated participant's runs as one delegation task on its child, on the participant
+ * generation it was pinned to; its activation is that task's input, whose id is the task's. What
+ * the entry records of it (child, lifetime, generation, checks) is its contract while it is open:
+ * an edit of the definition to those applies from the next entry.
+ */
+declare const AssignmentEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    context: z.ZodLiteral<"conversation">;
+    id: z.ZodString;
+    participant: z.ZodString;
+    activation: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    context: z.ZodLiteral<"isolated">;
+    id: z.ZodString;
+    participant: z.ZodString;
+    thread: z.ZodString;
+    task: z.ZodString;
+    generation: z.ZodNumber;
+    lifetime: z.ZodEnum<{
+        attempt: "attempt";
+        instance: "instance";
+    }>;
+    checks: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "context">;
+export type AssignmentEntry = z.output<typeof AssignmentEntrySchema>;
+/**
+ * What an isolated participant's child shows of one task: it `accepted` a submission (the child's
+ * `tool/result` row) at a completed ending (its `turn/end` row), carrying the submitted output; or
+ * it `ended` without that, as delegations settled the task (failed, stopped, or completed with a
+ * reply that submitted nothing), with what delegations says of it, the task's latest submission,
+ * and its latest prose as a partial report, both unaccepted; or, beside a sibling that ended, it is
+ * still `unfinished`, with its latest submission and prose as of then, unaccepted too. Or the task
+ * was never opened: delegations `refused` its start for good, for this child as asked (a
+ * conversation it will not continue, say), which ends the assignment as an ending does.
+ */
+declare const ObservedOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"accepted">;
+    submission: z.ZodNumber;
+    ending: z.ZodNumber;
+    output: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ended">;
+    settlement: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        stopped: "stopped";
+    }>;
+    detail: z.ZodString;
+    candidate: z.ZodNullable<z.ZodObject<{
+        submission: z.ZodNumber;
+        output: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    report: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    detail: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unfinished">;
+    candidate: z.ZodNullable<z.ZodObject<{
+        submission: z.ZodNumber;
+        output: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    report: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ObservedOutcome = z.output<typeof ObservedOutcomeSchema>;
+/** One task's facts as an observation carries them: the assignment, and the child, task and generation they are from. */
+declare const ObservationSchema: z.ZodObject<{
+    assignment: z.ZodString;
+    thread: z.ZodString;
+    task: z.ZodString;
+    generation: z.ZodNumber;
+    outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"accepted">;
+        submission: z.ZodNumber;
+        ending: z.ZodNumber;
+        output: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"ended">;
+        settlement: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            stopped: "stopped";
+        }>;
+        detail: z.ZodString;
+        candidate: z.ZodNullable<z.ZodObject<{
+            submission: z.ZodNumber;
+            output: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+        report: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"refused">;
+        detail: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unfinished">;
+        candidate: z.ZodNullable<z.ZodObject<{
+            submission: z.ZodNumber;
+            output: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+        report: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type Observation = z.output<typeof ObservationSchema>;
+/** What made a transition: the opening, an accepted result routed automatically, or a host decision. */
+declare const CauseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"opening">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"routed">;
+    result: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"decision">;
+    decision: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type TransitionCause = z.output<typeof CauseSchema>;
+/**
+ * What the journal keeps of a workflow instance, on its root thread, as `ext` rows of this plugin.
+ * Everything else is derived from these and core's rows: activation from the claim of an
+ * assignment's activation input, acceptance from the turn ending that accepts its submission,
+ * results, staleness, counts, routing and pending decisions from all of them. No row records a
+ * pending decision or an acceptance.
+ *
+ * - `opened` rides in the root's creation write: the definition's id, its readable canonical copy
+ *   as started, for audit and display only (execution always takes the definition registered under
+ *   the id now), the instance's input, the host's first input id and the pins of what it runs on.
+ * - `entered` opens an attempt, atomically: what it retires, every input bound with its citation,
+ *   the value of each evidence input, and its assignments, each with where it runs and what
+ *   activates it. One row, so a failed entry writes nothing.
+ * - `observed` brings isolated participants' facts to the root, whose fold cannot read their
+ *   children's rows: a task accepted a submission at a completed ending, or settled without one,
+ *   or its start was refused for good, and, beside one that ended, what each unfinished sibling
+ *   shows then. Evidence carried across,
+ *   recomputed from the retained children inside the root's write, never an acceptance of its own;
+ *   one acceptance or ending per task. One row per write, so a recovery opened by it sees all of it.
+ * - `stopped` is a person's Stop of the instance's current attempt, written in the root's cancel
+ *   write beside delegations' stop of its tasks: the attempt and what each open isolated
+ *   assignment's child showed inside that write, recomputed from the retained child. An acceptance
+ *   it carries happened before the Stop and stands; any other open isolated assignment is
+ *   superseded and the attempt recovers (cause `stop`), the root's own assignment with it. Its row is
+ *   the Stop's boundary: a transition owed by a result ready before it, entering isolated work after
+ *   it, recovers at its entry.
+ * - `completed` ends the instance through a `$complete` edge.
+ * - `decided` records a host decision on a pending gate, exhaustion or recovery, with the persistent
+ *   participants it restarts; it shares its write with the transition it selects.
+ * - `cancel-requested` admits a cancellation, closing assignment authority; `cancelled` is its
+ *   terminal row, written once cleanup is established.
+ */
+declare const InstanceRowSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"opened">;
+    definition: z.ZodString;
+    canonical: z.ZodType<CanonicalDefinition>;
+    input: z.ZodJSONSchema;
+    input_id: z.ZodString;
+    pins: z.ZodObject<{
+        participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+            configuration: z.ZodNullable<z.ZodObject<{
+                agent: z.ZodString;
+                route: z.ZodObject<{
+                    provider: z.ZodString;
+                    model: z.ZodString;
+                    thinking_effort: z.ZodNullable<z.ZodEnum<{
+                        low: "low";
+                        high: "high";
+                        none: "none";
+                        medium: "medium";
+                        max: "max";
+                    }>>;
+                }, z.core.$strip>;
+                environment: z.ZodObject<{
+                    cwd: z.ZodString;
+                    read_roots: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+                installations: z.ZodArray<z.ZodObject<{
+                    installation_id: z.ZodString;
+                    preset_id: z.ZodString;
+                    config: z.ZodJSONSchema;
+                    lifetime: z.ZodEnum<{
+                        defining: "defining";
+                        configurable: "configurable";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checks: z.ZodRecord<z.ZodString, z.ZodObject<{
+                config: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        evidence: z.ZodRecord<z.ZodString, z.ZodObject<{
+            config: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"entered">;
+    transition: z.ZodString;
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"opening">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"routed">;
+        result: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"decision">;
+        decision: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    step: z.ZodString;
+    attempt: z.ZodString;
+    ordinal: z.ZodNumber;
+    retires: z.ZodArray<z.ZodString>;
+    inputs: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"input">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"evidence">;
+        provider: z.ZodString;
+        immutable: z.ZodBoolean;
+        detail: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"result">;
+        result: z.ZodString;
+        participant: z.ZodNullable<z.ZodString>;
+        decision: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            current: "current";
+            historical: "historical";
+        }>;
+    }, z.core.$strict>], "kind">>>;
+    evidence: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    assignments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        context: z.ZodLiteral<"conversation">;
+        id: z.ZodString;
+        participant: z.ZodString;
+        activation: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        context: z.ZodLiteral<"isolated">;
+        id: z.ZodString;
+        participant: z.ZodString;
+        thread: z.ZodString;
+        task: z.ZodString;
+        generation: z.ZodNumber;
+        lifetime: z.ZodEnum<{
+            attempt: "attempt";
+            instance: "instance";
+        }>;
+        checks: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "context">>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"observed">;
+    observations: z.ZodArray<z.ZodObject<{
+        assignment: z.ZodString;
+        thread: z.ZodString;
+        task: z.ZodString;
+        generation: z.ZodNumber;
+        outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"accepted">;
+            submission: z.ZodNumber;
+            ending: z.ZodNumber;
+            output: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"ended">;
+            settlement: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                stopped: "stopped";
+            }>;
+            detail: z.ZodString;
+            candidate: z.ZodNullable<z.ZodObject<{
+                submission: z.ZodNumber;
+                output: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+            report: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            detail: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unfinished">;
+            candidate: z.ZodNullable<z.ZodObject<{
+                submission: z.ZodNumber;
+                output: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+            report: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"stopped">;
+    attempt: z.ZodString;
+    reason: z.ZodString;
+    observations: z.ZodArray<z.ZodObject<{
+        assignment: z.ZodString;
+        thread: z.ZodString;
+        task: z.ZodString;
+        generation: z.ZodNumber;
+        outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"accepted">;
+            submission: z.ZodNumber;
+            ending: z.ZodNumber;
+            output: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"ended">;
+            settlement: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                stopped: "stopped";
+            }>;
+            detail: z.ZodString;
+            candidate: z.ZodNullable<z.ZodObject<{
+                submission: z.ZodNumber;
+                output: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+            report: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            detail: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unfinished">;
+            candidate: z.ZodNullable<z.ZodObject<{
+                submission: z.ZodNumber;
+                output: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+            report: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"completed">;
+    transition: z.ZodString;
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"opening">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"routed">;
+        result: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"decision">;
+        decision: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"decided">;
+    decision: z.ZodString;
+    operation_id: z.ZodString;
+    actor: z.ZodString;
+    attempt: z.ZodString;
+    reason: z.ZodEnum<{
+        gate: "gate";
+        exhaustion: "exhaustion";
+        recovery: "recovery";
+    }>;
+    result: z.ZodNullable<z.ZodString>;
+    verdict: z.ZodEnum<{
+        approve: "approve";
+        revise: "revise";
+    }>;
+    option: z.ZodNullable<z.ZodString>;
+    feedback: z.ZodNullable<z.ZodString>;
+    restart: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"cancel-requested">;
+    operation_id: z.ZodString;
+    actor: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"cancelled">;
+    operation_id: z.ZodString;
+}, z.core.$strict>], "op">;
+export type InstanceRow = z.output<typeof InstanceRowSchema>;
+export type InstanceRowInput = z.input<typeof InstanceRowSchema>;
+export type Opened = Extract<InstanceRow, {
+    op: 'opened';
+}>;
+export type Entered = Extract<InstanceRow, {
+    op: 'entered';
+}>;
+export type Decided = Extract<InstanceRow, {
+    op: 'decided';
+}>;
+/**
+ * Declared policy state: entering, observing, stopping, deciding, completing and cancelling change
+ * what a thread's workflow authority allows, so one landing while a call is authorized, on the root
+ * or on a thread under it, decides that call again.
+ */
+export declare const instanceRow: {
+    record: (value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }) => import("../../models/index.js").ExtensionRecord;
+    parse: (value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }) => {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: CanonicalDefinition;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    };
+    entry: (value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../models/index.js").JournalEvent<"ext">>;
+    read(event: import("../../models/index.js").JournalEvent): {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: CanonicalDefinition;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../models/index.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../models/index.js").Seq[];
+    }): import("../../models/index.js").StepContribution;
+    matchesSource(record: DeepReadonly<import("../../models/index.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: unknown;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../models/index.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../models/index.js").JournalEvent) => {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: CanonicalDefinition;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    } | undefined;
+    readSource: (source: DeepReadonly<import("../../models/index.js").ExtensionRecord> | null) => {
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: CanonicalDefinition;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../kit/extension.js").ToldNotices<{
+        op: "decided";
+        decision: string;
+        operation_id: string;
+        actor: string;
+        attempt: string;
+        reason: "gate" | "exhaustion" | "recovery";
+        result: string | null;
+        verdict: "approve" | "revise";
+        option: string | null;
+        feedback: string | null;
+        restart: string[];
+    } | {
+        op: "opened";
+        definition: string;
+        canonical: CanonicalDefinition;
+        input: z.core.util.JSONType;
+        input_id: string;
+        pins: {
+            participants: Record<string, {
+                configuration: {
+                    agent: string;
+                    route: {
+                        provider: string;
+                        model: string;
+                        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                    };
+                    environment: {
+                        cwd: string;
+                        read_roots: string[];
+                    };
+                    installations: {
+                        installation_id: string;
+                        preset_id: string;
+                        config: z.core.util.JSONType;
+                        lifetime: "defining" | "configurable";
+                    }[];
+                } | null;
+                checks: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            }>;
+            evidence: Record<string, {
+                config: z.core.util.JSONType;
+            }>;
+        };
+    } | {
+        op: "entered";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+        step: string;
+        attempt: string;
+        ordinal: number;
+        retires: string[];
+        inputs: Record<string, {
+            kind: "input";
+        } | {
+            kind: "evidence";
+            provider: string;
+            immutable: boolean;
+            detail: z.core.util.JSONType;
+        } | {
+            kind: "result";
+            result: string;
+            participant: string | null;
+            decision: string | null;
+            mode: "current" | "historical";
+        } | null>;
+        evidence: Record<string, z.core.util.JSONType>;
+        assignments: ({
+            context: "conversation";
+            id: string;
+            participant: string;
+            activation: string;
+        } | {
+            context: "isolated";
+            id: string;
+            participant: string;
+            thread: string;
+            task: string;
+            generation: number;
+            lifetime: "attempt" | "instance";
+            checks: string[];
+        })[];
+    } | {
+        op: "observed";
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "stopped";
+        attempt: string;
+        reason: string;
+        observations: {
+            assignment: string;
+            thread: string;
+            task: string;
+            generation: number;
+            outcome: {
+                kind: "accepted";
+                submission: number;
+                ending: number;
+                output: z.core.util.JSONType;
+            } | {
+                kind: "ended";
+                settlement: "completed" | "failed" | "stopped";
+                detail: string;
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            } | {
+                kind: "refused";
+                detail: string;
+            } | {
+                kind: "unfinished";
+                candidate: {
+                    submission: number;
+                    output: z.core.util.JSONType;
+                } | null;
+                report: string | null;
+            };
+        }[];
+    } | {
+        op: "completed";
+        transition: string;
+        cause: {
+            kind: "opening";
+        } | {
+            kind: "routed";
+            result: string;
+        } | {
+            kind: "decision";
+            decision: string;
+        };
+    } | {
+        op: "cancel-requested";
+        operation_id: string;
+        actor: string;
+        reason: string;
+    } | {
+        op: "cancelled";
+        operation_id: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            op: "decided";
+            decision: string;
+            operation_id: string;
+            actor: string;
+            attempt: string;
+            reason: "gate" | "exhaustion" | "recovery";
+            result: string | null;
+            verdict: "approve" | "revise";
+            option: string | null;
+            feedback: string | null;
+            restart: string[];
+        } | {
+            op: "opened";
+            definition: string;
+            canonical: CanonicalDefinition;
+            input: z.core.util.JSONType;
+            input_id: string;
+            pins: {
+                participants: Record<string, {
+                    configuration: {
+                        agent: string;
+                        route: {
+                            provider: string;
+                            model: string;
+                            thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+                        };
+                        environment: {
+                            cwd: string;
+                            read_roots: string[];
+                        };
+                        installations: {
+                            installation_id: string;
+                            preset_id: string;
+                            config: z.core.util.JSONType;
+                            lifetime: "defining" | "configurable";
+                        }[];
+                    } | null;
+                    checks: Record<string, {
+                        config: z.core.util.JSONType;
+                    }>;
+                }>;
+                evidence: Record<string, {
+                    config: z.core.util.JSONType;
+                }>;
+            };
+        } | {
+            op: "entered";
+            transition: string;
+            cause: {
+                kind: "opening";
+            } | {
+                kind: "routed";
+                result: string;
+            } | {
+                kind: "decision";
+                decision: string;
+            };
+            step: string;
+            attempt: string;
+            ordinal: number;
+            retires: string[];
+            inputs: Record<string, {
+                kind: "input";
+            } | {
+                kind: "evidence";
+                provider: string;
+                immutable: boolean;
+                detail: z.core.util.JSONType;
+            } | {
+                kind: "result";
+                result: string;
+                participant: string | null;
+                decision: string | null;
+                mode: "current" | "historical";
+            } | null>;
+            evidence: Record<string, z.core.util.JSONType>;
+            assignments: ({
+                context: "conversation";
+                id: string;
+                participant: string;
+                activation: string;
+            } | {
+                context: "isolated";
+                id: string;
+                participant: string;
+                thread: string;
+                task: string;
+                generation: number;
+                lifetime: "attempt" | "instance";
+                checks: string[];
+            })[];
+        } | {
+            op: "observed";
+            observations: {
+                assignment: string;
+                thread: string;
+                task: string;
+                generation: number;
+                outcome: {
+                    kind: "accepted";
+                    submission: number;
+                    ending: number;
+                    output: z.core.util.JSONType;
+                } | {
+                    kind: "ended";
+                    settlement: "completed" | "failed" | "stopped";
+                    detail: string;
+                    candidate: {
+                        submission: number;
+                        output: z.core.util.JSONType;
+                    } | null;
+                    report: string | null;
+                } | {
+                    kind: "refused";
+                    detail: string;
+                } | {
+                    kind: "unfinished";
+                    candidate: {
+                        submission: number;
+                        output: z.core.util.JSONType;
+                    } | null;
+                    report: string | null;
+                };
+            }[];
+        } | {
+            op: "stopped";
+            attempt: string;
+            reason: string;
+            observations: {
+                assignment: string;
+                thread: string;
+                task: string;
+                generation: number;
+                outcome: {
+                    kind: "accepted";
+                    submission: number;
+                    ending: number;
+                    output: z.core.util.JSONType;
+                } | {
+                    kind: "ended";
+                    settlement: "completed" | "failed" | "stopped";
+                    detail: string;
+                    candidate: {
+                        submission: number;
+                        output: z.core.util.JSONType;
+                    } | null;
+                    report: string | null;
+                } | {
+                    kind: "refused";
+                    detail: string;
+                } | {
+                    kind: "unfinished";
+                    candidate: {
+                        submission: number;
+                        output: z.core.util.JSONType;
+                    } | null;
+                    report: string | null;
+                };
+            }[];
+        } | {
+            op: "completed";
+            transition: string;
+            cause: {
+                kind: "opening";
+            } | {
+                kind: "routed";
+                result: string;
+            } | {
+                kind: "decision";
+                decision: string;
+            };
+        } | {
+            op: "cancel-requested";
+            operation_id: string;
+            actor: string;
+            reason: string;
+        } | {
+            op: "cancelled";
+            operation_id: string;
+        }, event: import("../../models/index.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+/** The `opened` row of an instance of `definition`: its id and readable copy, `input`, the host's first input id and its pins. */
+export declare function openedRow(definition: WorkflowDefinition, input: z.input<typeof JsonValueSchema>, inputId: string, pins: Pins): Opened;
+/** What a submission's result carries: the assignment it answers and the output, as submitted and validated. */
+declare const SubmissionSchema: z.ZodObject<{
+    assignment: z.ZodString;
+    output: z.ZodJSONSchema;
+}, z.core.$strict>;
+export type Submission = z.output<typeof SubmissionSchema>;
+/** The metadata a submission's result records, read back by {@link readSubmission}. */
+export declare const submissionMetadata: (submission: Submission) => Record<string, unknown>;
+/**
+ * The submission `result` records: a successful result of {@link SUBMIT_TOOL} that concluded its
+ * turn, so core's stop checks judge it as the answer; `undefined` for any other result.
+ */
+export declare function readSubmission(result: ToolResult): Submission | undefined;
+/**
+ * The source of the one submission reminder an assignment gets per epoch: its activation, or the
+ * person's latest input since (`epoch`, that row's seq). The stop check sends a root reply back
+ * with it once per epoch and abstains once it is spent, so prose never advances the workflow.
+ */
+export declare const submissionReminder: {
+    record: (value: {
+        assignment: string;
+        epoch: number;
+    }) => import("../../models/index.js").ExtensionRecord;
+    parse: (value: {
+        assignment: string;
+        epoch: number;
+    }) => {
+        assignment: string;
+        epoch: number;
+    };
+    entry: (value: {
+        assignment: string;
+        epoch: number;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        assignment: string;
+        epoch: number;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../models/index.js").JournalEvent<"ext">>;
+    read(event: import("../../models/index.js").JournalEvent): {
+        assignment: string;
+        epoch: number;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../models/index.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        assignment: string;
+        epoch: number;
+    }, options?: {
+        sourceSeqs?: readonly import("../../models/index.js").Seq[];
+    }): import("../../models/index.js").StepContribution;
+    matchesSource(record: DeepReadonly<import("../../models/index.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        assignment: string;
+        epoch: number;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../models/index.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../models/index.js").JournalEvent) => {
+        assignment: string;
+        epoch: number;
+    } | undefined;
+    readSource: (source: DeepReadonly<import("../../models/index.js").ExtensionRecord> | null) => {
+        assignment: string;
+        epoch: number;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../kit/extension.js").ToldNotices<{
+        assignment: string;
+        epoch: number;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            assignment: string;
+            epoch: number;
+        }, event: import("../../models/index.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+/** The attempt that is `step`'s `ordinal`th entry. */
+export declare const attemptId: (instance: string, step: string, ordinal: number) => string;
+export declare const assignmentId: (attempt: string, participant: string) => string;
+/** The conversation generation `participant` runs on: 1, then one more for each restart a decision recorded. */
+export declare const generationOf: (generations: ReadonlyMap<string, number>, participant: string) => number;
+/** An attempt's result: an attempt produces at most one. */
+export declare const resultId: (attempt: string) => string;
+/** A decision is pending on one attempt for one reason. */
+export declare const decisionId: (attempt: string, reason: "gate" | "exhaustion" | "recovery") => string;
+/** The transition a cause makes: each cause makes at most one. */
+export declare function transitionId(instance: string, cause: TransitionCause): string;
+/**
+ * The input a transition is written with: the scheduling input of the root assignment it opens,
+ * whose claim activates it, or else the notice telling the root what happened.
+ */
+export declare const schedulingInputId: (transition: string) => string;
+/**
+ * The source of the input a transition is written with: the root assignment it schedules, or `null`
+ * for a notice of a transition that gives the root none; and the host decision that made it, if
+ * one did. An identity apart from the assignment's presentation, so a short scheduling input never
+ * counts as the detailed presentation.
+ */
+export declare const transitionNotice: {
+    record: (value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }) => import("../../models/index.js").ExtensionRecord;
+    parse: (value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }) => {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    };
+    entry: (value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../models/index.js").JournalEvent<"ext">>;
+    read(event: import("../../models/index.js").JournalEvent): {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../models/index.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }, options?: {
+        sourceSeqs?: readonly import("../../models/index.js").Seq[];
+    }): import("../../models/index.js").StepContribution;
+    matchesSource(record: DeepReadonly<import("../../models/index.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../models/index.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../models/index.js").JournalEvent) => {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    } | undefined;
+    readSource: (source: DeepReadonly<import("../../models/index.js").ExtensionRecord> | null) => {
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../kit/extension.js").ToldNotices<{
+        transition: string;
+        assignment: string | null;
+        decision: string | null;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            transition: string;
+            assignment: string | null;
+            decision: string | null;
+        }, event: import("../../models/index.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+export {};