@fungi.computer/braid 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,1628 @@
+import * as S from "effect/Schema";
+import { type NodeEvent, type NodeAdmissionResult } from "../execution.js";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type WorkflowRunAuthority } from "./run-authority.js";
+import type { ArmedWorkflowTrigger } from "./trigger-owner.js";
+import { type WorkflowRunContext, type GraphRun, type WorkflowRunDelivery } from "./graph-contract.js";
+import { type StoredWorkflowNode } from "./graph-dispatch.js";
+import type { WorkflowAppCall, WorkflowAppCallResult, WorkflowCatalogEntry } from "./ports.js";
+import { type GraphStartRequest } from "./graph-start.js";
+/** The member can supply a plan, never stored authority or a captured ceiling. */
+export declare const memberCompiledGraphStartSchema: S.Struct<{
+    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;
+    }>>;
+    readonly runId: S.String;
+    readonly computerId: S.NullOr<S.String>;
+    readonly plan: S.Struct<{
+        readonly planDigest: S.String;
+        readonly definition: S.Struct<{
+            readonly format: S.Literal<"fungi.workflow/v1">;
+            readonly title: S.String;
+            readonly description: S.optionalKey<S.String>;
+            readonly apps: S.$Record<S.String, S.Struct<{
+                readonly appId: S.String;
+                readonly role: S.optionalKey<S.String>;
+            }>>;
+            readonly subgraphs: S.optionalKey<S.$Record<S.String, S.Struct<{
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"code">;
+                    readonly source: S.String;
+                    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                    readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                    readonly values: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"app">;
+                    readonly app: S.String;
+                    readonly method: S.String;
+                    readonly methodDigest: S.String;
+                    readonly values: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+                    readonly gitAccess: S.optionalKey<S.declare<{
+                        binding: string;
+                        repository: string;
+                        branches: string[];
+                    } | {
+                        binding: string;
+                        repository: string;
+                        access: "read";
+                    }, {
+                        binding: string;
+                        repository: string;
+                        branches: string[];
+                    } | {
+                        binding: string;
+                        repository: string;
+                        access: "read";
+                    }>>;
+                    readonly retry: S.optionalKey<S.Struct<{
+                        readonly attempts: S.Number;
+                    }>>;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"review">;
+                    readonly title: S.String;
+                    readonly show: S.$Array<S.Struct<{
+                        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                        readonly port: S.String;
+                    }>>;
+                    readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+                    readonly timeout: S.Number;
+                    readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                        readonly id: S.String;
+                        readonly label: S.String;
+                    }>>>;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"condition">;
+                    readonly test: S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"map">;
+                    readonly over: S.Struct<{
+                        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                        readonly port: S.String;
+                    }>;
+                    readonly body: S.String;
+                    readonly concurrency: S.Number;
+                    readonly maxItems: S.Number;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"repeat">;
+                    readonly body: S.String;
+                    readonly maxRounds: S.Number;
+                    readonly until: S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"wait">;
+                    readonly for: S.Number;
+                }>, S.Struct<{
+                    readonly id: S.String;
+                    readonly kind: S.Literal<"transform">;
+                    readonly fields: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+                }>]>>;
+                readonly edges: S.$Array<S.Struct<{
+                    readonly from: S.Struct<{
+                        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                        readonly port: S.String;
+                    }>;
+                    readonly to: S.Struct<{
+                        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                        readonly port: S.String;
+                    }>;
+                }>>;
+                readonly output: S.$Record<S.String, S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>>;
+            }>>>;
+            readonly triggers: S.optionalKey<S.$Array<S.Union<readonly [S.Struct<{
+                readonly id: S.String;
+                readonly on: S.Literal<"webhook">;
+                readonly title: S.optionalKey<S.String>;
+                readonly when: S.optionalKey<S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>>;
+                readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly on: S.Literal<"schedule">;
+                readonly title: S.optionalKey<S.String>;
+                readonly cron: S.Struct<{
+                    readonly expression: S.String;
+                    readonly timeZone: S.String;
+                }>;
+                readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly on: S.Literal<"event">;
+                readonly title: S.optionalKey<S.String>;
+                readonly app: S.String;
+                readonly event: S.String;
+                readonly eventDigest: S.String;
+                readonly when: S.optionalKey<S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>>;
+                readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>>;
+                readonly repository: S.optionalKey<S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+            }>]>>>;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"code">;
+                readonly source: S.String;
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly values: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"app">;
+                readonly app: S.String;
+                readonly method: S.String;
+                readonly methodDigest: S.String;
+                readonly values: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+                readonly gitAccess: S.optionalKey<S.declare<{
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }, {
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }>>;
+                readonly retry: S.optionalKey<S.Struct<{
+                    readonly attempts: S.Number;
+                }>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"review">;
+                readonly title: S.String;
+                readonly show: S.$Array<S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>>;
+                readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+                readonly timeout: S.Number;
+                readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                    readonly id: S.String;
+                    readonly label: S.String;
+                }>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"condition">;
+                readonly test: S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"map">;
+                readonly over: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly body: S.String;
+                readonly concurrency: S.Number;
+                readonly maxItems: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"repeat">;
+                readonly body: S.String;
+                readonly maxRounds: S.Number;
+                readonly until: S.Codec<import("../schema.js").Predicate, import("../schema.js").Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"wait">;
+                readonly for: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"transform">;
+                readonly fields: S.$Record<S.String, S.Codec<import("../schema.js").Mapping, import("../schema.js").Mapping, never, never>>;
+            }>]>>;
+            readonly edges: S.$Array<S.Struct<{
+                readonly from: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly to: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+            }>>;
+            readonly output: S.$Record<S.String, S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+        }>;
+        readonly catalog: S.$Record<S.String, S.Struct<{
+            readonly methods: S.$Record<S.String, S.Struct<{
+                readonly digest: S.String;
+                readonly pending: S.optionalKey<S.Literal<true>>;
+                readonly description: S.String;
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+                readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+                readonly requires: S.$Array<S.String>;
+            }>>;
+            readonly events: S.optionalKey<S.$Record<S.String, S.Struct<{
+                readonly digest: S.String;
+                readonly description: S.String;
+                readonly payload: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            }>>>;
+        }>>;
+        readonly bindings: S.$Record<S.String, S.declare<{
+            kind: "team-source";
+        } | {
+            appId: string;
+            installationId: string;
+        }, {
+            kind: "team-source";
+        } | {
+            appId: string;
+            installationId: string;
+        }>>;
+        readonly estimatedSteps: S.Number;
+        readonly requiredBindings: S.$Array<S.Struct<{
+            readonly pending: S.optionalKey<S.Literal<true>>;
+            readonly description: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+            readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+            readonly requires: S.$Array<S.String>;
+            readonly app: S.String;
+            readonly installationId: S.String;
+            readonly method: S.String;
+        }>>;
+    }>;
+    readonly requestId: S.String;
+}>;
+/** Host-resolved identity of one active installed App node execution. */
+export type WorkflowNodeAdmission = Pick<StoredWorkflowNode, "installationId" | "appId" | "method" | "methodDigest" | "computerId"> & {
+    teamId: string;
+    memberId: string;
+    context: WorkflowRunContext;
+};
+/**
+ * The one Workflow run owner: graph runs, their captured authority, trigger
+ * reservations and revocation. Every run, Storyboard included, is a graph run.
+ */
+export declare function createTeamWorkflowRuns(options: {
+    sql: WatchdogSqliteOwner["sql"];
+    transactionSync: <T>(body: () => T) => T;
+    teamId: () => string;
+    admission: () => "active" | "suspended";
+    errors: Readonly<{
+        app(code: "denied" | "invalid" | "unavailable"): Error;
+        suspended(): Error;
+    }>;
+    /** Required host admission/capture after compilation; callers cannot supply ceilings. */
+    authority: WorkflowRunAuthority;
+    member: (actorId: string) => Promise<{
+        membershipVersion: number;
+    }>;
+    /** Arms prompt delivery of the Computer cleanup a revocation queued. */
+    wake: () => void;
+    /** Graph node App calls, made as the member the run acts for. */
+    callWorkflowApp: (memberId: string, call: WorkflowAppCall) => Promise<WorkflowAppCallResult>;
+    /** Whether a member may pin this Computer to a run they start. */
+    memberComputer: (memberId: string, computerId: string) => Promise<boolean>;
+    /** The App methods this member's Workflows may call, admitted now. */
+    catalog: (memberId: string) => Promise<readonly WorkflowCatalogEntry[]>;
+    /** A current member answering a review, and whether they own the Team. */
+    reviewer: (memberId: string) => Promise<{
+        isOwner: boolean;
+    }>;
+    /** Whether this member may have run endings reported to the Agent Session. */
+    admitDelivery: (memberId: string, delivery: WorkflowRunDelivery) => Promise<boolean>;
+    terminateGraphRun: (runId: string) => Promise<"cancelled" | "terminal">;
+}): {
+    workflowRunOutcome: (rawRunId: string) => "active" | "terminal" | "cancelled" | null;
+    admitWorkflowNode: (rawContext: WorkflowRunContext, rawTarget: {
+        installationId: string;
+        method: string;
+    }) => WorkflowNodeAdmission | null;
+    /** Up to 50 runs of one installation, newest first; `actorId` narrows to one viewer. */
+    listRuns(installationId: string, actorId?: string, workflowId?: string): readonly ({
+        readonly input: {
+            readonly [x: string]: S.Json;
+        };
+        readonly source: "key" | "manual" | "event" | "schedule" | "agent";
+        readonly runId: string;
+        readonly computerId: string | null;
+        readonly plan: {
+            readonly planDigest: string;
+            readonly definition: {
+                readonly input: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly output: {
+                    readonly [x: string]: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                };
+                readonly title: string;
+                readonly format: "fungi.workflow/v1";
+                readonly nodes: readonly ({
+                    readonly id: string;
+                    readonly kind: "code";
+                    readonly source: string;
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly values: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                } | {
+                    readonly values: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                    readonly id: string;
+                    readonly method: string;
+                    readonly kind: "app";
+                    readonly app: string;
+                    readonly methodDigest: string;
+                    readonly gitAccess?: {
+                        binding: string;
+                        repository: string;
+                        branches: string[];
+                    } | {
+                        binding: string;
+                        repository: string;
+                        access: "read";
+                    };
+                    readonly retry?: {
+                        readonly attempts: number;
+                    };
+                } | {
+                    readonly show: readonly {
+                        readonly node: string;
+                        readonly port: string;
+                    }[];
+                    readonly id: string;
+                    readonly title: string;
+                    readonly timeout: number;
+                    readonly kind: "review";
+                    readonly reviewers: "runner" | "owners";
+                    readonly choices?: readonly {
+                        readonly id: string;
+                        readonly label: string;
+                    }[];
+                } | {
+                    readonly id: string;
+                    readonly kind: "condition";
+                    readonly test: import("../schema.js").Predicate;
+                } | {
+                    readonly id: string;
+                    readonly kind: "map";
+                    readonly over: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                    readonly body: string;
+                    readonly concurrency: number;
+                    readonly maxItems: number;
+                } | {
+                    readonly id: string;
+                    readonly kind: "repeat";
+                    readonly body: string;
+                    readonly maxRounds: number;
+                    readonly until: import("../schema.js").Predicate;
+                } | {
+                    readonly id: string;
+                    readonly kind: "wait";
+                    readonly for: number;
+                } | {
+                    readonly id: string;
+                    readonly kind: "transform";
+                    readonly fields: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                })[];
+                readonly edges: readonly {
+                    readonly from: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                    readonly to: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                }[];
+                readonly apps: {
+                    readonly [x: string]: {
+                        readonly appId: string;
+                        readonly role?: string;
+                    };
+                };
+                readonly description?: string;
+                readonly subgraphs?: {
+                    readonly [x: string]: {
+                        readonly input: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly nodes: readonly ({
+                            readonly id: string;
+                            readonly kind: "code";
+                            readonly source: string;
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly output: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly values: {
+                                readonly [x: string]: import("../schema.js").Mapping;
+                            };
+                        } | {
+                            readonly values: {
+                                readonly [x: string]: import("../schema.js").Mapping;
+                            };
+                            readonly id: string;
+                            readonly method: string;
+                            readonly kind: "app";
+                            readonly app: string;
+                            readonly methodDigest: string;
+                            readonly gitAccess?: {
+                                binding: string;
+                                repository: string;
+                                branches: string[];
+                            } | {
+                                binding: string;
+                                repository: string;
+                                access: "read";
+                            };
+                            readonly retry?: {
+                                readonly attempts: number;
+                            };
+                        } | {
+                            readonly show: readonly {
+                                readonly node: string;
+                                readonly port: string;
+                            }[];
+                            readonly id: string;
+                            readonly title: string;
+                            readonly timeout: number;
+                            readonly kind: "review";
+                            readonly reviewers: "runner" | "owners";
+                            readonly choices?: readonly {
+                                readonly id: string;
+                                readonly label: string;
+                            }[];
+                        } | {
+                            readonly id: string;
+                            readonly kind: "condition";
+                            readonly test: import("../schema.js").Predicate;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "map";
+                            readonly over: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                            readonly body: string;
+                            readonly concurrency: number;
+                            readonly maxItems: number;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "repeat";
+                            readonly body: string;
+                            readonly maxRounds: number;
+                            readonly until: import("../schema.js").Predicate;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "wait";
+                            readonly for: number;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "transform";
+                            readonly fields: {
+                                readonly [x: string]: import("../schema.js").Mapping;
+                            };
+                        })[];
+                        readonly edges: readonly {
+                            readonly from: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                            readonly to: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                        }[];
+                        readonly output: {
+                            readonly [x: string]: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                        };
+                    };
+                };
+                readonly triggers?: readonly ({
+                    readonly id: string;
+                    readonly on: "webhook";
+                    readonly input?: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                    readonly title?: string;
+                    readonly when?: import("../schema.js").Predicate;
+                } | {
+                    readonly id: string;
+                    readonly on: "schedule";
+                    readonly cron: {
+                        readonly expression: string;
+                        readonly timeZone: string;
+                    };
+                    readonly input?: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                    readonly title?: string;
+                } | {
+                    readonly id: string;
+                    readonly on: "event";
+                    readonly event: string;
+                    readonly app: string;
+                    readonly eventDigest: string;
+                    readonly input?: {
+                        readonly [x: string]: import("../schema.js").Mapping;
+                    };
+                    readonly title?: string;
+                    readonly when?: import("../schema.js").Predicate;
+                    readonly repository?: import("../schema.js").Mapping;
+                })[];
+            };
+            readonly catalog: {
+                readonly [x: string]: {
+                    readonly methods: {
+                        readonly [x: string]: {
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly output: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly description: string;
+                            readonly requires: readonly string[];
+                            readonly effect: "write" | "external" | "read";
+                            readonly approval: "none" | "queue" | "simulate";
+                            readonly digest: string;
+                            readonly pending?: true;
+                        };
+                    };
+                    readonly events?: {
+                        readonly [x: string]: {
+                            readonly digest: string;
+                            readonly description: string;
+                            readonly payload: {
+                                readonly [x: string]: S.Json;
+                            };
+                        };
+                    };
+                };
+            };
+            readonly bindings: {
+                readonly [x: string]: {
+                    kind: "team-source";
+                } | {
+                    appId: string;
+                    installationId: string;
+                };
+            };
+            readonly estimatedSteps: number;
+            readonly requiredBindings: readonly {
+                readonly input: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly output: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly method: string;
+                readonly description: string;
+                readonly requires: readonly string[];
+                readonly effect: "write" | "external" | "read";
+                readonly installationId: string;
+                readonly app: string;
+                readonly approval: "none" | "queue" | "simulate";
+                readonly pending?: true;
+            }[];
+        };
+        readonly teamId: string;
+        readonly requestId: string;
+        readonly actorId: string;
+        readonly ceiling: {
+            readonly nodes: readonly {
+                readonly level: "write" | "read";
+                readonly bindings: readonly {
+                    readonly name: "BACKGROUND" | "GIT" | "EVENTS" | "APPS" | "WORKFLOWS" | "APP_STORAGE" | "MEDIA" | "COMPUTER" | "INBOX" | "AGENTS";
+                    readonly operations: readonly string[];
+                }[];
+                readonly nodeId: string;
+                readonly capabilities: readonly ("agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
+                readonly graphId?: string;
+            }[];
+            readonly nodeGitAccess: readonly {
+                readonly nodeId: string;
+                readonly gitAccess: {
+                    repository: {
+                        kind: "installation";
+                        installationId: string;
+                        repository: string;
+                    } | {
+                        kind: "team-source";
+                        repository: string;
+                    };
+                    branches: string[];
+                } | {
+                    repository: {
+                        kind: "installation";
+                        installationId: string;
+                        repository: string;
+                    } | {
+                        kind: "team-source";
+                        repository: string;
+                    };
+                    access: "read";
+                };
+                readonly graphId?: string;
+            }[];
+        };
+        readonly initiatedBy: {
+            readonly kind: "member";
+            readonly memberId: string;
+        } | {
+            readonly kind: "agent";
+            readonly agentId: string;
+            readonly sessionId: string;
+            readonly grantorMemberId: string;
+        } | {
+            readonly kind: "key";
+            readonly keyId: string;
+            readonly grantorMemberId: string;
+        };
+        readonly delivery?: {
+            readonly agentId: string;
+            readonly sessionId: string;
+        };
+        readonly trigger?: {
+            readonly workflowId: string;
+            readonly armedBy: string;
+            readonly commit: string;
+            readonly triggerId: string;
+            readonly libraryInstallationId: string;
+            readonly repository?: string;
+            readonly nodeGitAccess?: readonly {
+                readonly nodeId: string;
+                readonly gitAccess: {
+                    repository: {
+                        kind: "installation";
+                        installationId: string;
+                        repository: string;
+                    } | {
+                        kind: "team-source";
+                        repository: string;
+                    };
+                    branches: string[];
+                } | {
+                    repository: {
+                        kind: "installation";
+                        installationId: string;
+                        repository: string;
+                    } | {
+                        kind: "team-source";
+                        repository: string;
+                    };
+                    access: "read";
+                };
+                readonly graphId?: string;
+            }[];
+        };
+        readonly publication?: {
+            readonly installationId: string;
+            readonly workflowId: string;
+            readonly commit: string;
+            readonly digest: string;
+            readonly armedBy: {
+                kind: "member";
+                memberId: string;
+            } | {
+                kind: "agent";
+                agentId: string;
+            } | {
+                kind: "team-key";
+                keyId: string;
+            };
+        };
+        readonly libraryInstallationId?: string;
+    } & {
+        startedAt: number;
+    })[];
+    bindTriggerRun(reservationId: string, rawRunId: string): "bound" | "replay" | "conflict";
+    terminalTriggerRun: (rawRunId: string, outcome?: "terminal" | "cancelled") => void;
+    cancel(memberId: string, rawRunId: string): Promise<{
+        kind: "cancelled" | "terminal";
+    } | {
+        kind: "refused";
+        reason: "denied";
+    }>;
+    pendingWorkflowRunCleanups(): {
+        teamId: string;
+        runId: string;
+        computerId: string;
+    }[];
+    /** Delivery consumer calls this only after durable Computer revocation resolves. */
+    acknowledgeWorkflowRunCleanup(rawRunId: string): void;
+    triggerPlans: {
+        put(binding: ArmedWorkflowTrigger, plan: import("../schema.js").ExecutionPlan): void;
+        read(binding: ArmedWorkflowTrigger): {
+            binding: {
+                installationId: string;
+                workflowId: string;
+                commit: string;
+                digest: string & {
+                    readonly appReleaseKind: "Sha256Digest";
+                };
+                triggerId: string;
+                bindings: Record<string, string | {
+                    kind: "team-source";
+                }>;
+                armedBy: string;
+                armedVia: {
+                    kind: "connector";
+                    agentId: string;
+                    attachmentId: string;
+                    attachmentVersion: number;
+                } | {
+                    kind: "policy";
+                    agentId: string;
+                    policyRevision: string;
+                    grantorMemberId: string;
+                } | null;
+                grantorMembershipVersion: number;
+                installationAuthority: {
+                    selection: {
+                        instanceId: string;
+                        owner: {
+                            kind: "installation" | "deployment";
+                            id: string;
+                        };
+                        appId: string & {
+                            readonly appReleaseKind: "AppId";
+                        };
+                        releaseId: string & {
+                            readonly appReleaseKind: "ReleaseId";
+                        };
+                        authorityVersion: number;
+                    };
+                    artifactDigest: string & {
+                        readonly appReleaseKind: "Sha256Digest";
+                    };
+                };
+                computerId: string;
+                delivery?: {
+                    readonly agentId: string;
+                    readonly sessionId: string;
+                } | undefined;
+                nodeGitAccess?: readonly {
+                    readonly nodeId: string;
+                    readonly gitAccess: {
+                        repository: {
+                            kind: "installation";
+                            installationId: string;
+                            repository: string;
+                        } | {
+                            kind: "team-source";
+                            repository: string;
+                        };
+                        branches: string[];
+                    } | {
+                        repository: {
+                            kind: "installation";
+                            installationId: string;
+                            repository: string;
+                        } | {
+                            kind: "team-source";
+                            repository: string;
+                        };
+                        access: "read";
+                    };
+                    readonly graphId?: string;
+                }[] | undefined;
+            };
+            plan: {
+                readonly planDigest: string;
+                readonly definition: {
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                    };
+                    readonly title: string;
+                    readonly format: "fungi.workflow/v1";
+                    readonly nodes: readonly ({
+                        readonly id: string;
+                        readonly kind: "code";
+                        readonly source: string;
+                        readonly input: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly output: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly values: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                    } | {
+                        readonly values: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly id: string;
+                        readonly method: string;
+                        readonly kind: "app";
+                        readonly app: string;
+                        readonly methodDigest: string;
+                        readonly gitAccess?: {
+                            binding: string;
+                            repository: string;
+                            branches: string[];
+                        } | {
+                            binding: string;
+                            repository: string;
+                            access: "read";
+                        };
+                        readonly retry?: {
+                            readonly attempts: number;
+                        };
+                    } | {
+                        readonly show: readonly {
+                            readonly node: string;
+                            readonly port: string;
+                        }[];
+                        readonly id: string;
+                        readonly title: string;
+                        readonly timeout: number;
+                        readonly kind: "review";
+                        readonly reviewers: "runner" | "owners";
+                        readonly choices?: readonly {
+                            readonly id: string;
+                            readonly label: string;
+                        }[];
+                    } | {
+                        readonly id: string;
+                        readonly kind: "condition";
+                        readonly test: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "map";
+                        readonly over: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                        readonly body: string;
+                        readonly concurrency: number;
+                        readonly maxItems: number;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "repeat";
+                        readonly body: string;
+                        readonly maxRounds: number;
+                        readonly until: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "wait";
+                        readonly for: number;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "transform";
+                        readonly fields: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                    })[];
+                    readonly edges: readonly {
+                        readonly from: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                        readonly to: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                    }[];
+                    readonly apps: {
+                        readonly [x: string]: {
+                            readonly appId: string;
+                            readonly role?: string;
+                        };
+                    };
+                    readonly description?: string;
+                    readonly subgraphs?: {
+                        readonly [x: string]: {
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly nodes: readonly ({
+                                readonly id: string;
+                                readonly kind: "code";
+                                readonly source: string;
+                                readonly input: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly output: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly values: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                            } | {
+                                readonly values: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                                readonly id: string;
+                                readonly method: string;
+                                readonly kind: "app";
+                                readonly app: string;
+                                readonly methodDigest: string;
+                                readonly gitAccess?: {
+                                    binding: string;
+                                    repository: string;
+                                    branches: string[];
+                                } | {
+                                    binding: string;
+                                    repository: string;
+                                    access: "read";
+                                };
+                                readonly retry?: {
+                                    readonly attempts: number;
+                                };
+                            } | {
+                                readonly show: readonly {
+                                    readonly node: string;
+                                    readonly port: string;
+                                }[];
+                                readonly id: string;
+                                readonly title: string;
+                                readonly timeout: number;
+                                readonly kind: "review";
+                                readonly reviewers: "runner" | "owners";
+                                readonly choices?: readonly {
+                                    readonly id: string;
+                                    readonly label: string;
+                                }[];
+                            } | {
+                                readonly id: string;
+                                readonly kind: "condition";
+                                readonly test: import("../schema.js").Predicate;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "map";
+                                readonly over: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                                readonly body: string;
+                                readonly concurrency: number;
+                                readonly maxItems: number;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "repeat";
+                                readonly body: string;
+                                readonly maxRounds: number;
+                                readonly until: import("../schema.js").Predicate;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "wait";
+                                readonly for: number;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "transform";
+                                readonly fields: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                            })[];
+                            readonly edges: readonly {
+                                readonly from: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                                readonly to: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                            }[];
+                            readonly output: {
+                                readonly [x: string]: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                            };
+                        };
+                    };
+                    readonly triggers?: readonly ({
+                        readonly id: string;
+                        readonly on: "webhook";
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                        readonly when?: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly on: "schedule";
+                        readonly cron: {
+                            readonly expression: string;
+                            readonly timeZone: string;
+                        };
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                    } | {
+                        readonly id: string;
+                        readonly on: "event";
+                        readonly event: string;
+                        readonly app: string;
+                        readonly eventDigest: string;
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                        readonly when?: import("../schema.js").Predicate;
+                        readonly repository?: import("../schema.js").Mapping;
+                    })[];
+                };
+                readonly catalog: {
+                    readonly [x: string]: {
+                        readonly methods: {
+                            readonly [x: string]: {
+                                readonly input: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly output: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly description: string;
+                                readonly requires: readonly string[];
+                                readonly effect: "write" | "external" | "read";
+                                readonly approval: "none" | "queue" | "simulate";
+                                readonly digest: string;
+                                readonly pending?: true;
+                            };
+                        };
+                        readonly events?: {
+                            readonly [x: string]: {
+                                readonly digest: string;
+                                readonly description: string;
+                                readonly payload: {
+                                    readonly [x: string]: S.Json;
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly bindings: {
+                    readonly [x: string]: {
+                        kind: "team-source";
+                    } | {
+                        appId: string;
+                        installationId: string;
+                    };
+                };
+                readonly estimatedSteps: number;
+                readonly requiredBindings: readonly {
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly method: string;
+                    readonly description: string;
+                    readonly requires: readonly string[];
+                    readonly effect: "write" | "external" | "read";
+                    readonly installationId: string;
+                    readonly app: string;
+                    readonly approval: "none" | "queue" | "simulate";
+                    readonly pending?: true;
+                }[];
+            };
+            refusal: string | null;
+        } | null;
+        refusal(binding: ArmedWorkflowTrigger): string | null;
+        installation(installationId: string): {
+            binding: {
+                installationId: string;
+                workflowId: string;
+                commit: string;
+                digest: string & {
+                    readonly appReleaseKind: "Sha256Digest";
+                };
+                triggerId: string;
+                bindings: Record<string, string | {
+                    kind: "team-source";
+                }>;
+                armedBy: string;
+                armedVia: {
+                    kind: "connector";
+                    agentId: string;
+                    attachmentId: string;
+                    attachmentVersion: number;
+                } | {
+                    kind: "policy";
+                    agentId: string;
+                    policyRevision: string;
+                    grantorMemberId: string;
+                } | null;
+                grantorMembershipVersion: number;
+                installationAuthority: {
+                    selection: {
+                        instanceId: string;
+                        owner: {
+                            kind: "installation" | "deployment";
+                            id: string;
+                        };
+                        appId: string & {
+                            readonly appReleaseKind: "AppId";
+                        };
+                        releaseId: string & {
+                            readonly appReleaseKind: "ReleaseId";
+                        };
+                        authorityVersion: number;
+                    };
+                    artifactDigest: string & {
+                        readonly appReleaseKind: "Sha256Digest";
+                    };
+                };
+                computerId: string;
+                delivery?: {
+                    readonly agentId: string;
+                    readonly sessionId: string;
+                } | undefined;
+                nodeGitAccess?: readonly {
+                    readonly nodeId: string;
+                    readonly gitAccess: {
+                        repository: {
+                            kind: "installation";
+                            installationId: string;
+                            repository: string;
+                        } | {
+                            kind: "team-source";
+                            repository: string;
+                        };
+                        branches: string[];
+                    } | {
+                        repository: {
+                            kind: "installation";
+                            installationId: string;
+                            repository: string;
+                        } | {
+                            kind: "team-source";
+                            repository: string;
+                        };
+                        access: "read";
+                    };
+                    readonly graphId?: string;
+                }[] | undefined;
+            };
+            plan: {
+                readonly planDigest: string;
+                readonly definition: {
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                    };
+                    readonly title: string;
+                    readonly format: "fungi.workflow/v1";
+                    readonly nodes: readonly ({
+                        readonly id: string;
+                        readonly kind: "code";
+                        readonly source: string;
+                        readonly input: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly output: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly values: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                    } | {
+                        readonly values: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly id: string;
+                        readonly method: string;
+                        readonly kind: "app";
+                        readonly app: string;
+                        readonly methodDigest: string;
+                        readonly gitAccess?: {
+                            binding: string;
+                            repository: string;
+                            branches: string[];
+                        } | {
+                            binding: string;
+                            repository: string;
+                            access: "read";
+                        };
+                        readonly retry?: {
+                            readonly attempts: number;
+                        };
+                    } | {
+                        readonly show: readonly {
+                            readonly node: string;
+                            readonly port: string;
+                        }[];
+                        readonly id: string;
+                        readonly title: string;
+                        readonly timeout: number;
+                        readonly kind: "review";
+                        readonly reviewers: "runner" | "owners";
+                        readonly choices?: readonly {
+                            readonly id: string;
+                            readonly label: string;
+                        }[];
+                    } | {
+                        readonly id: string;
+                        readonly kind: "condition";
+                        readonly test: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "map";
+                        readonly over: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                        readonly body: string;
+                        readonly concurrency: number;
+                        readonly maxItems: number;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "repeat";
+                        readonly body: string;
+                        readonly maxRounds: number;
+                        readonly until: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "wait";
+                        readonly for: number;
+                    } | {
+                        readonly id: string;
+                        readonly kind: "transform";
+                        readonly fields: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                    })[];
+                    readonly edges: readonly {
+                        readonly from: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                        readonly to: {
+                            readonly node: string;
+                            readonly port: string;
+                        };
+                    }[];
+                    readonly apps: {
+                        readonly [x: string]: {
+                            readonly appId: string;
+                            readonly role?: string;
+                        };
+                    };
+                    readonly description?: string;
+                    readonly subgraphs?: {
+                        readonly [x: string]: {
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly nodes: readonly ({
+                                readonly id: string;
+                                readonly kind: "code";
+                                readonly source: string;
+                                readonly input: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly output: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly values: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                            } | {
+                                readonly values: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                                readonly id: string;
+                                readonly method: string;
+                                readonly kind: "app";
+                                readonly app: string;
+                                readonly methodDigest: string;
+                                readonly gitAccess?: {
+                                    binding: string;
+                                    repository: string;
+                                    branches: string[];
+                                } | {
+                                    binding: string;
+                                    repository: string;
+                                    access: "read";
+                                };
+                                readonly retry?: {
+                                    readonly attempts: number;
+                                };
+                            } | {
+                                readonly show: readonly {
+                                    readonly node: string;
+                                    readonly port: string;
+                                }[];
+                                readonly id: string;
+                                readonly title: string;
+                                readonly timeout: number;
+                                readonly kind: "review";
+                                readonly reviewers: "runner" | "owners";
+                                readonly choices?: readonly {
+                                    readonly id: string;
+                                    readonly label: string;
+                                }[];
+                            } | {
+                                readonly id: string;
+                                readonly kind: "condition";
+                                readonly test: import("../schema.js").Predicate;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "map";
+                                readonly over: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                                readonly body: string;
+                                readonly concurrency: number;
+                                readonly maxItems: number;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "repeat";
+                                readonly body: string;
+                                readonly maxRounds: number;
+                                readonly until: import("../schema.js").Predicate;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "wait";
+                                readonly for: number;
+                            } | {
+                                readonly id: string;
+                                readonly kind: "transform";
+                                readonly fields: {
+                                    readonly [x: string]: import("../schema.js").Mapping;
+                                };
+                            })[];
+                            readonly edges: readonly {
+                                readonly from: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                                readonly to: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                            }[];
+                            readonly output: {
+                                readonly [x: string]: {
+                                    readonly node: string;
+                                    readonly port: string;
+                                };
+                            };
+                        };
+                    };
+                    readonly triggers?: readonly ({
+                        readonly id: string;
+                        readonly on: "webhook";
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                        readonly when?: import("../schema.js").Predicate;
+                    } | {
+                        readonly id: string;
+                        readonly on: "schedule";
+                        readonly cron: {
+                            readonly expression: string;
+                            readonly timeZone: string;
+                        };
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                    } | {
+                        readonly id: string;
+                        readonly on: "event";
+                        readonly event: string;
+                        readonly app: string;
+                        readonly eventDigest: string;
+                        readonly input?: {
+                            readonly [x: string]: import("../schema.js").Mapping;
+                        };
+                        readonly title?: string;
+                        readonly when?: import("../schema.js").Predicate;
+                        readonly repository?: import("../schema.js").Mapping;
+                    })[];
+                };
+                readonly catalog: {
+                    readonly [x: string]: {
+                        readonly methods: {
+                            readonly [x: string]: {
+                                readonly input: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly output: {
+                                    readonly [x: string]: S.Json;
+                                };
+                                readonly description: string;
+                                readonly requires: readonly string[];
+                                readonly effect: "write" | "external" | "read";
+                                readonly approval: "none" | "queue" | "simulate";
+                                readonly digest: string;
+                                readonly pending?: true;
+                            };
+                        };
+                        readonly events?: {
+                            readonly [x: string]: {
+                                readonly digest: string;
+                                readonly description: string;
+                                readonly payload: {
+                                    readonly [x: string]: S.Json;
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly bindings: {
+                    readonly [x: string]: {
+                        kind: "team-source";
+                    } | {
+                        appId: string;
+                        installationId: string;
+                    };
+                };
+                readonly estimatedSteps: number;
+                readonly requiredBindings: readonly {
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly method: string;
+                    readonly description: string;
+                    readonly requires: readonly string[];
+                    readonly effect: "write" | "external" | "read";
+                    readonly installationId: string;
+                    readonly app: string;
+                    readonly approval: "none" | "queue" | "simulate";
+                    readonly pending?: true;
+                }[];
+            };
+            refusal: string | null;
+        }[];
+        refuse(binding: ArmedWorkflowTrigger, reason: string): void;
+        remove(binding: ArmedWorkflowTrigger): void;
+        invalidateInstallation(installationId: string): void;
+    };
+    /** Member-started generic graphs only; trigger starts use startCachedGraph instead. */
+    startGraph(memberId: string, raw: GraphStartRequest, computerId: string | null, libraryInstallationId?: string): Promise<Readonly<{
+        kind: "invalid";
+        issues: readonly import("../validate.js").Issue[];
+    }> | {
+        kind: "conflict" | "started" | "replay";
+        runId: string;
+        planDigest: string;
+    } | {
+        kind: "invalid";
+        issues: {
+            code: string;
+            message: string;
+        }[];
+    }>;
+    startCachedGraph(binding: ArmedWorkflowTrigger, started: Pick<GraphStartRequest, "requestId" | "input"> & {
+        triggerRepository?: string;
+    }): Promise<{
+        kind: "conflict" | "started" | "replay";
+        runId: string;
+        planDigest: string;
+    } | {
+        kind: "refused";
+        reason: string;
+    }>;
+    callWorkflowApp: (memberId: string, call: WorkflowAppCall) => Promise<WorkflowAppCallResult>;
+    admitDelivery: (memberId: string, delivery: WorkflowRunDelivery) => Promise<boolean>;
+    memberComputer: (memberId: string, computerId: string) => Promise<boolean>;
+    catalog: (memberId: string) => Promise<readonly WorkflowCatalogEntry[]>;
+    reviewer: (memberId: string) => Promise<{
+        isOwner: boolean;
+    }>;
+    member: (actorId: string) => Promise<{
+        membershipVersion: number;
+    }>;
+    /** A removed member's runs end now; node admission would refuse them anyway. */
+    revokeMember(rawMemberId: string): void;
+    /** Apps calls this with its permission change inside the shared transaction. */
+    revokeInstallationInMutation(rawInstallationId: string): void;
+    /** A revoked Release ends every run whose frozen plan binds an affected App. */
+    revokeReleaseInMutation(appIds: readonly string[]): void;
+    /** The kernel's lifecycle caller owns the transaction. Suspension ends every run. */
+    onLifecycle(status: "active" | "suspended"): void;
+    reserveTriggerRun(raw: {
+        scope: import("./trigger-run-reservations.js").TriggerRunScope;
+        requestId: string;
+    }): {
+        kind: "reserved" | "replay";
+        reservationId: string;
+        runId: string | null;
+    } | {
+        kind: "refused";
+        reason: "limit";
+    };
+    countActiveTriggerRuns(scope: import("./trigger-run-reservations.js").TriggerRunScope): number;
+    releaseTriggerRun(rawReservationId: string): void;
+    graph: {
+        read: (runId: string) => GraphRun | null;
+        list(filter: {
+            installationId: string;
+            actorId?: string;
+            workflowId?: string;
+        }): readonly (GraphRun & {
+            startedAt: number;
+        })[];
+        active(): readonly GraphRun[];
+        outcome(runId: string): "active" | "terminal" | "cancelled" | null;
+        markTerminal(runId: string, outcome?: "terminal" | "cancelled"): void;
+        startCompiled: (input: GraphRun) => "started" | "replay" | "conflict";
+        start(input: GraphRun): Promise<"started" | "replay" | "conflict">;
+        recordEvent(input: NodeEvent): void;
+        events(runId: string): readonly NodeEvent[];
+        openReview(input: import("../execution.js").GraphReview): number;
+        reviews(runId: string): {
+            review: {
+                readonly show: readonly S.Json[];
+                readonly title: string;
+                readonly timeout: number;
+                readonly runId: string;
+                readonly nodeId: string;
+                readonly reviewers: "runner" | "owners";
+                readonly iteration: string;
+                readonly instanceId: string;
+                readonly eventType: string;
+                readonly choices?: readonly string[];
+            };
+            status: "closed" | "pending" | "answered" | "delivered" | "timed_out";
+            openedAt: number;
+            expiresAt: number;
+        }[];
+        answerReview(key: Pick<import("../execution.js").GraphReview, "runId" | "nodeId" | "iteration">, answer: {
+            readonly approved: boolean;
+        } | {
+            readonly choice: string;
+            readonly note?: string;
+        }, reviewer: import("./graph-run-store.js").GraphReviewer): "accepted" | "denied" | "not_waiting" | "invalid";
+        pendingReviewDeliveries(runId: string): readonly import("./graph-run-store.js").ReviewDelivery[];
+        markReviewDelivered(delivery: import("./graph-run-store.js").ReviewDelivery): void;
+    };
+    /** Every node kind rechecks the stored run; completion cleanup stays with the root engine. */
+    recheckGraphNode(raw: NodeEvent): Promise<NodeAdmissionResult>;
+    /** Recompile the member plan against live catalog, then capture before storage. */
+    startMemberGraph(memberId: string, raw: unknown, libraryInstallationId?: string): Promise<"conflict" | "started" | "replay">;
+};