cloving 1.1.0 → 1.2.0

package/assets/watch-fonts/manifest.json

@@ -0,0 +1,112 @@
+{
+  "files": [
+    {
+      "path": "fira-code-latin-400-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/fira-code/-/fira-code-5.3.0.tgz",
+      "sourceMember": "package/files/fira-code-latin-400-normal.woff2",
+      "package": "@fontsource/fira-code",
+      "version": "5.3.0",
+      "bytes": 23312,
+      "sha256": "6dc9da171ccea71d525379ee1cbf51d143e31acac330a251bb71b3d6060e687c"
+    },
+    {
+      "path": "fira-code-latin-500-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/fira-code/-/fira-code-5.3.0.tgz",
+      "sourceMember": "package/files/fira-code-latin-500-normal.woff2",
+      "package": "@fontsource/fira-code",
+      "version": "5.3.0",
+      "bytes": 23316,
+      "sha256": "9e4da5ad2c147be02544df5a732d22830a82b1e9800dc06267ba656f5c40f7e9"
+    },
+    {
+      "path": "fira-code-OFL.md",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/fira-code/-/fira-code-5.3.0.tgz",
+      "sourceMember": "package/LICENSE",
+      "package": "@fontsource/fira-code",
+      "version": "5.3.0",
+      "bytes": 4389,
+      "sha256": "126cd7bf732b86f42885f1fbf682e6aeea456672c7fdb99f2d557ec44e468a28"
+    },
+    {
+      "path": "heebo-latin-500-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/heebo/-/heebo-5.3.0.tgz",
+      "sourceMember": "package/files/heebo-latin-500-normal.woff2",
+      "package": "@fontsource/heebo",
+      "version": "5.3.0",
+      "bytes": 12312,
+      "sha256": "aa1ea48851b81ac859cf5bcb0e121b596d6b9386dbb9a3f7cd01af3e997201ae"
+    },
+    {
+      "path": "heebo-latin-700-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/heebo/-/heebo-5.3.0.tgz",
+      "sourceMember": "package/files/heebo-latin-700-normal.woff2",
+      "package": "@fontsource/heebo",
+      "version": "5.3.0",
+      "bytes": 12216,
+      "sha256": "2dd5f140b9902257dc0f38e89f47f79d40b31438abef118637d916861fd370bb"
+    },
+    {
+      "path": "heebo-latin-800-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/heebo/-/heebo-5.3.0.tgz",
+      "sourceMember": "package/files/heebo-latin-800-normal.woff2",
+      "package": "@fontsource/heebo",
+      "version": "5.3.0",
+      "bytes": 12132,
+      "sha256": "4890f322303544cf75def54d1065880f017dfe173f15d1b89a1a216e9855fe58"
+    },
+    {
+      "path": "heebo-OFL.md",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/heebo/-/heebo-5.3.0.tgz",
+      "sourceMember": "package/LICENSE",
+      "package": "@fontsource/heebo",
+      "version": "5.3.0",
+      "bytes": 4379,
+      "sha256": "50ac3e340fcd4822b2904413d14b457e02392f0bef38cd790e88da82014be44f"
+    },
+    {
+      "path": "space-grotesk-latin-400-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/space-grotesk/-/space-grotesk-5.3.0.tgz",
+      "sourceMember": "package/files/space-grotesk-latin-400-normal.woff2",
+      "package": "@fontsource/space-grotesk",
+      "version": "5.3.0",
+      "bytes": 13388,
+      "sha256": "65fd17fcbd2e2f522940b5f67ead3d23329e02891aa5495e74d11a499c0b0673"
+    },
+    {
+      "path": "space-grotesk-latin-500-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/space-grotesk/-/space-grotesk-5.3.0.tgz",
+      "sourceMember": "package/files/space-grotesk-latin-500-normal.woff2",
+      "package": "@fontsource/space-grotesk",
+      "version": "5.3.0",
+      "bytes": 13312,
+      "sha256": "1b1a8131d9edf975d9decee81e2f2bf504812f7a4f498e5500f28a613e22e64c"
+    },
+    {
+      "path": "space-grotesk-latin-600-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/space-grotesk/-/space-grotesk-5.3.0.tgz",
+      "sourceMember": "package/files/space-grotesk-latin-600-normal.woff2",
+      "package": "@fontsource/space-grotesk",
+      "version": "5.3.0",
+      "bytes": 13284,
+      "sha256": "685bbbf69fa616df1ef81847c85fc76be097ddfb3468ff2257be54511ab3130f"
+    },
+    {
+      "path": "space-grotesk-latin-700-normal.woff2",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/space-grotesk/-/space-grotesk-5.3.0.tgz",
+      "sourceMember": "package/files/space-grotesk-latin-700-normal.woff2",
+      "package": "@fontsource/space-grotesk",
+      "version": "5.3.0",
+      "bytes": 12840,
+      "sha256": "35f8aec56cfd5cbfdb03cc68733a54a0b05bb3617ffcd5fd332badc0b045ca55"
+    },
+    {
+      "path": "space-grotesk-OFL.md",
+      "sourceArchive": "https://registry.npmjs.org/@fontsource/space-grotesk/-/space-grotesk-5.3.0.tgz",
+      "sourceMember": "package/LICENSE",
+      "package": "@fontsource/space-grotesk",
+      "version": "5.3.0",
+      "bytes": 4401,
+      "sha256": "18a4de52385f6b988782639d5d0cc1326e5a8c2de9a7f01d7b20d9aedcc60943"
+    }
+  ]
+}

package/assets/watch-fonts/space-grotesk-OFL.md

@@ -0,0 +1,93 @@
+Copyright 2020 The Space Grotesk Project Authors (https://github.com/floriankarsten/space-grotesk)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/src/authority/commands.d.ts

@@ -5,3 +5,4 @@ export declare const recoveryBound = 10;
 export declare function isCapabilityList(value: unknown): value is string;
 export declare function isIdentifier(value: unknown): value is string;
 export declare function isRecordKey(value: unknown): value is string;
+export declare function isCommandId(value: unknown): value is string;

package/dist/src/authority/commands.js

@@ -1,6 +1,7 @@
 import { isTicketStatus } from "../ticket-status.js";
+import { operationScope } from "../operation-identity.js";
 import { isInstant } from "./instants.js";
-import { isBlockedReason } from "../workflow-contracts.js";
+import { isBlockedReason, isPromotionId } from "../workflow-contracts.js";
 import { numberFields, textFields, } from "./transitions.js";
 const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
 const digest = /^sha256:[0-9a-f]{64}$/;
@@ -30,6 +31,8 @@ const shapes = {
     "admit-run": {
         required: ["workflow"],
         optional: [
+            "parentRunId",
+            "chainId",
             "submission",
             "input",
             "resolver",
@@ -37,6 +40,7 @@ const shapes = {
             "capabilities",
         ],
         groups: [
+            ["parentRunId", "chainId"],
             ["submission", "input", "resolver"],
             ["effectLimit", "capabilities"],
         ],
@@ -66,15 +70,24 @@ const shapes = {
     "resume-run": revised,
     "complete-run": {
         required: ["expectedRevision"],
-        optional: ["outcome", "outcomeReason", "ticketStatus", "issueUpdate"],
+        optional: [
+            "outcome",
+            "outcomeReason",
+            "promotionId",
+            "ticketStatus",
+            "issueUpdate",
+        ],
         validators: {
             outcome: (value) => value === "handoff_requested" || value === "blocked",
             outcomeReason: isBlockedReason,
+            promotionId: isPromotionId,
             ticketStatus: isTicketStatus,
             issueUpdate: (value) => value === "failed",
         },
         consistent: (fields) => (fields["outcomeReason"] === undefined ||
-            fields["outcome"] === "blocked") &&
+            fields["outcome"] !== undefined) &&
+            (fields["promotionId"] === undefined ||
+                fields["outcome"] === "handoff_requested") &&
             (fields["ticketStatus"] === undefined ||
                 fields["outcome"] === "handoff_requested") &&
             (fields["issueUpdate"] === undefined ||
@@ -147,7 +160,7 @@ export function parseCommand(value) {
         return null;
     const fields = Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
     const { kind, commandId, runId } = fields;
-    if (!knownKind(kind) || !isRecordKey(commandId) || !isRecordKey(runId))
+    if (!knownKind(kind) || !isCommandId(commandId) || !isRecordKey(runId))
         return null;
     if (!completeFields(kind, fields))
         return null;
@@ -269,3 +282,11 @@ const plainRecord = {};
 export function isRecordKey(value) {
     return isIdentifier(value) && !(value in plainRecord);
 }
+export function isCommandId(value) {
+    if (isRecordKey(value))
+        return true;
+    return (typeof value === "string" &&
+        value.startsWith("handoff:") &&
+        printable(value.slice(8)) &&
+        operationScope(value.slice(8)) !== null);
+}

package/dist/src/authority/dispatch-decision.d.ts

@@ -35,6 +35,7 @@ export interface DispatchCheck {
         readonly leaseGeneration?: number;
     };
     readonly now: string;
+    readonly mode?: "retry";
 }
 export type DispatchDecision = "stale" | "withheld" | "refused" | "blocked" | "send";
 export declare function dispatchDecision(read: DispatchRead, check: DispatchCheck): DispatchDecision;

package/dist/src/authority/dispatch-decision.js

@@ -15,13 +15,16 @@ function bound(read, intent) {
         lease.state !== "released",
     ].every(Boolean);
 }
-function sendable(read, now) {
+function sendable(read, check) {
+    const statuses = check.mode === "retry"
+        ? ["dispatch-pending", "recovering", "blocked"]
+        : ["dispatch-pending"];
     return [
         !read.released,
         read.runStatus === "running",
-        read.operation?.status === "dispatch-pending",
+        statuses.includes(read.operation?.status ?? ""),
         read.lease?.state === "held",
-        isAfter(read.lease?.expiresAt ?? "", now),
+        isAfter(read.lease?.expiresAt ?? "", check.now),
     ].every(Boolean);
 }
 function authorized(read) {
@@ -39,7 +42,7 @@ function authorized(read) {
 export function dispatchDecision(read, check) {
     if (!bound(read, check.intent))
         return "stale";
-    if (!sendable(read, check.now))
+    if (!sendable(read, check))
         return "withheld";
     if (!authorized(read))
         return "refused";

package/dist/src/authority/events.js

@@ -1,4 +1,4 @@
-import { isRecordKey } from "./commands.js";
+import { isCommandId, isRecordKey } from "./commands.js";
 import { eventTypes } from "./transitions.js";
 export function parseEvent(value) {
     const fields = record(value);
@@ -11,7 +11,7 @@ export function parseEvent(value) {
         !Number.isSafeInteger(sequence) ||
         eventType === undefined ||
         !isRecordKey(runId) ||
-        !isRecordKey(commandId) ||
+        !isCommandId(commandId) ||
         typeof recordedAt !== "string" ||
         typeof request !== "string" ||
         !payload)

package/dist/src/authority/handoff-chain.d.ts

@@ -0,0 +1,24 @@
+export interface RunOrigin {
+    readonly parentRunId: string | null;
+    readonly chainId: string;
+}
+export type RunOrigins = Readonly<Record<string, RunOrigin>>;
+export interface RunLinks extends RunOrigin {
+    readonly childRunIds: readonly string[];
+}
+export declare function linksOf(run: {
+    readonly runId: string;
+} & Partial<RunLinks>): RunLinks;
+export declare function runLinks(origins: RunOrigins): Readonly<Record<string, RunLinks>>;
+export declare function childRuns(origins: RunOrigins): Readonly<Record<string, readonly string[]>>;
+export type HandoffChain = {
+    readonly kind: "root";
+} | {
+    readonly kind: "handoff";
+    readonly parentRunId: string;
+    readonly chainId: string;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export declare function handoffChain(commandId: string, origins: RunOrigins): HandoffChain;

package/dist/src/authority/handoff-chain.js

@@ -0,0 +1,46 @@
+import { operationScope } from "../operation-identity.js";
+export function linksOf(run) {
+    return {
+        parentRunId: run.parentRunId ?? null,
+        chainId: run.chainId ?? run.runId,
+        childRunIds: run.childRunIds ?? [],
+    };
+}
+export function runLinks(origins) {
+    const children = childRuns(origins);
+    return Object.fromEntries(Object.entries(origins).map(([runId, origin]) => [
+        runId,
+        {
+            ...origin,
+            childRunIds: children[runId] ?? [],
+        },
+    ]));
+}
+export function childRuns(origins) {
+    const children = {};
+    for (const [runId, origin] of Object.entries(origins)) {
+        if (origin.parentRunId === null)
+            continue;
+        const siblings = children[origin.parentRunId] ?? [];
+        siblings.push(runId);
+        children[origin.parentRunId] = siblings;
+    }
+    return children;
+}
+export function handoffChain(commandId, origins) {
+    if (!commandId.startsWith("handoff:"))
+        return { kind: "root" };
+    const parentRunId = operationScope(commandId.slice(8))?.run;
+    const parent = parentRunId === undefined ? undefined : origins[parentRunId];
+    if (parent === undefined || parentRunId === undefined)
+        return { kind: "refused", reason: "unknown-handoff-parent" };
+    let current = parent;
+    for (let length = 1; current !== undefined; length += 1) {
+        if (length >= 5)
+            return { kind: "refused", reason: "chain-limit" };
+        if (current.parentRunId === null)
+            return { kind: "handoff", parentRunId, chainId: parent.chainId };
+        current = origins[current.parentRunId];
+    }
+    return { kind: "refused", reason: "unknown-handoff-parent" };
+}

package/dist/src/authority/reconciliation.d.ts

@@ -4,6 +4,7 @@ export interface WorldRun {
     readonly receipt: string;
     readonly status: string;
     readonly outcome?: string;
+    readonly promotionId?: string;
     readonly outcomeReason?: string;
     readonly issueUpdate?: "failed";
     readonly ticketStatus?: "complete" | "partial";

package/dist/src/authority/reconciliation.js

@@ -1,6 +1,6 @@
 import { isTicketStatus } from "../ticket-status.js";
 import { gateContinuation } from "./gate-reduction.js";
-import { isBlockedReason } from "../workflow-contracts.js";
+import { isBlockedReason, isPromotionId } from "../workflow-contracts.js";
 import { continues } from "./gates.js";
 import { startOperation } from "./reduction.js";
 import { terminal, } from "./transitions.js";
@@ -111,19 +111,26 @@ function moved(kind, observed) {
 }
 function completionOutcome(world) {
     const { outcome, outcomeReason } = world;
-    if (outcome !== "handoff_requested" && outcome !== "blocked")
-        return {};
-    if (outcome !== "blocked" || !isBlockedReason(outcomeReason))
+    if (outcome === "blocked")
         return {
             outcome,
-            ...(outcome === "handoff_requested" && world.issueUpdate === "failed"
-                ? { issueUpdate: world.issueUpdate }
-                : {}),
-            ...(outcome === "handoff_requested" && isTicketStatus(world.ticketStatus)
-                ? { ticketStatus: world.ticketStatus }
-                : {}),
+            ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
         };
-    return { outcome, outcomeReason };
+    if (outcome !== "handoff_requested")
+        return {};
+    return {
+        outcome,
+        ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
+        ...(isPromotionId(world.promotionId)
+            ? { promotionId: world.promotionId }
+            : {}),
+        ...(world.issueUpdate === "failed"
+            ? { issueUpdate: world.issueUpdate }
+            : {}),
+        ...(isTicketStatus(world.ticketStatus)
+            ? { ticketStatus: world.ticketStatus }
+            : {}),
+    };
 }
 function noted(observed, evidence) {
     const { run, world, reason } = observed;

package/dist/src/authority/transitions.d.ts

@@ -40,7 +40,7 @@ export interface AuthorityEvent {
     readonly payload: Readonly<Record<string, string>>;
 }
 export declare const numberFields: readonly ["expectedRevision", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity"];
-export declare const textFields: readonly ["workflow", "submission", "input", "resolver", "gateId", "gateKind", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "ticketStatus", "issueUpdate", "result"];
+export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "submission", "input", "resolver", "gateId", "gateKind", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result"];
 export type NumberField = (typeof numberFields)[number];
 export type TextField = (typeof textFields)[number];
 export type AuthorityCommand = {

package/dist/src/authority/transitions.js

@@ -31,6 +31,8 @@ export const numberFields = [
     "capacity",
 ];
 export const textFields = [
+    "parentRunId",
+    "chainId",
     "workflow",
     "submission",
     "input",
@@ -60,6 +62,7 @@ export const textFields = [
     "worker",
     "outcome",
     "outcomeReason",
+    "promotionId",
     "ticketStatus",
     "issueUpdate",
     "result",

package/dist/src/broker/actor/authority-queries.d.ts

@@ -1,6 +1,7 @@
 import type { Database } from "solid-objects";
 import type { AuthorityCommand, AuthorityEvent } from "../../authority/transitions.ts";
 import { type SqlConnection } from "../../storage/domain-rows.ts";
+import { type RunLinks, type RunOrigins } from "../../authority/handoff-chain.ts";
 export interface CommandRecord {
     readonly commandId: string;
     readonly sequence: number;
@@ -28,6 +29,7 @@ export interface Sequences {
 export interface CompletionCursor {
     readonly runId: string;
     readonly atOrBefore: number;
+    readonly terminal?: boolean;
 }
 export interface AuthorityQueries {
     readonly document: (digest: string) => Promise<string | undefined>;
@@ -36,6 +38,8 @@ export interface AuthorityQueries {
     readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
     readonly sequences: () => Promise<Sequences>;
     readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+    readonly runOrigins: () => Promise<RunOrigins>;
+    readonly runLinks: () => Promise<Readonly<Record<string, RunLinks>>>;
 }
 export type Read = <Value>(query: (connection: SqlConnection) => Promise<Value>) => Promise<Value>;
 export declare function guardedRead(access: {

package/dist/src/broker/actor/authority-queries.js

@@ -1,8 +1,19 @@
 import { parseCommand } from "../../authority/commands.js";
 import { documentBody } from "../../storage/decision-rows.js";
-import { integer, latestSequence, text, } from "../../storage/domain-rows.js";
+import { integer, optionalText, latestSequence, text, } from "../../storage/domain-rows.js";
 import { storedEvents } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
+import { runLinks, } from "../../authority/handoff-chain.js";
+async function runOrigins(connection, cursor) {
+    const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
+    return Object.fromEntries(rows.map((row) => [
+        text(row, "run_id"),
+        {
+            parentRunId: optionalText(row, "parent_run_id"),
+            chainId: text(row, "chain_id"),
+        },
+    ]));
+}
 async function receipt(connection, commandId) {
     const row = await connection.get("SELECT c.request, c.sequence, e.run_id, e.recorded_at FROM commands c JOIN events e ON e.sequence = c.sequence WHERE c.command_id = ?", [commandId]);
     if (row === undefined)
@@ -51,7 +62,10 @@ function publishedEvents(rows) {
     }));
 }
 async function latestCompletion(connection, cursor) {
-    const row = await connection.get("SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND type = 'run.completed' AND sequence <= ? ORDER BY sequence DESC LIMIT 1", [cursor.runId, cursor.atOrBefore]);
+    const types = cursor.terminal === true
+        ? "type IN ('run.completed', 'run.failed', 'run.cancelled')"
+        : "type = 'run.completed'";
+    const row = await connection.get(`SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND ${types} AND sequence <= ? ORDER BY sequence DESC LIMIT 1`, [cursor.runId, cursor.atOrBefore]);
     return row === undefined ? undefined : publishedEvents([row])[0];
 }
 async function sequences(connection) {
@@ -66,6 +80,28 @@ async function workflowIds(connection) {
     const rows = await connection.all("SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'");
     return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
 }
+function cachedOrigins(read) {
+    let sequence = 0;
+    let origins = {};
+    let pending = Promise.resolve();
+    return () => {
+        const result = pending.then(() => read(async (connection) => {
+            const through = await latestSequence(connection);
+            if (through === sequence)
+                return origins;
+            const added = await runOrigins(connection, {
+                after: sequence,
+                through,
+            });
+            if (Object.keys(added).length > 0)
+                origins = { ...origins, ...added };
+            sequence = through;
+            return origins;
+        }));
+        pending = result.then(() => undefined, () => undefined);
+        return result;
+    };
+}
 export function guardedRead(access) {
     const { reader, ready } = access;
     return async (query) => {
@@ -74,6 +110,17 @@ export function guardedRead(access) {
     };
 }
 export function authorityQueries(read) {
+    const origins = cachedOrigins(read);
+    let linkedOrigins;
+    let links = {};
+    const currentLinks = async () => {
+        const current = await origins();
+        if (current !== linkedOrigins) {
+            links = runLinks(current);
+            linkedOrigins = current;
+        }
+        return links;
+    };
     return {
         document: (digest) => read((connection) => documentBody(connection, digest)),
         receipt: (commandId) => read((connection) => receipt(connection, commandId)),
@@ -81,5 +128,7 @@ export function authorityQueries(read) {
         latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
         sequences: () => read(sequences),
         workflowIds: () => read(workflowIds),
+        runOrigins: origins,
+        runLinks: currentLinks,
     };
 }

package/dist/src/broker/actor/delivery-intents.d.ts

@@ -51,6 +51,7 @@ export interface Delivery {
         readonly worker?: string;
     } | AdapterOutcome>;
     readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly retry?: Delivery["reconcile"];
     readonly stop?: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
 }
 export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined;

package/dist/src/broker/actor/effect-delivery.js

@@ -69,9 +69,16 @@ function decided(parts, attempt) {
     }), {
         intent: { ...intent, computedDigest: effectInputDigest(intent) },
         now,
+        ...(attempt.mode === undefined ? {} : { mode: attempt.mode }),
     }));
 }
 const withheld = { kind: "withheld" };
+async function retryEffect(parts, attempt) {
+    const retry = await decided(parts, { ...attempt, mode: "retry" });
+    return retry === "send"
+        ? called(parts, { intent: attempt.intent, name: "retry" })
+        : attempt.known;
+}
 function unsent(decision) {
     return decision === "stale" ? withheld : { kind: decision };
 }
@@ -83,6 +90,8 @@ async function attempted(parts, attempt) {
     if (intent.purpose === "stop")
         return stopRequested(parts, intent);
     const known = await called(parts, { intent, name: "reconcile" });
+    if (known.kind === "unknown" && parts.delivery.retry !== undefined)
+        return retryEffect(parts, { ...attempt, known });
     if (known.kind !== "absent" || intent.purpose === "reconcile")
         return known;
     if (first !== "send")