@astrosheep/keiyaku 4.0.6 → 4.1.0

package/build/src/cli/render/task.js

@@ -25,10 +25,10 @@ function priorityText(priority) {
     return priority === null ? "P?" : `P${priority}`;
 }
 function scanUnit(id, priority, word) {
-    return `${markFor(word)} ${id} · ${priorityText(priority)} ${word}`;
+    return word === undefined ? `${markFor("ready")} ${id} · ${priorityText(priority)}` : `${markFor(word)} ${id} · ${priorityText(priority)} ${word}`;
 }
 function entityLines(entity, columns, indent = "") {
-    const scan = `${indent}${scanUnit(entity.id, entity.priority, entity.word)}`;
+    const scan = `${indent}${scanUnit(entity.id, entity.priority, entity.word)}${entity.facts === undefined ? "" : ` · ${entity.facts}`}`;
     if (entity.title === null || entity.title.length === 0)
         return [scan];
     const title = safeText(entity.title);
@@ -37,9 +37,6 @@ function entityLines(entity, columns, indent = "") {
         return [inline];
     return [`${scan} —`, ...renderTextBlock(title, `${indent}  `, columns)];
 }
-function listEntity(item) {
-    return { id: item.id, priority: item.priority, word: item.disposition, title: item.title };
-}
 function stateEntity(task) {
     return { id: task.id, priority: "priority" in task && task.priority !== undefined ? task.priority : null, word: task.state, title: task.title };
 }
@@ -79,23 +76,71 @@ function pageHeading(view, page) {
         return `${view} ${page.returned} of ${page.total} · limit ${page.returned}`;
     return `${view} ${page.returned}`;
 }
-function renderListRow(item, columns) {
-    const lines = [...entityLines(listEntity(item), columns)];
+function updatedAge(updatedAt) {
+    const elapsed = Math.max(0, performance.timeOrigin + performance.now() - Date.parse(updatedAt));
+    const minutes = Math.floor(elapsed / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function compactFacts(item) {
+    return [
+        `updated ${updatedAge(item.updatedAt)}`,
+        ...(item.bodyPresent ? [] : ["no body"]),
+        ...(item.children === undefined ? [] : [`children ${item.children.live}/${item.children.total} live`]),
+    ].join(" · ");
+}
+function listEntity(item, omitDisposition) {
+    return {
+        id: item.id,
+        priority: item.priority,
+        ...(omitDisposition ? {} : { word: item.disposition }),
+        facts: compactFacts(item),
+        title: item.title,
+    };
+}
+function renderListRow(item, columns, omitDisposition) {
+    const lines = [...entityLines(listEntity(item, omitDisposition), columns)];
     if ("blockers" in item) {
         for (const blocker of item.blockers)
             lines.push(`  needs ${blocker.id} · ${blocker.state}`);
     }
     return lines;
 }
+function shellQuote(value) { return `'${value.replaceAll("'", "'\\''")}'`; }
+function recoveryCommand(command, total) {
+    const parts = ["keiyaku", "task", command.action];
+    if (command.action === "ls") {
+        if (command.flags.closed === true)
+            parts.push("--closed");
+        if (command.flags.all === true)
+            parts.push("--all");
+    }
+    if (command.flags.world === true)
+        parts.push("--world");
+    if ((command.action === "ready" || command.action === "blocked") && typeof command.flags.parent === "string") {
+        parts.push("--parent", command.flags.parent);
+    }
+    if (command.action === "query" && typeof command.flags.where === "string")
+        parts.push("--where", shellQuote(command.flags.where));
+    if (command.action === "query" && typeof command.flags.sort === "string")
+        parts.push("--sort", command.flags.sort);
+    parts.push("--limit", String(total));
+    return parts.join(" ");
+}
 function renderRows(command, result, columns) {
     if (result.kind !== "accepted")
         return renderFailure(command.action, result, columns);
     const view = command.action === "ls" ? "tasks" : command.action;
-    return [pageHeading(view, result.value), ...result.value.rows.flatMap((item) => renderListRow(item, columns))].join("\n");
+    const footer = result.value.truncated
+        ? ["", `  + ${result.value.total - result.value.returned} more not shown`, `    ${recoveryCommand(command, result.value.total)}`]
+        : [];
+    return [pageHeading(view, result.value), ...result.value.rows.flatMap((item) => renderListRow(item, columns, command.action === "ready")), ...footer].join("\n");
 }
-function renderShow(result, columns) {
-    if ("kind" in result)
-        return result.kind === "accepted" ? entityLines(stateEntity(result.value), columns).join("\n") : renderFailure("show", result, columns);
+function renderShowDetail(result, columns) {
     const task = result.task;
     const lines = [
         ...entityLines(stateEntity(task), columns),
@@ -124,6 +169,13 @@ function renderShow(result, columns) {
         receiptPayload(lines, "body", task.body);
     return lines.join("\n");
 }
+function renderShow(result, columns) {
+    if (Array.isArray(result))
+        return result.map((detail) => renderShowDetail(detail, columns)).join("\n\n");
+    if ("kind" in result)
+        return renderFailure("show", result, columns);
+    return renderShowDetail(result, columns);
+}
 function treeLines(node, columns, depth = 0) {
     const indent = "  ".repeat(depth);
     if (node.cycle === true)

package/build/src/cli/result.d.ts

@@ -1,4 +1,4 @@
-import type { AuditReport, ContractHistory, ContractId, Delivery, Fact, IntegrationConflictMaterialized, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
+import type { AuditReport, ContractHistory, ContractId, ContinuationReport, Delivery, Fact, IntegrationConflictMaterialized, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
 import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
@@ -45,6 +45,7 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: never;
     verificationSummary?: never;
     placement?: never;
+    continuation?: never;
     cleanup?: never;
     leak?: never;
     report?: never;
@@ -63,6 +64,7 @@ export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: never;
     verificationSummary?: never;
     placement?: never;
+    continuation?: never;
     cleanup?: never;
     leak?: never;
     report?: never;
@@ -80,6 +82,7 @@ export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: VerificationReuse;
     verificationSummary?: string;
     placement?: PlacementStop;
+    continuation?: ContinuationReport;
     cleanup?: MutationResult<unknown>["cleanup"];
     leak?: MutationResult<unknown>["leak"];
     target?: never;
@@ -101,6 +104,7 @@ export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: VerificationReuse;
     verificationSummary?: string;
     placement?: PlacementStop;
+    continuation?: ContinuationReport;
     workspace?: Review["workspace"];
     cleanup?: MutationResult<unknown>["cleanup"];
     leak?: MutationResult<unknown>["leak"];
@@ -124,6 +128,7 @@ export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: never;
     verificationSummary?: never;
     placement?: never;
+    continuation?: never;
     cleanup?: never;
     leak?: never;
     overlaps?: never;
@@ -144,6 +149,7 @@ export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: never;
     verificationSummary?: never;
     placement?: never;
+    continuation?: never;
     cleanup?: never;
     leak?: never;
     overlaps?: never;
@@ -166,6 +172,7 @@ export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     verificationReuse?: never;
     verificationSummary?: never;
     placement?: never;
+    continuation?: never;
     overlaps?: never;
     overlapFailure?: never;
     workspace?: never;

package/build/src/contract-worktree.d.ts

@@ -54,6 +54,4 @@ export declare function withContractWorktreeAppointment<T>(repository: GitReposi
 export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
 /** Remove matching here appointments and their exact generated support from registered worktrees. */
 export declare function nukeHereAppointments(repository: GitRepository): Promise<void>;
-/** Validate the existing Contract-worktree coordination lock before releasing it. */
-export declare function nukeContractWorktreeLock(repository: GitRepository): Promise<void>;
 export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister, onConflict?: (diagnostic: string) => never): Promise<ContractWorktreeResult>;

package/build/src/contract-worktree.js

@@ -30,7 +30,14 @@ const FULFILLMENT = [
     "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` "
         + "to organize and manage Tasks.",
     "Promptly update progress for Tasks already present in the current worktree.",
-    "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.", "",
+    "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.",
+    "Deliver from this worktree. A clean worktree delivers HEAD; uncommitted work",
+    "needs `deliver --include-dirty`, which captures the final non-ignored tree and",
+    "stages or commits nothing. If deliver reports a conflict, run",
+    "`deliver --materialize-conflict`, resolve the conflicted files, stage them,",
+    "and deliver again; while the merge stays uncommitted that continuation uses",
+    "`--include-dirty`. Unresolved paths always refuse.",
+    "",
     "### Reviewer", "",
     "Review this Contract worktree against the complete Contract.",
     "Review the complete current worktree snapshot, not a named candidate commit.",
@@ -177,30 +184,12 @@ async function removeOwnedHereSupport(worktree) {
 export async function nukeHereAppointments(repository) {
     for (const registered of await registeredWorktrees(repository)) {
         const scoped = { ...repository, effectiveCwd: registered.path };
-        await withContractWorktreeAppointment(scoped, async () => {
-            const appointment = await readContractAppointment(scoped);
-            if (appointment.kind === "appointed") {
-                await unlink(appointment.path);
-                await removeOwnedHereSupport(registered.path);
-            }
-        });
-    }
-}
-/** Validate the existing Contract-worktree coordination lock before releasing it. */
-export async function nukeContractWorktreeLock(repository) {
-    const path = join(repository.commonDirectory, "keiyaku", "contract-worktree.sqlite");
-    try {
-        const value = await lstat(path);
-        if (!value.isFile() || value.isSymbolicLink())
-            throw new Error(`Contract worktree lock custody is not a regular file: ${path}`);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
+        const appointment = await readContractAppointment(scoped);
+        if (appointment.kind === "appointed") {
+            await unlink(appointment.path);
+            await removeOwnedHereSupport(registered.path);
+        }
     }
-    const held = await acquireSqliteTransactionLock({ path, mode: "immediate" });
-    held.close();
 }
 async function repair(repository, worktree, relativePath, bytes) {
     const path = join(worktree, relativePath);

package/build/src/git/nuke.js

@@ -1,9 +1,7 @@
 import { access } from "node:fs/promises";
-import { nukeContractWorktreeLock, nukeHereAppointments } from "../contract-worktree.js";
-import { nukeSettlementFences } from "../settlement/fence.js";
+import { nukeHereAppointments } from "../contract-worktree.js";
 import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees, } from "../workspace-place.js";
 import { nukeWorktreeHookResidue } from "./hooks.js";
-import { nukeReconcileLocks } from "./reconcile.js";
 import { runGit } from "./process.js";
 import { NoGitWorldError, registeredWorktrees, repositoryAt, worktreeGitDirectory } from "./repository.js";
 import { worktreePath } from "./workspace.js";
@@ -86,9 +84,6 @@ export async function nukeGit(world) {
     }
     await nukeHereAppointments(repository);
     await nukeEmptyPlaceAuthority(repository);
-    await nukeContractWorktreeLock(repository);
-    await nukeReconcileLocks(repository);
-    await nukeSettlementFences(repository);
     await removeOwnedRefs(repository, custody.refs);
     if (custody.state) {
         const oid = (await runGit(repository, ["rev-parse", "--verify", "refs/heads/keiyaku-state"])).toString("utf8").trim();

package/build/src/git/reconcile.d.ts

@@ -64,6 +64,4 @@ type ReconcileBatchOptions = Readonly<{
 }>;
 /** Reconcile each discovered Contract through its own serialized, fresh observation. */
 export declare function reconcileBatch(repository: GitRepository, channel: GitDecodeChannel, contracts: Iterable<ContractId>, options: ReconcileBatchOptions): Promise<readonly ReconcileBatchItem[]>;
-/** Remove only validated Contract reconciliation lock residue. */
-export declare function nukeReconcileLocks(repository: GitRepository): Promise<void>;
 export {};

package/build/src/git/reconcile.js

@@ -1,5 +1,5 @@
-import { access, mkdir, readdir } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { access, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, isKeiyakuOwnedRef, readRef, registeredWorktreePaths, writeCommit, worktreeGitDirectory, } from "./repository.js";
@@ -466,34 +466,3 @@ export async function reconcileBatch(repository, channel, contracts, options) {
     }
     return items;
 }
-/** Remove only validated Contract reconciliation lock residue. */
-export async function nukeReconcileLocks(repository) {
-    const root = join(commonGitDirectory(repository), "keiyaku", "locks", "reconcile");
-    let first;
-    try {
-        first = await readdir(root, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    let paths = [];
-    for (const directory of first) {
-        if (!/^[0-9a-f]{2}$/u.test(directory.name) || !directory.isDirectory() || directory.isSymbolicLink()) {
-            throw new Error(`reconciliation lock custody is invalid: ${resolve(root, directory.name)}`);
-        }
-        const nested = resolve(root, directory.name);
-        const files = await readdir(nested, { withFileTypes: true });
-        for (const file of files) {
-            if (!/^[0-9a-f]{62}\.sqlite$/u.test(file.name) || !file.isFile() || file.isSymbolicLink()) {
-                throw new Error(`reconciliation lock custody is invalid: ${resolve(nested, file.name)}`);
-            }
-            paths.push(resolve(nested, file.name));
-        }
-    }
-    for (const path of paths) {
-        const held = await acquireSqliteTransactionLock({ path, mode: "immediate" });
-        held.close();
-    }
-}

package/build/src/git/tender.d.ts

@@ -8,11 +8,18 @@ export type TenderCaptureCoordinates = Readonly<{
     coordinates: ContractCoordinates;
     place?: string;
     workspacePath?: string;
+    captureMergeState?: boolean;
+    rejectUnmerged?: boolean;
 }>;
-export type TenderCaptureRefusal = Readonly<{
+export type WorktreeMissingRefusal = Readonly<{
     kind: "worktree-missing";
     contractId: ContractId;
 }>;
+export type TenderCaptureRefusal = WorktreeMissingRefusal | Readonly<{
+    kind: "unmerged-paths";
+    contractId: ContractId;
+    paths: readonly string[];
+}>;
 export type WorkspaceDirtyDelta = Readonly<{
     staged: readonly string[];
     unstaged: readonly string[];
@@ -35,12 +42,16 @@ export type DirtyWorkspaceRefusal = Readonly<{
 export type TenderCapture = Readonly<{
     tree: GitObjectId;
     head: SnapshotId;
+    mergeHead?: SnapshotId;
     at: string;
     dirty: boolean;
     changes: Awaited<ReturnType<typeof captureWorkspaceTree>>["changes"];
 }>;
 /** Capture the complete workspace tree through Git's private index mechanics. */
-export declare function captureTender(repository: GitRepository, input: TenderCaptureCoordinates): Promise<Preparation<TenderCapture, TenderCaptureRefusal>>;
+export declare function captureTender(repository: GitRepository, input: TenderCaptureCoordinates & Readonly<{
+    rejectUnmerged: true;
+}>): Promise<Preparation<TenderCapture, TenderCaptureRefusal>>;
+export declare function captureTender(repository: GitRepository, input: TenderCaptureCoordinates): Promise<Preparation<TenderCapture, WorktreeMissingRefusal>>;
 export declare function dirtyTenderRefusal(repository: GitRepository, contractId: ContractId, tender: TenderCapture): Promise<DirtyWorkspaceRefusal>;
 export declare function dirtyTenderDelta(repository: GitRepository, tender: TenderCapture): Promise<WorkspaceDirtyDelta | undefined>;
 type GitCommitIdentity = Readonly<{

package/build/src/git/tender.js

@@ -13,13 +13,49 @@ function workspaceFor(repository, input) {
         return input.workspacePath;
     return input.place === undefined ? undefined : worktreePath(repository, input.place);
 }
-/** Capture the complete workspace tree through Git's private index mechanics. */
+async function workspaceMergeHead(repository, workspace) {
+    try {
+        return mintSnapshotId((await runGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
+            .toString("utf8")
+            .trim());
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return undefined;
+        throw error;
+    }
+}
+async function unmergedWorkspacePaths(repository, workspace) {
+    const records = (await runGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"]))
+        .toString("utf8")
+        .split("\0");
+    const paths = new Set();
+    for (const record of records.slice(0, -1)) {
+        const separator = record.indexOf("\t");
+        if (separator < 0)
+            throw new Error(`malformed unmerged index record: ${record}`);
+        paths.add(record.slice(separator + 1));
+    }
+    return [...paths].sort();
+}
 export async function captureTender(repository, input) {
     const workspace = workspaceFor(repository, input);
     if (workspace === undefined || !(await workspaceExists(repository, input.coordinates.workspace, workspace))) {
         return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
     }
-    return { kind: "prepared", data: await captureWorkspaceTree(repository, workspace) };
+    if (input.rejectUnmerged === true) {
+        const paths = await unmergedWorkspacePaths(repository, workspace);
+        if (paths.length > 0)
+            return { kind: "refused", refusal: { kind: "unmerged-paths", contractId: input.contractId, paths } };
+    }
+    const captured = await captureWorkspaceTree(repository, workspace);
+    const mergeHead = input.captureMergeState === true
+        ? await workspaceMergeHead(repository, workspace)
+        : undefined;
+    return {
+        kind: "prepared",
+        data: { ...captured, ...(mergeHead === undefined ? {} : { mergeHead }) },
+    };
 }
 async function dirtyShortStat(repository, tender) {
     return decodeGitNumstat(await runGit(repository, [
@@ -81,9 +117,12 @@ export async function prepareDeliveryCommitMetadata(repository, input) {
 }
 /** Materialize the tender tree when it contains admitted dirty workspace bytes. */
 export async function materializeTenderSnapshot(repository, tender, commit) {
-    if (!tender.dirty)
+    if (!tender.dirty && tender.mergeHead === undefined)
         return tender.head;
-    const oid = (await runGitWithEnvironment(repository, ["commit-tree", tender.tree, "-p", gitObjectIdForSnapshot(tender.head)], commit.message, {
+    const parents = ["-p", gitObjectIdForSnapshot(tender.head)];
+    if (tender.mergeHead !== undefined)
+        parents.push("-p", gitObjectIdForSnapshot(tender.mergeHead));
+    const oid = (await runGitWithEnvironment(repository, ["commit-tree", tender.tree, ...parents], commit.message, {
         GIT_AUTHOR_NAME: commit.identity.name,
         GIT_AUTHOR_EMAIL: commit.identity.email,
         GIT_COMMITTER_NAME: commit.identity.name,

package/build/src/kanshi/read.js

@@ -244,22 +244,42 @@ async function joinAkuma(path, observeContract, dispatches, aliases) {
         for (const binding of aliases.value)
             aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
         const dispatchById = new Map(dispatches.map((dispatch) => [dispatch.akuId, dispatch]));
+        const rows = source.rows.map((row) => {
+            const dispatch = dispatchById.get(row.id);
+            return {
+                ...row,
+                aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
+                ...(dispatch === undefined ? {} : {
+                    contract: {
+                        id: dispatch.contractId,
+                        observed: observeContract(dispatch.contractId),
+                    },
+                }),
+            };
+        });
+        const running = rows
+            .filter((row) => row.life === "running")
+            .sort((left, right) => {
+            const l = "lastActivityAt" in left && left.lastActivityAt !== null ? Date.parse(left.lastActivityAt) : -Infinity;
+            const r = "lastActivityAt" in right && right.lastActivityAt !== null ? Date.parse(right.lastActivityAt) : -Infinity;
+            return r - l;
+        })
+            .slice(0, 3);
+        const snapshots = new Map(await Promise.all(running.map(async (row) => {
+            try {
+                return [row.id, (await Akuma.of(path).of({ id: row.id }).status()).timeline];
+            }
+            catch {
+                return [row.id, undefined];
+            }
+        })));
         return {
             kind: "present",
             value: {
                 ...source,
-                rows: source.rows.map((row) => {
-                    const dispatch = dispatchById.get(row.id);
-                    return {
-                        ...row,
-                        aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
-                        ...(dispatch === undefined ? {} : {
-                            contract: {
-                                id: dispatch.contractId,
-                                observed: observeContract(dispatch.contractId),
-                            },
-                        }),
-                    };
+                rows: rows.map((row) => {
+                    const snapshot = snapshots.get(row.id);
+                    return snapshot === undefined ? row : { ...row, snapshot };
                 }),
             },
         };

package/build/src/kanshi/report.d.ts

@@ -1,6 +1,6 @@
 import type { ContractBoard, ContractDisposition } from "../library/contract.js";
 import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
-import type { AkumaList, AkumaListRow, UnbornAkumaListRow } from "../akuma/index.js";
+import type { AkumaList, AkumaListRow, UnbornAkumaListRow, ActivitySnapshot } from "../akuma/index.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { ContractId } from "../library/contract.js";
@@ -53,6 +53,7 @@ export type AkumaKanshiRow = (AkumaListRow | UnbornAkumaListRow) & Readonly<{
         id: string;
         observed: ContractEndpointObservation;
     }>;
+    snapshot?: ActivitySnapshot;
 }>;
 export type AkumaKanshiWorld = Omit<AkumaList, "rows"> & Readonly<{
     rows: readonly AkumaKanshiRow[];

package/build/src/library/continuation.d.ts

@@ -0,0 +1,26 @@
+import type { ContractId, ContractState } from "../core/facts/types.js";
+import { type GitDecodeChannel } from "../git/read-observation.js";
+import type { DocumentDerivation, HereWorkspaceResolver, PlacementStop, RepositoryScope } from "../protocol/operations.js";
+import type { AcceptedIntent } from "./mutation.js";
+export type ContinuationReport = Readonly<{
+    attempted: number;
+    claimed: readonly ContractId[];
+    stopped: readonly Readonly<{
+        contractId: ContractId;
+        stop: PlacementStop | Readonly<{
+            kind: "already-terminal" | "delivery-missing";
+        }>;
+    }>[];
+}>;
+export declare function continueDeliveredDependents<Value extends object>(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    contractId: ContractId;
+    accepted: AcceptedIntent<Value>;
+    deriveDocument: (state: ContractState) => DocumentDerivation;
+    resolveHereWorkspace?: HereWorkspaceResolver;
+    actor?: import("../core/facts/types.js").ActorId;
+    signal?: AbortSignal;
+}>): Promise<AcceptedIntent<Value & Readonly<{
+    continuation?: ContinuationReport;
+}>>>;

package/build/src/library/continuation.js

@@ -0,0 +1,78 @@
+import { observeActiveContractWorld } from "../git/observe.js";
+import { withGitReadObservation } from "../git/read-observation.js";
+import { continueDeliveryOperation } from "../protocol/deliver.js";
+function directDependents(world, claimed, attempted, newlyClaimed) {
+    const dependents = [];
+    for (const [contractId, record] of world.contracts) {
+        const state = record.state;
+        if (state === null
+            || attempted.has(contractId)
+            || !state.terms.after.includes(claimed)
+            || state.delivery === null
+            || !state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed"))
+            continue;
+        dependents.push({ state, journal: record.entries });
+    }
+    return dependents.sort((left, right) => left.state.id.localeCompare(right.state.id));
+}
+function appendAccepted(primary, child) {
+    const effects = [...(primary.physical?.effects ?? []), ...(child.physical?.effects ?? [])];
+    const lag = [...(primary.physical?.lag ?? []), ...(child.physical?.lag ?? [])];
+    return {
+        ...primary,
+        facts: [...primary.facts, ...child.facts],
+        ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+    };
+}
+export async function continueDeliveredDependents(input) {
+    const world = await withGitReadObservation(input.scope, input.channel, async (observation) => await observeActiveContractWorld(observation));
+    const pending = [input.contractId];
+    const attempted = new Set();
+    const newlyClaimed = new Set(pending);
+    const claimed = [];
+    const stopped = [];
+    let accepted = input.accepted;
+    while (pending.length > 0) {
+        const parent = pending.shift();
+        for (const candidate of directDependents(world, parent, attempted, newlyClaimed)) {
+            const contractId = candidate.state.id;
+            attempted.add(contractId);
+            const child = await continueDeliveryOperation({
+                scope: input.scope,
+                channel: input.channel,
+                state: candidate.state,
+                journal: candidate.journal,
+                deriveDocument: input.deriveDocument,
+                ...(input.resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace: input.resolveHereWorkspace }),
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            accepted = appendAccepted(accepted, child.admission);
+            if (child.evidence.completion !== undefined) {
+                claimed.push(contractId);
+                newlyClaimed.add(contractId);
+                pending.push(contractId);
+                continue;
+            }
+            const stop = child.evidence.placement;
+            if (stop === undefined)
+                throw new Error("incomplete continuation is missing its placement stop");
+            if ("refusal" in stop && stop.refusal.kind === "terminal") {
+                stopped.push({ contractId, stop: { kind: "already-terminal" } });
+            }
+            else if ("refusal" in stop && stop.refusal.kind === "delivery-missing") {
+                stopped.push({ contractId, stop: { kind: "delivery-missing" } });
+            }
+            else {
+                stopped.push({ contractId, stop });
+            }
+        }
+    }
+    return {
+        ...accepted,
+        value: {
+            ...accepted.value,
+            ...(attempted.size === 0 ? {} : { continuation: { attempted: attempted.size, claimed, stopped } }),
+        },
+    };
+}

package/build/src/library/contract.d.ts

@@ -6,7 +6,7 @@ export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { type PlacementStop, type RepositoryScope, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
 import type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow } from "../protocol/read/status.js";
 import type { AuditReport } from "../protocol/audit.js";
-import { type DeliverValue, type IntegrationConflictMaterialized, type VerificationReuse } from "../protocol/deliver.js";
+import { type IntegrationConflictMaterialized, type VerificationReuse } from "../protocol/deliver.js";
 import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
 import { type ReviewValue } from "../protocol/review.js";
 import type { FactKind } from "../core/facts/types.js";
@@ -15,7 +15,8 @@ import { type SettlementReport } from "../settlement/settle.js";
 import { type TaskId } from "../task/identity.js";
 import { Repo, type ReconcileInput } from "./repo.js";
 import { type AuditInput } from "./audit.js";
-import { Delivery } from "./delivery.js";
+import { Delivery, type DeliveryValue } from "./delivery.js";
+import { type ContinuationReport } from "./continuation.js";
 import { type MutationResult } from "./mutation.js";
 import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
 export { KeiyakuRefused, type ContractAppointmentRefusal, } from "./refusal.js";
@@ -41,8 +42,11 @@ export type ContractHistory = Readonly<{
 }>;
 export type ActorId = string;
 export type AttestationVerdict = "satisfied" | "unsatisfied";
-export type Review = ReviewValue;
+export type Review = ReviewValue & Readonly<{
+    continuation?: ContinuationReport;
+}>;
 export type { PlacementStop, VerificationReuse, VerificationStop, IntegrationConflictMaterialized };
+export type { ContinuationReport };
 export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
 export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
 export type { MutationResult };
@@ -115,7 +119,7 @@ export type DeliverInput = ActorOptions & Readonly<{
 }>;
 type ForwardedDeliveryReceipt = Readonly<{
     kind: "accepted";
-    result: MutationResult<DeliverValue>;
+    result: MutationResult<DeliveryValue>;
 }> | Readonly<{
     kind: "refused";
     refusal: KeiyakuRefusal;
@@ -125,7 +129,7 @@ type ForwardedDeliveryReceipt = Readonly<{
 }> | IntegrationConflictMaterialized;
 type ForwardedReviewReceipt = Readonly<{
     kind: "accepted";
-    result: MutationResult<ReviewValue>;
+    result: MutationResult<Review>;
 }> | Readonly<{
     kind: "refused";
     refusal: KeiyakuRefusal;