@leuduan/lagent 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,116 @@
+import type { CommandWork } from '../commands/index.js';
+import { type EntryEvidence, type EvidenceNeeds } from './bindings.js';
+import { type CanonicalDefinition } from './definition.js';
+import type { InstanceState, PendingDecision } from './fold.js';
+import { type InstanceRowInput } from './record.js';
+import type { ReadonlyState } from '../../util/foldState.js';
+/**
+ * The decision a person owes, derived: a recovering attempt waits for its recovery decision; a
+ * gated step's ready result waits for its gate; an ungated one whose selected edge would exceed its
+ * target's allowance waits on exhaustion, marked with the transition it holds back. Nothing records
+ * a pending decision; its id is the attempt's and the reason's, so a decision on a superseded id is
+ * stale. Its actions are what the recorded facts alone offer: what a recovery waits on and must
+ * restart is added from its barrier ({@link offered}). Read with the copy recorded at opening, which
+ * a held instance renders from, a step that copy lacks (one added in place and entered since) owes
+ * no gate or exhaustion it can name, and offers no option.
+ */
+export declare function pendingDecision(state: ReadonlyState<InstanceState>, definition: CanonicalDefinition): PendingDecision | null;
+/**
+ * What a recovery's decision waits on and must restart, as the lifetime owners of the work answer it
+ * now (decision 18 of the slice-2 plan), combined by the service: `cleanup`, the recovering
+ * attempt's work still ending (`draining`) or whose end nothing establishes (`unresolved`): its tasks,
+ * their runs, descendants and commands, the stops of them not yet acknowledged, and conversations
+ * whose continuation cannot be judged yet; `uncontinuable`, each persistent participant with a
+ * conversation that delegations will not continue, with why. Also what a cancellation's end waits
+ * on, its `cleanup` covering everything under the root.
+ */
+export type Barrier = {
+    readonly cleanup: CommandWork;
+    readonly uncontinuable: ReadonlyMap<string, string>;
+};
+/**
+ * `pending` as `decide` would take it now: a recovery's actions under `barrier`, with no verdict
+ * while its cleanup is pending (`cleanupPending`), and each revise choice required to restart the
+ * participants it allows that cannot be continued. Gate and exhaustion decisions wait on nothing.
+ */
+export declare function offered(pending: PendingDecision, barrier: Barrier): PendingDecision;
+/** Evidence the plan needs before it can be made, acquired outside any write; then plan again with it. */
+export type Needs = {
+    readonly kind: 'needs';
+    readonly needs: EvidenceNeeds;
+};
+/** One transition's row, planned; or why it cannot be written; or the evidence its entry needs first. */
+type Transition = {
+    readonly kind: 'transition';
+    readonly row: Extract<InstanceRowInput, {
+        op: 'entered' | 'completed';
+    }>;
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+} | Needs;
+/**
+ * What the instance does next on its own: nothing while it works, waits for a decision or has
+ * ended; otherwise the automatic transition its accepted, ungated result selects, to be written by
+ * its owner as a follow-up (repair writes the same one, by its deterministic id); or the reason the
+ * selected target cannot be entered, which blocks the instance (`entry-refused`) until it can; or
+ * the evidence its entry needs, when `evidence` is not what it acquired for that very attempt.
+ */
+export declare function nextMove(state: ReadonlyState<InstanceState>, definition: CanonicalDefinition, evidence?: EntryEvidence): {
+    readonly kind: 'none';
+} | Transition;
+/** A host decision as `decide` takes it. */
+export type DecisionRequest = {
+    readonly operationId: string;
+    /** The pending decision's id. */
+    readonly decision: string;
+    readonly verdict: 'approve' | 'revise';
+    readonly option: string | null;
+    readonly feedback: string | null;
+    /** The persistent participants to give a new conversation, as the host listed them. */
+    readonly restart: readonly string[];
+    readonly actor: string;
+};
+/**
+ * What a decision or cancellation writes: its rows, nothing (a replay of the same operation), a
+ * refusal, or, for a decision, the evidence its selected entry needs first.
+ */
+export type Plan = {
+    readonly kind: 'rows';
+    readonly rows: readonly InstanceRowInput[];
+} | {
+    readonly kind: 'replay';
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+} | Needs;
+/**
+ * Plans a host decision on the pending decision it names, for one write: the `decided` row and the
+ * transition it selects. Every host decision resets every step's count first, so the entry it
+ * opens always fits. Refused, writing nothing and leaving the decision pending: a stale or unknown
+ * id, a recovery whose cleanup `barrier` says is not established, a verdict or option the decision
+ * does not offer, a restart list naming someone twice, someone its choice may not restart or
+ * leaving out someone `barrier` says cannot be continued, a conflicting reuse of the operation
+ * id, an instance that cannot execute (`definition` is the executable one, `undefined` when
+ * blocked), and a selected target that cannot be entered, named in the reason. The same operation
+ * and payload again, its restart list compared as a set, is a replay, even after the instance moved
+ * on. A selected entry that binds evidence is planned with `evidence`, acquired for exactly that
+ * attempt, and needs it otherwise.
+ *
+ * A gate or exhaustion decision routes its result's edges over the result and the decision. A
+ * recovery has no result: a plain revise opens the same step again; a revise with an option routes
+ * the step's edges over the decision alone, and the edge that takes it must guard the recovery and
+ * that option and enter a step.
+ */
+export declare function planDecision(state: ReadonlyState<InstanceState>, definition: CanonicalDefinition | undefined, request: DecisionRequest, barrier: Barrier, evidence?: EntryEvidence): Plan;
+/**
+ * Plans admitting a cancellation: its `cancel-requested` row, which closes assignment authority.
+ * Available whatever is registered, since it executes no procedure; refused once the instance ended
+ * or another cancellation is under way. The same operation and payload again is a replay.
+ */
+export declare function planCancel(state: ReadonlyState<InstanceState>, request: {
+    readonly operationId: string;
+    readonly reason: string;
+    readonly actor: string;
+}): Plan;
+export {};

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** An admitted schema, or why it is not. */
+export type Admission = {
+    readonly problems: string[];
+    readonly schema: z.ZodType | undefined;
+};
+/**
+ * Admits `schema` (problems name where: `at`, then the path inside it), rebuilding it from the plain
+ * values the walk read, so the result shares nothing with the caller's schema: mutating that one
+ * later changes nothing. A JSON Schema rendering alone does not show what a zod schema validates: a
+ * pipe renders one side, a refinement or transform renders as its base type, regex flags are
+ * dropped, repeated checks collapse and metadata can overwrite validation keywords. So only nodes
+ * whose rendering describes their validation, and that never normalize what they accept, are
+ * admitted: strict objects, arrays, strings with length bounds and a flagless regex, numbers and
+ * integers with bounds and `multipleOf`, booleans, scalar enums and literals, inclusive unions
+ * (discriminated ones too), nullable and optional, with `title` and `description` metadata, each
+ * check once per node and with a parameter its rendering can state. Everything else is refused,
+ * recursion included. Custom error messages are not kept: they change no validation.
+ */
+export declare function admitSchema(schema: unknown, at: string): Admission;
+/**
+ * The schemas an admitted `schema` has at JSON Pointer `tokens` (already unescaped): one per union
+ * branch that reaches it, none when the pointer cannot hold a value. Nullable and optional wrappers
+ * are looked through.
+ */
+export declare function schemasAt(schema: z.core.$ZodType, tokens: readonly string[]): z.core.$ZodType[];

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

@@ -0,0 +1,477 @@
+import { Service, type Context } from '@leuduan/cordis';
+import { z } from 'zod';
+import { type ThinkingEffort } from '../../llm/index.js';
+import type { FreshOpening, WriteRows } from '../../loop/index.js';
+import type { ThreadEnvironment } from '../../models/index.js';
+import type { InitialInstallationInput } from '../../services/presets.js';
+import type { DeepReadonly } from '../../util/json.js';
+import type { AppendEntry } from '../../journal/index.js';
+import { type CanonicalDefinition, type JsonSchema, type WorkflowDefinition } from './definition.js';
+import { type Configured } from './providers.js';
+import { type InstanceView } from './view.js';
+declare module '@leuduan/cordis' {
+    interface Context {
+        /** Workflow definitions and the instances that run them (optional plugin). */
+        workflows: WorkflowsService;
+    }
+}
+/**
+ * A host check on the conversation an instance opens in, as its creation records it (agent,
+ * installations): `null` when it holds, otherwise why not, which refuses the opening.
+ */
+export type Prerequisite = (conversation: DeepReadonly<FreshOpening>) => string | null;
+/**
+ * A role's binding: what an isolated participant under it runs on besides its route, resolved from
+ * the conversation's configuration as the host proposes to create it; or why that conversation
+ * cannot have such a participant, which refuses the opening. Its installations are each defining
+ * and named by its id, as an assignment child's must be.
+ */
+export type RoleBinding = (conversation: Configured) => {
+    readonly agent: string;
+    readonly environment: DeepReadonly<ThreadEnvironment>;
+    readonly installations: readonly InitialInstallationInput[];
+} | {
+    readonly refused: string;
+};
+declare const WorkflowsConfigSchema: z.ZodObject<{
+    definitions: z.ZodArray<z.ZodCustom<CanonicalDefinition, CanonicalDefinition>>;
+    restrictions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        allow: z.ZodArray<z.ZodString>;
+        denial: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    coordination: z.ZodObject<{
+        allow: z.ZodArray<z.ZodString>;
+        denial: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    prerequisites: z.ZodRecord<z.ZodString, z.ZodCustom<Prerequisite, Prerequisite>>;
+    roles: z.ZodRecord<z.ZodString, z.ZodCustom<RoleBinding, RoleBinding>>;
+    modelProviders: z.ZodArray<z.ZodString>;
+    checks: z.ZodRecord<z.ZodString, z.ZodCustom<import("./providers.js").CheckProvider, import("./providers.js").CheckProvider>>;
+    evidence: z.ZodRecord<z.ZodString, z.ZodCustom<import("./providers.js").EvidenceProvider, import("./providers.js").EvidenceProvider>>;
+}, z.core.$strict>;
+export type WorkflowsConfig = z.input<typeof WorkflowsConfigSchema>;
+/**
+ * One registered definition as a start form lists it: its id, its input's JSON Schema, and each
+ * isolated participant's model: the default its definition names (effort explicit or `null`) and
+ * whether the starter may choose another, from the model providers the host offers
+ * (`modelProviders`), which `opening` takes as `models`.
+ */
+export type CatalogEntry = {
+    readonly id: string;
+    readonly input: JsonSchema;
+    readonly participants: Readonly<Record<string, {
+        readonly provider: string;
+        readonly model: string;
+        readonly thinkingEffort: ThinkingEffort | null;
+        readonly configurable: boolean;
+    }>>;
+    readonly modelProviders: readonly string[];
+};
+declare const OpeningRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    inputId: z.ZodString;
+    definition: z.ZodString;
+    input: z.ZodJSONSchema;
+    conversation: z.ZodObject<{
+        environment: z.ZodObject<{
+            cwd: z.ZodString;
+            read_roots: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        installations: z.ZodArray<z.ZodCustom<InitialInstallationInput, InitialInstallationInput>>;
+    }, z.core.$strict>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        thinkingEffort: z.ZodNullable<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            none: "none";
+            medium: "medium";
+            max: "max";
+        }>>;
+    }, z.core.$strict>>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+}, z.core.$strict>;
+export type OpeningRequest = z.input<typeof OpeningRequestSchema>;
+declare const DecideRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    instanceId: z.ZodString;
+    decision: z.ZodString;
+    verdict: z.ZodEnum<{
+        approve: "approve";
+        revise: "revise";
+    }>;
+    option: z.ZodOptional<z.ZodString>;
+    feedback: z.ZodOptional<z.ZodString>;
+    restart: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type DecideRequest = z.input<typeof DecideRequestSchema>;
+declare const CancelRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    instanceId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type CancelRequest = z.input<typeof CancelRequestSchema>;
+/**
+ * The host's cancel of a root for a person's Stop, as {@link WorkflowsService.stop} runs it: it
+ * cancels the root with `rows` among its cancel `rows`, beside delegations' stop obligations, and
+ * settles with that write.
+ */
+export type StopCancel = (rows: (threadId: string) => AppendEntry<'ext'>[]) => Promise<void>;
+/** A request the workflow refuses, with why: nothing was recorded. */
+export declare class WorkflowRefusedError extends Error {
+    constructor(reason: string);
+}
+/**
+ * Registered definitions and the instances that run them. An instance lives on its root thread,
+ * the conversation it was opened with: the root requires {@link WORKFLOWS_OWNER}, so it runs only
+ * while this service is mounted and repaired. Everything the instance records is written here, each
+ * write deciding again inside itself what it records:
+ *
+ * - `opening` gives the rows of the root's creation write: the opening, the entry attempt.
+ * - An accepted result routes on its own: after the turn ending that accepted it, one follow-up send
+ *   on the root writes the transition with its input under the transition's deterministic id; the
+ *   repair at startup sends any a crash missed, which that id makes idempotent.
+ * - `decide` records a host decision with the transition it selects and its input in one send: on a
+ *   recovery, with the persistent participants it restarts.
+ * - Reconciliation, one pass at a time per root (`reconcile`), never waiting on a model turn of the
+ *   root: an isolated participant's child is observed on the root (`observations.ts`), a write on
+ *   the root recomputing from the retained child whether its task accepted a submission or ended
+ *   without one; then the transition the instance owes on its own is routed; then each isolated
+ *   assignment the instance owes a task is started (`participants.ts`), in the background, never
+ *   waiting on the child's work. It runs after every row of the instance, at the root's turn end,
+ *   when a participant's task settles, after a start ends, on rows under a root whose start waits
+ *   on a slot or a previous task, on a provider's notice, and at the repair, so a remount resumes it.
+ *   A start delegations refuses for good is recorded, rechecked inside the root's write, as an
+ *   observation that recovers its attempt.
+ * - `cancel` admits a cancellation in a write of its own, then cancels the root's operation, stops
+ *   its commands, and records the end once the evidence holds: the run released, each command's
+ *   termination established from its records. A failed stop or unknown termination leaves the
+ *   instance blocked on cleanup; a crash after the admission resumes at the repair.
+ * - A person's Stop of the root (`stop`) records, in its cancel write, what it met: isolated
+ *   work open stops for good and the attempt recovers, an acceptance before it stands. A task that
+ *   ends without acceptance recovers its attempt too, and the observation's write stops its
+ *   siblings' tasks. A recovery's decision, its restarts and the successor it opens wait on one
+ *   evidence barrier (`cleanup.ts`), as a cancellation's end does.
+ *
+ * Beside these writes it mounts what the fold derives for the model steps of the root, its
+ * participants' children and the threads they start: the presentation of assignments
+ * (`assignment.ts`), the vote and grant of their authority (`policy.ts`), and
+ * `submit_workflow_output` with the stop check reminding a thread to submit (`submit.ts`). Its
+ * constraint holds the root and every thread under it while the instance cannot execute.
+ *
+ * An entry that binds evidence has it acquired first, outside any write, for exactly that transition
+ * and attempt; its write plans the entry again with that evidence and records it only when the plan
+ * is unchanged. The providers' subscriptions and every acquisition in flight are this service's
+ * (`providers.ts`): a provider's notice decides again what it held, and the unload cancels and
+ * waits for what is in flight.
+ *
+ * Registration refuses a definition naming a restriction, prerequisite, role or provider the host
+ * does not bind, and a second definition under one id. An id is a definition's whole identity: an
+ * instance runs by the definition registered under its id now, edits included, and is held only
+ * where it cannot continue on it (`heldBy`); a breaking change registers under a new id.
+ */
+export declare class WorkflowsService extends Service<WorkflowsConfig> {
+    static inject: string[];
+    private readonly config;
+    private readonly registered;
+    private readonly entries;
+    /** Cleanups under way, by root: each instance's runs once at a time. */
+    private readonly cleanups;
+    /** Roots whose admitted cancellation has not ended, whose cleanup a later row or run event may finish. */
+    private readonly cancelling;
+    /**
+     * Roots the repair could not read, clean up or reconcile, with why: held with every thread under
+     * them, never reconciled again and none of their participants' tasks started or admitted, until a
+     * remount repairs them again ({@link quarantined}).
+     */
+    private readonly unrepaired;
+    /** Follow-up sends in flight, which shutdown lets land. */
+    private readonly sends;
+    /** Each root's reconciliation in flight, and whether another was asked for while it ran. */
+    private readonly passes;
+    /** Set once shutdown began: no reconciliation starts after it. */
+    private closing;
+    /** Set once the repair began, which reconciles every root: none is reconciled before. */
+    private repairing;
+    private readonly participants;
+    /** The catalog refresh of the instance contribution registration queued; the repair awaits it. */
+    private refreshed;
+    private readonly providers;
+    private constraint;
+    /**
+     * The latest refusal of each root's automatic transition over evidence acquired for it, until a
+     * provider's notice retries it: a derived availability condition, never recorded.
+     */
+    private readonly entryRefusals;
+    constructor(ctx: Context, config: WorkflowsConfig);
+    /** Every registered definition, with its rendered input schema and participants' models, in registration order. */
+    catalog(): readonly CatalogEntry[];
+    /** The definition registered under `id`; `undefined` when none is. */
+    definition(id: string): WorkflowDefinition | undefined;
+    /**
+     * The rows that open an instance in the write creating its root, for `threads.create`'s `rows`:
+     * the opening (id, readable copy, input, pins) and the entry attempt, activated by
+     * the claim of the first input. The host creates the root under `id`, with its first input under
+     * `inputId`, `requires: [WORKFLOWS_OWNER]` and exactly the proposed `conversation`, in that one
+     * write, and with a wake exactly when the entry step assigns the conversation participant: an
+     * entry worked by isolated participants alone is started by reconciliation, with no root turn.
+     *
+     * Prepared outside the write, and cancelled by `signal`: each isolated participant's configuration
+     * resolved through its role and pinned with its complete route, the default or the starter's
+     * choice; each check provider pinned from its participant's configuration, and each evidence
+     * provider from the conversation's; and the entry step's evidence acquired.
+     *
+     * Refused here, with {@link WorkflowRefusedError}: a definition not registered under that id, an
+     * input its schema refuses, a model choice for a participant that takes none or with
+     * a provider the host does not offer, a role or provider that is unavailable or refuses this
+     * conversation, and an entry that cannot bind. Refused inside the write, which then creates nothing: a write that is not a
+     * new root's creation under `id` (a fork, a delegated thread), one without the owner or the first
+     * input, a wake where the entry needs one or one where it needs none, a conversation other than
+     * the one proposed, and one a prerequisite's check refuses. A root found again under `id` gets no rows: the host compares its recorded definition
+     * (`read`) with the one it asked for.
+     */
+    opening(request: OpeningRequest): Promise<WriteRows>;
+    /** The conversation a host proposes, as its creation records it, installation ids left out. */
+    private proposed;
+    /**
+     * What the instance runs on besides its definition, pinned: each participant's configuration and
+     * the pins of the checks its assignments list, then the evidence providers' pins.
+     */
+    private pins;
+    /**
+     * An isolated participant's complete configuration: its route, the default its definition names
+     * or the starter's complete choice, on a provider the host offers; and what its role resolves from
+     * the conversation, its installations validated and normalized as its creation records them.
+     */
+    private configuration;
+    /** Why the write `opening` describes cannot open this instance, or `null`. */
+    private openingRefusal;
+    /**
+     * The instance on root `instanceId`, as a host reads it now: synchronous, so a host can put it in
+     * the same snapshot as the thread's other reads. Read while the root is loaded, as
+     * `ctx.threads.view` is: the caller retains it (`ctx.threads.retain`), or it is running.
+     */
+    read(instanceId: string): InstanceView;
+    /**
+     * Records a host decision on the pending decision it names, with the transition it selects and an
+     * input, in one send on the root: the scheduling input of the root assignment the transition
+     * opens, or else a notice telling the root what was decided. A person's wake comes with it when
+     * the root gets work, or when the decision must release a person's Stop. Everything is decided
+     * again inside the write, serialized with the conversation's other input. The same operation and
+     * payload again returns the instance as it stands. Refused with {@link WorkflowRefusedError},
+     * recording nothing and leaving the decision pending: a stale or unknown decision, a verdict or
+     * option it does not offer (a recovery offers no approve), a restart list naming someone twice,
+     * someone its choice may not restart or leaving out someone it must, a conflicting reuse of the
+     * operation id, an instance that cannot execute, and a selected step that cannot be entered, whose
+     * reason names the missing binding, evidence that could not be acquired included. A selected entry that binds evidence has it
+     * acquired before the send; the send's write plans it again with that evidence.
+     */
+    decide(request: DecideRequest, actor: string): Promise<InstanceView>;
+    /**
+     * Cancels the instance on root `instanceId`. The cancellation is admitted first, in a write of its
+     * own that closes assignment authority: refused with {@link WorkflowRefusedError} once the instance
+     * ended, under another cancellation, or for a conflicting reuse of the operation id. Then the
+     * root's operation is cancelled, which clears its queued input, its commands are stopped, and the
+     * terminal row is written once the evidence holds: its run released, and every command it
+     * recorded known to have ended. A failed stop or an unknown termination leaves it blocked on
+     * cleanup, named in the view; the same operation again tries the cleanup again. Resolves with the
+     * instance as it then stands. Available whatever is registered.
+     */
+    cancel(request: CancelRequest, actor: string): Promise<InstanceView>;
+    /**
+     * A person's Stop of root `threadId`, through the host's own cancel of it (`cancel`), which
+     * composes the rows this gives beside delegations' stop obligations, which stop the tasks for good.
+     * The children of the current attempt's open isolated assignments are held loaded first, so the
+     * cancel's write reads what each shows then, and the rows decide there what the Stop met
+     * ({@link stopFact}): an acceptance before it stands; any other isolated work open is superseded
+     * with the root's own assignment, and the attempt recovers (cause `stop`), counting nothing; a
+     * result ready before it whose transition is still owed enters any isolated work it opens
+     * recovering. Nothing for a root running no workflow, a root-only attempt, which stays active
+     * across the Stop, or an attempt already recovering, whose decision, cause and subject a repeated
+     * Stop keeps. The row is declared policy state, so a call authorized under the instance as the
+     * Stop lands decides again.
+     *
+     * The write refuses, and the Stop is prepared again and its cancel made again, when what it meets
+     * is not what was held: another attempt, or a child of the attempt that is not loaded, whose
+     * acceptance would otherwise go unread. Rejects with what the cancel rejects with, or once the
+     * attempt kept changing.
+     */
+    stop(threadId: string, reason: string, cancel: StopCancel): Promise<void>;
+    /** What a Stop of `threadId` meets now: the current attempt, and its open isolated assignments' children that exist. */
+    private stopping;
+    /**
+     * The Stop's rows, inside its write: refused ({@link StaleStopError}) when the attempt it meets is
+     * not the one `prepared` held, or one of its children is not loaded.
+     */
+    private stopRows;
+    /** The instance on `threadId`, which the caller holds. */
+    private state;
+    /** The instance as a host reads it: an owned, frozen copy, never a reference into the fold. */
+    private view;
+    /** The one evidence barrier of the instance on `threadId` ({@link barrierOf}), with its participants' starts in flight. */
+    private barrier;
+    /** The definition `state` executes by, or `undefined` while it cannot continue on what is registered ({@link heldBy}). */
+    private executable;
+    /**
+     * What derived reads of `state` take its procedure from: the definition it executes by, or, while
+     * it is held, the copy recorded at its opening, which renders and is never executed.
+     */
+    private procedure;
+    private planDecision;
+    /** A decision's plan, with the evidence its selected entry needs acquired; cancelled, it is refused. */
+    private prepareDecision;
+    /** What the instance does on its own now, with `evidence` for the entry it owes; `none` when it cannot execute. */
+    private owed;
+    /**
+     * Writes the transition the instance owes on its own, if any: a follow-up send whose input is the
+     * scheduling input of the root assignment it opens, with a `fresh` wake that releases no hold,
+     * or else a notice the root reads at its next turn. An entry that binds evidence has it acquired
+     * first; one it refuses is kept as the instance's entry refusal until a provider's notice tries
+     * again, and one cancelled writes nothing. Nothing is acquired when nothing is owed, such as after
+     * an entry was recorded: replay reads what that entry recorded. Decided again inside the write; a
+     * send whose id is known, or whose transition is no longer owed, writes nothing.
+     */
+    private advance;
+    /**
+     * Why a write must not record `rows` now, rechecked inside it: a provider an entry among them
+     * depends on cannot serve the instance's pin (`Providers.problem`): an evidence binding its step
+     * declares, or a check its assignments list. `null` when every one can.
+     */
+    private entryProblem;
+    /** Why an opening must not be recorded now: a provider it pinned cannot serve its pin; `null` when all can. */
+    private pinsProblem;
+    /**
+     * Runs `plan` with the evidence the entry it plans needs: acquired outside any write, for exactly
+     * the transition and attempt it names, then planned again with it, and acquired again when the
+     * instance moved on meanwhile. Returns the plan with the evidence it was made with, which the
+     * write's own plan must be made with too.
+     */
+    private withEvidence;
+    private send;
+    /**
+     * `row`'s input: the scheduling input naming the root assignment the transition opens, or a notice
+     * of what happened, with the host decision that made it when one did.
+     */
+    private transition;
+    /**
+     * The cleanup of an admitted cancellation, once at a time per instance: the root's operation
+     * cancelled (`cleanup`, which holds nothing), with, in that cancel's write, delegations' stop
+     * obligation over every sub-agent task under the root, participants' included; then the commands
+     * of every thread under the root stopped; and the terminal row written once the evidence holds
+     * ({@link finishCleanup}). Work still ending finishes it later, as its rows land.
+     */
+    private cleanUp;
+    private runCleanup;
+    /**
+     * Writes an admitted cancellation's terminal row, decided inside its write, once nothing runs the
+     * root (no run or other operation holds it, read as the write is decided, so whatever operation a
+     * cancel captured, a retry's included, has released it) and everything under the root is known to
+     * have ended ({@link barrierOf}); otherwise nothing, and the instance stays blocked on
+     * cleanup until a later row under it, or the root's next run event, lets this decide again. The
+     * one rule every path to the terminal row takes.
+     */
+    private finishCleanup;
+    /**
+     * Whether the constraint governs `summary`'s thread: a workflow's root, or any thread under one by
+     * origin, which core's readiness alone would let run while its root is held (decision 12 of the
+     * slice-2 plan): only owner readiness passes down, never what this constraint says of the root.
+     */
+    private governs;
+    /**
+     * The constraint on a workflow's root and every thread under it: an instance that has not ended
+     * runs only on a definition registered under its id that it can continue on ({@link heldBy}), so
+     * all of them are held while there is none; and while a check an open assignment's entry
+     * recorded has no provider that serves the pin it recorded, which would drop the check, the
+     * thread working that assignment is held with the threads its line started: the root and its
+     * ordinary descendants for the root's checks, an isolated participant's child and its descendants
+     * for its own. A completed or cancelled instance is
+     * ordinary chat and holds nothing. A root the repair failed on is held with its error, whatever
+     * its instance says. Registration is fixed for this mount, so its hold changes only
+     * with a remount, which registers again; a provider's notice decides a check's hold again.
+     */
+    private evaluate;
+    /**
+     * Asks core to decide again every thread under the workflow root `root`, whose holds, and the
+     * owner's say on whose tasks, read the root's instance.
+     */
+    private governedChanged;
+    /** What the owner's say on a running task of `root` reads: the root's catalog entry, which needs nothing loaded. */
+    private runnable;
+    /**
+     * A provider's notice: each instance whose open assignments list a check is decided again, its root
+     * and every thread under it, and reconciled, as is each whose transition an entry refusal held, so
+     * a provider that returns resumes what it blocked, a start it held included. A disposed provider
+     * stays missing until a remount binds one.
+     */
+    private providerChanged;
+    /**
+     * What a row asks for: on a root, after a row of its instance or a turn ending that may have
+     * accepted its result, a reconciliation; under a root whose cancellation's cleanup is unfinished,
+     * or one of whose starts waits on a slot or a previous task, a row that may settle work asks for
+     * that cleanup's end, or a reconciliation that starts it. A participant's task settling is told by
+     * delegations (`Participants`), which asks for its root's reconciliation.
+     */
+    private onRow;
+    /**
+     * One reconciliation of the instance on `root` at a time, never waiting on a model turn: one asked
+     * for while it runs runs once more after it. With the root held: an admitted cancellation's
+     * cleanup end decided again; otherwise the observations its participants' children owe it
+     * written, the transition it owes on its own routed, and each isolated task it owes started, in
+     * the background ({@link Participants.dispatch}). Nothing before the repair, which reconciles every
+     * root, nor once shutdown began, nor on a root the repair failed on.
+     */
+    private reconcile;
+    /**
+     * Records delegations' refusal for good of `assignment`'s start as its attempt's recovery: an
+     * observation, decided again inside the root's write, with the children it reads held. Written
+     * only while the assignment still waits for its start, open in the current attempt with no task
+     * on its child, and, for a child that exists, while delegations still will not continue it.
+     */
+    private refused;
+    /**
+     * Writes the observations the root owes of its participants' children (`observations.ts`), with
+     * those children retained so the write reads them: decided again inside it from what they record,
+     * so an observation carries exactly what its child shows, once per task; one that ends a task
+     * without acceptance stops its unfinished siblings' tasks in the same write. The caller holds the root.
+     */
+    private observe;
+    private track;
+    /**
+     * What a crash or a remount left, before anything runs: each instance's unfinished cancellation
+     * resumed, and every other one reconciled ({@link reconcile}): the observations of its
+     * participants' children it missed written, the transition it owes on its own sent, and the
+     * isolated tasks it owes started, a start a crash cut off adopting the task it committed. Every
+     * root requiring this plugin is read; reconciliation starts here.
+     *
+     * A failure is the instance's alone: reported with its root, which stays held with the error
+     * ({@link evaluate}) and is not tried again until a remount, and the repair goes on to the next
+     * root, so the owner becomes ready for every other. A root missing from the catalog refresh is
+     * held by its absent entry.
+     */
+    private repair;
+    /**
+     * Why the repair failed on the root `root`, or `null`: the one question every path that would let
+     * its instance progress asks, its constraint, its reconciliation and its participants' starts,
+     * and every write of its rows, decided again inside that write, which then writes nothing on it:
+     * a refusal's or an observation's, a transition, a decision, a cancellation and its cleanup, and
+     * a person's Stop, whose own cancel still lands without the instance's row.
+     */
+    private quarantined;
+    /** Refuses a host operation on the root `root` while it is quarantined ({@link WorkflowRefusedError}). */
+    private refuseQuarantined;
+    /** Runs `work` with `threadId` loaded and held. */
+    private holding;
+    /** Runs `work` with `members` loaded and held, read again as the retention asks. */
+    private retaining;
+    /** `threadId` and every thread under it, as the catalog lists them now: what a retention of a root's work reads. */
+    private subtree;
+    /**
+     * Cancels the acquisitions in flight and waits for them, and lets the reconciliations, participants'
+     * starts, follow-up sends and cleanups under way land while the journal takes their rows, starting
+     * none; a transition whose evidence was cancelled, or a start that did not land, is owed again at
+     * the next mount's repair.
+     */
+    private shutdown;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import type { Context } from '@leuduan/cordis';
+import { type Governance } from './policy.js';
+/**
+ * Mounts submission on the application root: `submit_workflow_output`, registered in the root's
+ * scope and granted to no agent (each instance root's and participant child's activation grants it,
+ * `policy.ts`), and the stop check that reminds a thread to submit.
+ */
+export declare function acceptSubmissions(ctx: Context, governance: Governance): void;