@fungi.computer/braid 0.0.0-stage → 0.1.0

package/dist/runtime/graph-start.d.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import * as S from "effect/Schema";
+import { type ExecutionPlan, type Issue } from "../index.js";
+import type { WorkflowCatalogEntry } from "./ports.js";
+/** A stored publication selected by its admitted publisher App. */
+export declare const workflowPublicationSelectionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    workflowId: z.ZodString;
+    version: z.ZodNumber;
+    digest: z.ZodString & z.ZodType<string & {
+        readonly appReleaseKind: "Sha256Digest";
+    }, string, z.core.$ZodTypeInternals<string & {
+        readonly appReleaseKind: "Sha256Digest";
+    }, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    workflowId: z.ZodString;
+    commit: z.ZodString;
+    digest: z.ZodString & z.ZodType<string & {
+        readonly appReleaseKind: "Sha256Digest";
+    }, string, z.core.$ZodTypeInternals<string & {
+        readonly appReleaseKind: "Sha256Digest";
+    }, string>>;
+}, z.core.$strict>]>;
+/** Published starts retain the original document and its concrete stored row identity. */
+export declare const graphStartRequestSchema: S.Union<readonly [S.Struct<{
+    readonly definition: S.Unknown;
+    readonly published: S.optionalKey<S.Never>;
+    readonly requestId: S.String;
+    readonly bindings: S.declare<Record<string, string | {
+        kind: "team-source";
+    }>, Record<string, string | {
+        kind: "team-source";
+    }>>;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly delivery: S.optionalKey<S.Struct<{
+        readonly agentId: S.String;
+        readonly sessionId: S.String;
+    }>>;
+}>, S.Struct<{
+    readonly definition: S.Codec<S.Json, S.Json, never, never>;
+    readonly published: S.declare<{
+        workflowId: string;
+        commit: string;
+        digest: string & {
+            readonly appReleaseKind: "Sha256Digest";
+        };
+    }, unknown>;
+    readonly requestId: S.String;
+    readonly bindings: S.declare<Record<string, string | {
+        kind: "team-source";
+    }>, Record<string, string | {
+        kind: "team-source";
+    }>>;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly delivery: S.optionalKey<S.Struct<{
+        readonly agentId: S.String;
+        readonly sessionId: S.String;
+    }>>;
+}>]>;
+export type GraphStartRequest = typeof graphStartRequestSchema.Type;
+export type GraphCompileResult = Readonly<{
+    kind: "invalid";
+    issues: readonly Issue[];
+}> | Readonly<{
+    kind: "compiled";
+    plan: ExecutionPlan;
+}>;
+/**
+ * Compile a definition against the member's live catalog. The App supplies
+ * only references to installations; each installation's App id and method
+ * digests come from the catalog, so a stale or foreign binding is an issue,
+ * never a guess.
+ */
+export declare function compileForMember(entries: readonly WorkflowCatalogEntry[], request: Omit<GraphStartRequest, "definition" | "published"> & Readonly<{
+    definition: unknown;
+}>): Promise<GraphCompileResult>;
+/**
+ * The highest effect any node in the compiled plan uses on each bound
+ * installation, subgraphs included (`requiredBindings` already spans every
+ * graph). A read-only binding keeps `"read"`; any write or external effect
+ * raises it to `"write"`. Pure projection of the plan, never a live grant.
+ */
+export declare function planInstallationLevels(plan: Pick<ExecutionPlan, "requiredBindings">): readonly Readonly<{
+    installationId: string;
+    level: "read" | "write";
+}>[];
+/** One run per (Team, member, App request id); a repeat replays it. */
+export declare function memberRunIdentity(teamId: string, memberId: string, requestId: string): Promise<Readonly<{
+    requestId: string;
+    runId: string;
+}>>;

package/dist/runtime/graph-start.js

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { bindingsSelectionSchema, workflowBindingSchema, } from "../git-access.js";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
+import { workflowIdSchema } from "../workflow-id.js";
+import * as S from "effect/Schema";
+import { compile, contentDigest, workflowDefinitionSchema, } from "../index.js";
+import { workflowRunDeliverySchema } from "./graph-contract.js";
+const id = S.String.pipe(S.check(S.isMinLength(1)), S.check(S.isMaxLength(256)));
+/** A stored publication selected by its admitted publisher App. */
+export const workflowPublicationSelectionSchema = z.union([
+    z.strictObject({
+        workflowId: workflowIdSchema,
+        version: z.number().int().positive(),
+        digest: z.string().refine(S.is(sha256DigestSchema)),
+    }),
+    z.strictObject({
+        workflowId: workflowIdSchema,
+        commit: gitSha1Schema,
+        digest: z.string().refine(S.is(sha256DigestSchema)),
+    }),
+]);
+const startFields = {
+    requestId: id,
+    /** Canonical installation selections or explicit Team-source namespaces. */
+    bindings: S.declare((value) => bindingsSelectionSchema.safeParse(value).success),
+    input: S.JsonObject,
+    /** Where the run's ending is reported; absent reports nowhere. */
+    delivery: S.optionalKey(workflowRunDeliverySchema),
+};
+/** Published starts retain the original document and its concrete stored row identity. */
+export const graphStartRequestSchema = S.Union([
+    S.Struct({
+        ...startFields,
+        definition: S.Unknown,
+        published: S.optionalKey(S.Never),
+    }),
+    S.Struct({
+        ...startFields,
+        definition: S.Json,
+        published: S.declare((value) => workflowPublicationSelectionSchema.options[1].safeParse(value).success),
+    }),
+]);
+/**
+ * Compile a definition against the member's live catalog. The App supplies
+ * only references to installations; each installation's App id and method
+ * digests come from the catalog, so a stale or foreign binding is an issue,
+ * never a guess.
+ */
+export async function compileForMember(entries, request) {
+    const byInstallation = new Map(entries.map((entry) => [entry.installationId, entry]));
+    const catalog = {};
+    const bindings = {};
+    for (const [ref, selection] of Object.entries(request.bindings)) {
+        const installation = bindingsSelectionSchema.valueType.options[0].safeParse(selection);
+        if (!installation.success) {
+            bindings[ref] = workflowBindingSchema.parse(selection);
+            continue;
+        }
+        const installationId = installation.data;
+        const entry = byInstallation.get(installationId);
+        if (entry === undefined)
+            return {
+                kind: "invalid",
+                issues: [
+                    {
+                        code: "binding",
+                        message: "Installation is not available to you",
+                    },
+                ],
+            };
+        catalog[entry.appId] =
+            entry.events === undefined
+                ? { methods: entry.methods }
+                : { methods: entry.methods, events: entry.events };
+        bindings[ref] = { appId: entry.appId, installationId };
+    }
+    let definition;
+    try {
+        definition = S.decodeUnknownSync(workflowDefinitionSchema)(request.definition, { onExcessProperty: "error" });
+    }
+    catch (cause) {
+        if (!S.isSchemaError(cause))
+            throw cause;
+        return {
+            kind: "invalid",
+            issues: [{ code: "schema", message: "Definition failed v1 decoding" }],
+        };
+    }
+    const result = await compile(definition, catalog, bindings);
+    return result.ok
+        ? { kind: "compiled", plan: result.plan }
+        : { kind: "invalid", issues: result.issues };
+}
+/**
+ * The highest effect any node in the compiled plan uses on each bound
+ * installation, subgraphs included (`requiredBindings` already spans every
+ * graph). A read-only binding keeps `"read"`; any write or external effect
+ * raises it to `"write"`. Pure projection of the plan, never a live grant.
+ */
+export function planInstallationLevels(plan) {
+    const levels = new Map();
+    for (const bound of plan.requiredBindings) {
+        if (levels.get(bound.installationId) === "write")
+            continue;
+        levels.set(bound.installationId, bound.effect === "read" ? "read" : "write");
+    }
+    return [...levels.entries()]
+        .map(([installationId, level]) => ({ installationId, level }))
+        .sort((a, b) => a.installationId.localeCompare(b.installationId));
+}
+/** One run per (Team, member, App request id); a repeat replays it. */
+export async function memberRunIdentity(teamId, memberId, requestId) {
+    const digest = await contentDigest([
+        "fungi.workflow/v1 start",
+        teamId,
+        memberId,
+        requestId,
+    ]);
+    return {
+        requestId: digest,
+        runId: "run_" + digest.slice("sha256:".length, 39),
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./graph-contract.js";
+export * from "./graph-run-store.js";
+export * from "./graph-dispatch.js";
+export * from "./graph-start.js";
+export * from "./ports.js";
+export * from "./git-pass-contract.js";
+export * from "./git-pass.js";
+export * from "./git-pass-store.js";
+export * from "./bindings.js";
+export * from "./run-authority.js";
+export * from "./run-ceiling.js";
+export * from "./trigger-owner.js";
+export * from "./trigger-plans.js";
+export * from "./trigger-run-reservations.js";
+export * from "./schedules.js";
+export * from "./trigger-router.js";
+export * from "./run-owner.js";
+export * from "./capture.js";
+export * from "./arming-authority.js";
+export * from "./run-report.js";

package/dist/runtime/index.js

@@ -0,0 +1,20 @@
+export * from "./graph-contract.js";
+export * from "./graph-run-store.js";
+export * from "./graph-dispatch.js";
+export * from "./graph-start.js";
+export * from "./ports.js";
+export * from "./git-pass-contract.js";
+export * from "./git-pass.js";
+export * from "./git-pass-store.js";
+export * from "./bindings.js";
+export * from "./run-authority.js";
+export * from "./run-ceiling.js";
+export * from "./trigger-owner.js";
+export * from "./trigger-plans.js";
+export * from "./trigger-run-reservations.js";
+export * from "./schedules.js";
+export * from "./trigger-router.js";
+export * from "./run-owner.js";
+export * from "./capture.js";
+export * from "./arming-authority.js";
+export * from "./run-report.js";

package/dist/runtime/ports.d.ts

@@ -0,0 +1,156 @@
+import type { Pending } from "@fungi.computer/agar/backend-definition";
+import type { ResultRow } from "@fungi.computer/gills";
+import type { RunCeiling } from "./run-ceiling.js";
+import type { Catalog } from "../index.js";
+import type * as Schema from "effect/Schema";
+import type { GraphNodeContext, WorkflowRunContext } from "./graph-contract.js";
+/** One installed App's methods as a member's Workflows may call them. */
+export type WorkflowCatalogEntry = Readonly<{
+    installationId: string;
+    appId: string;
+    displayName: string;
+    icon?: string;
+    /** Requests declared by the current verified Release, never installation grants. */
+    capabilities?: RunCeiling["nodes"][number]["capabilities"];
+    /** The host projects its current workflow.publish grant decision, not declaration metadata. */
+    workflowPublishGranted?: boolean;
+    /** Current workflow.run + approved WORKFLOWS/runGraph host decision; absent refuses. */
+    workflowRunGranted?: boolean;
+    methods: Catalog[string]["methods"];
+    events?: NonNullable<Catalog[string]["events"]>;
+}>;
+/** One graph node's App call, as the run's frozen plan names it. */
+export type WorkflowAppCall = (GraphNodeContext | WorkflowRunContext) & Readonly<{
+    installationId: string;
+    appId: string;
+    method: string;
+    methodDigest: string;
+    input: Schema.Json;
+    /** The run's pinned Computer, if any. */
+    computerId: string | null;
+    /** Host-captured operations from this stored run, never method input. */
+    bindingCeiling: RunCeiling["nodes"][number]["bindings"];
+}>;
+/** The engine's refusal vocabulary (Braid dispatch results). */
+export type WorkflowAppCallResult = Pending | Readonly<{
+    kind: "complete";
+    output: Schema.Json;
+    costMilliunits: number;
+    /** How the finished call reads to a person, when the App declares a presentation. */
+    row?: ResultRow;
+}> | Readonly<{
+    kind: "refused";
+    code: "not_granted" | "invalid_input" | "invalid_output" | "revoked" | "unknown_method";
+}> | Readonly<{
+    kind: "unavailable";
+}>;
+/** Delivery belongs to the host; saved review state belongs to the runtime. */
+export type ReviewPort = Readonly<{
+    notify(review: import("../execution.js").GraphReview): Promise<void>;
+    settle(key: Pick<import("../execution.js").GraphReview, "runId" | "nodeId" | "iteration">, state: "answered" | "delivered" | "timed_out" | "closed"): Promise<void>;
+}>;
+/** Host facts are admitted by the host, never decoded from Workflow input. */
+export type NodeInvoker<Facts> = Readonly<{
+    invoke(actor: import("@fungi.computer/puffball/app-method-runtime").HostActor, installationId: string, method: string, input: Schema.Json, facts: Facts): Promise<WorkflowAppCallResult>;
+}>;
+/** The host keeps its existing initiator and captured-grant representations. */
+export type RunAuthority<Initiator, Ceiling> = Readonly<{
+    resolve(initiator: Initiator): Promise<Readonly<{
+        kind: "admitted";
+        actor: Extract<import("@fungi.computer/puffball/app-method-runtime").HostActor, {
+            kind: "member";
+        }>;
+        ceiling: Ceiling;
+    }> | Readonly<{
+        kind: "refused";
+        code: "not_granted" | "revoked";
+    }>>;
+    stillAttached(initiator: Initiator): Promise<boolean>;
+}>;
+/** Shared lifecycle owners use host admission and the host's existing alarm. */
+export type WorkflowLifecyclePorts = Readonly<{
+    authorize(memberId: string, installationId: string): Promise<void>;
+    wake(due: number | null): Promise<void>;
+    commit<A>(body: () => A): Promise<A>;
+}>;
+/** Existing start result; published-selection metadata is supplied by its host. */
+export type GraphStartReply = Readonly<{
+    kind: "invalid";
+    issues: readonly import("../validate.js").Issue[];
+}> | Readonly<{
+    kind: "started" | "replay" | "conflict";
+    runId: string;
+    planDigest: string;
+}> | Readonly<{
+    kind: "refused";
+    reason: string;
+}>;
+/** One start port; hosts retain the protected invocation context. */
+export type RunStarter<Context, Request = import("./graph-start.js").GraphStartRequest, Reply = GraphStartReply> = Readonly<{
+    start(context: Context, request: Request): Promise<Reply>;
+}>;
+/** An admitted host delivers reports to the originating session, idempotently. */
+export type RunReporter<Initiator> = Readonly<{
+    report(initiator: Initiator, runId: string, event: Readonly<{
+        kind: "first-review";
+        review: import("../execution.js").GraphReview;
+    }> | Readonly<{
+        kind: "complete";
+        output: Schema.Json;
+    }> | Readonly<{
+        kind: "failed";
+        error: Readonly<{
+            name: string;
+            message: string;
+        }>;
+    }>): Promise<void>;
+}>;
+/** An immutable published document resolved by its admitted host library. */
+export type PublishedDefinition = Readonly<{
+    workflowId: string;
+    definition: import("../schema.js").WorkflowDefinition;
+    commit: string;
+    version: number | null;
+    /** Original stored publication digest, validated by the host before compilation. */
+    digest: string;
+}>;
+export type WorkflowPublicationSelector = Readonly<{
+    workflowId: string;
+}> & (Readonly<{
+    version: number;
+}> | Readonly<{
+    commit: string;
+}>);
+/** Context holds the host-selected library and access; a saved copy is not admission. */
+export type PublishedDefinitionPort<Context> = Readonly<{
+    resolve(context: Context, selector: WorkflowPublicationSelector): Promise<PublishedDefinition | null>;
+}>;
+/** Transient host-issued Git capability; this context is never persisted or guest input. */
+export type WorkflowPublicationContext = Readonly<{
+    memberId: string;
+    installationId: string;
+    computerId: string;
+    git: import("@fungi.computer/agar/git").GitBinding;
+}>;
+/** Only the operations the shared trigger owner consumes from the shared run owner. */
+export type WorkflowTriggerRunPorts = Readonly<{
+    member(memberId: string): Promise<{
+        membershipVersion: number;
+    }>;
+    memberComputer(memberId: string, computerId: string): Promise<boolean>;
+    catalog(memberId: string): Promise<readonly WorkflowCatalogEntry[]>;
+    /** Whether this member may have run endings reported to the Agent Session. */
+    admitDelivery(memberId: string, delivery: import("./graph-contract.js").WorkflowRunDelivery): Promise<boolean>;
+    triggerPlans: ReturnType<typeof import("./trigger-plans.js").createTriggerPlans>;
+    startCachedGraph(binding: import("./trigger-owner.js").ArmedWorkflowTrigger, request: Pick<import("./graph-start.js").GraphStartRequest, "requestId" | "input"> & {
+        /** The firing event's repository, evaluated from the armed trigger. */
+        triggerRepository?: string;
+    }): Promise<Exclude<GraphStartReply, {
+        kind: "invalid";
+    }>>;
+}>;
+/** Hosts retain their existing error vocabulary and denial classification. */
+export type WorkflowErrorPort = Readonly<{
+    denied(): Error;
+    isDenied(cause: Error): boolean;
+}>;

package/dist/runtime/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/run-authority.d.ts

@@ -0,0 +1,60 @@
+import type { NodeAdmissionResult } from "../execution.js";
+import type { ExecutionPlan } from "../index.js";
+import type { HostActor } from "@fungi.computer/puffball/app-method-runtime";
+import type { RunAuthority, WorkflowCatalogEntry } from "./ports.js";
+import type { RunCeiling } from "./run-ceiling.js";
+import type { GraphRun, WorkflowMemberInitiator, WorkflowAgentInitiator, WorkflowKeyInitiator } from "./graph-contract.js";
+export type { WorkflowMemberInitiator, WorkflowAgentInitiator, WorkflowKeyInitiator, };
+/** Host-owned start context after publication resolution and compilation. */
+export type WorkflowRunPreparation = Readonly<{
+    plan: ExecutionPlan;
+    computerId: string | null;
+}> & (Readonly<{
+    initiatedBy: WorkflowMemberInitiator;
+    source: "manual" | "schedule" | "event";
+    libraryInstallationId?: string;
+    /** The firing event's repository; only the trigger owner supplies it. */
+    triggerRepository?: string;
+}> | Readonly<{
+    initiatedBy: WorkflowAgentInitiator;
+    source: "agent";
+    libraryInstallationId: string;
+}> | Readonly<{
+    initiatedBy: WorkflowKeyInitiator;
+    source: "key";
+    libraryInstallationId: string;
+}>);
+export type WorkflowRunMember = Readonly<{
+    membershipVersion: number;
+}>;
+export type WorkflowRunAuthority = RunAuthority<WorkflowRunPreparation, RunCeiling> & Readonly<{
+    recheckRun(preparation: WorkflowRunPreparation): Promise<NodeAdmissionResult>;
+    member(memberId: string): Promise<WorkflowRunMember>;
+    memberComputer(memberId: string, computerId: string): Promise<boolean>;
+    catalog(memberId: string): Promise<readonly WorkflowCatalogEntry[]>;
+}>;
+/** Every check and capture is required; no role, creator or binding default grants access. */
+export type WorkflowRunAuthorityPorts = Readonly<{
+    member(memberId: string): Promise<WorkflowRunMember | null>;
+    memberComputer(memberId: string, computerId: string): Promise<boolean>;
+    catalog(memberId: string): Promise<readonly WorkflowCatalogEntry[]>;
+    admitAgent(preparation: Extract<WorkflowRunPreparation, {
+        source: "agent";
+    }>): Promise<boolean>;
+    /** Absent on a host that never admits key-sourced runs; never a default grant. */
+    admitKey?(preparation: Extract<WorkflowRunPreparation, {
+        source: "key";
+    }>): Promise<boolean>;
+    capture(preparation: WorkflowRunPreparation, actor: Extract<HostActor, {
+        kind: "member";
+    }>, member: WorkflowRunMember): Promise<RunCeiling | null>;
+    denied(): Error;
+}>;
+/** Shared admission and capture ordering; hosts supply their real human and attachment checks. */
+export declare function createWorkflowRunAuthority(ports: WorkflowRunAuthorityPorts): WorkflowRunAuthority;
+/**
+ * Rebuild the preparation a stored run was admitted with, from its recorded
+ * `source`/`initiatedBy`, for a later recheck. A run whose source and
+ * initiator kind disagree is corrupt, not a recoverable shape.
+ */
+export declare function preparationFromRun(run: Pick<GraphRun, "source" | "initiatedBy" | "plan" | "computerId" | "teamId">, libraryInstallationId: string | undefined): WorkflowRunPreparation;

package/dist/runtime/run-authority.js

@@ -0,0 +1,145 @@
+import { decodeWorkflowRunMember } from "./run-member.js";
+import { runCeilingSchema } from "./run-ceiling.js";
+import * as S from "effect/Schema";
+import * as Result from "effect/Result";
+/** Shared admission and capture ordering; hosts supply their real human and attachment checks. */
+export function createWorkflowRunAuthority(ports) {
+    const readMember = async (id) => decodeWorkflowRunMember(await ports.member(id));
+    const member = async (id) => {
+        const current = await readMember(id);
+        if (current === null)
+            throw ports.denied();
+        return current;
+    };
+    const memberComputer = async (id, computerId) => {
+        const admitted = await readMember(id);
+        if (admitted === null)
+            return false;
+        const allowed = await ports.memberComputer(id, computerId);
+        const current = await readMember(id);
+        return allowed && current?.membershipVersion === admitted.membershipVersion;
+    };
+    const memberId = (preparation) => preparation.initiatedBy.kind === "member"
+        ? preparation.initiatedBy.memberId
+        : preparation.initiatedBy.grantorMemberId;
+    const admitKey = (preparation) => ports.admitKey ? ports.admitKey(preparation) : Promise.resolve(false);
+    const stillAttached = async (preparation) => {
+        if ((await readMember(memberId(preparation))) === null)
+            return false;
+        if (preparation.computerId !== null &&
+            !(await memberComputer(memberId(preparation), preparation.computerId)))
+            return false;
+        if (preparation.source === "agent")
+            return ports.admitAgent(preparation);
+        if (preparation.source === "key")
+            return admitKey(preparation);
+        return true;
+    };
+    return {
+        async recheckRun(preparation) {
+            const id = memberId(preparation);
+            const before = await readMember(id);
+            if (before === null)
+                return { kind: "refused", code: "member_revoked" };
+            if (preparation.computerId !== null) {
+                const allowed = await ports.memberComputer(id, preparation.computerId);
+                const afterComputer = await readMember(id);
+                if (afterComputer?.membershipVersion !== before.membershipVersion)
+                    return { kind: "refused", code: "member_revoked" };
+                if (!allowed)
+                    return { kind: "refused", code: "computer_revoked" };
+            }
+            if (preparation.source === "agent" &&
+                !(await ports.admitAgent(preparation)))
+                return { kind: "refused", code: "revoked" };
+            if (preparation.source === "key" && !(await admitKey(preparation)))
+                return { kind: "refused", code: "revoked" };
+            let runGranted = true;
+            if (preparation.libraryInstallationId !== undefined) {
+                const entries = await ports.catalog(id);
+                runGranted = entries.some((entry) => entry.installationId === preparation.libraryInstallationId &&
+                    entry.workflowRunGranted === true);
+            }
+            const after = await readMember(id);
+            if (after?.membershipVersion !== before.membershipVersion)
+                return { kind: "refused", code: "member_revoked" };
+            return runGranted
+                ? { kind: "admitted" }
+                : { kind: "refused", code: "workflow_run_revoked" };
+        },
+        member,
+        memberComputer,
+        async catalog(id) {
+            const admitted = await member(id);
+            const entries = await ports.catalog(id);
+            const current = await member(id);
+            if (current.membershipVersion !== admitted.membershipVersion)
+                throw ports.denied();
+            return entries;
+        },
+        stillAttached,
+        async resolve(preparation) {
+            const admitted = await readMember(memberId(preparation));
+            if (admitted === null)
+                return { kind: "refused", code: "not_granted" };
+            if (!(await stillAttached(preparation)))
+                return { kind: "refused", code: "not_granted" };
+            const actor = {
+                kind: "member",
+                memberId: memberId(preparation),
+            };
+            const captured = await ports.capture(preparation, actor, admitted);
+            const decoded = S.decodeUnknownResult(runCeilingSchema, {
+                onExcessProperty: "error",
+            })(captured);
+            if (Result.isFailure(decoded))
+                return { kind: "refused", code: "not_granted" };
+            if (!(await stillAttached(preparation)))
+                return { kind: "refused", code: "revoked" };
+            const current = await readMember(actor.memberId);
+            if (current?.membershipVersion !== admitted.membershipVersion)
+                return { kind: "refused", code: "revoked" };
+            return { kind: "admitted", actor, ceiling: decoded.success };
+        },
+    };
+}
+/**
+ * Rebuild the preparation a stored run was admitted with, from its recorded
+ * `source`/`initiatedBy`, for a later recheck. A run whose source and
+ * initiator kind disagree is corrupt, not a recoverable shape.
+ */
+export function preparationFromRun(run, libraryInstallationId) {
+    if (run.source === "agent") {
+        if (run.initiatedBy.kind !== "agent")
+            throw new Error("Workflow run source does not match its initiator");
+        return {
+            initiatedBy: run.initiatedBy,
+            source: "agent",
+            plan: run.plan,
+            computerId: run.computerId,
+            libraryInstallationId: libraryInstallationId ?? run.teamId,
+        };
+    }
+    if (run.source === "key") {
+        if (run.initiatedBy.kind !== "key")
+            throw new Error("Workflow run source does not match its initiator");
+        return {
+            initiatedBy: run.initiatedBy,
+            source: "key",
+            plan: run.plan,
+            computerId: run.computerId,
+            libraryInstallationId: libraryInstallationId ?? run.teamId,
+        };
+    }
+    if (run.initiatedBy.kind !== "member")
+        throw new Error("Workflow run source does not match its initiator");
+    const preparation = {
+        initiatedBy: run.initiatedBy,
+        source: run.source,
+        plan: run.plan,
+        computerId: run.computerId,
+    };
+    return libraryInstallationId === undefined
+        ? preparation
+        : { ...preparation, libraryInstallationId };
+}