@astrosheep/keiyaku 4.0.3 → 4.0.5

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

@@ -193,7 +193,56 @@ function endpointFact(id, observed) {
         return `-> ${id} (unavailable)`;
     return `-> ${id}`;
 }
-function renderContracts(report, context, selection) {
+function renderNamespaceTasks(row, context) {
+    if (row.namespaceTasks.kind === "absent")
+        return plumbFacts(["namespace tasks absent"], context.columns);
+    if (row.namespaceTasks.kind === "failed") {
+        return plumbFacts([`namespace tasks failed ${row.namespaceTasks.failure.message}`], context.columns);
+    }
+    const lines = [...plumbFacts([`namespace tasks ${row.namespaceTasks.value.length}`], context.columns)];
+    for (const task of row.namespaceTasks.value) {
+        const scan = `${taskMark(task)} ${task.id} · P${task.priority} ${task.disposition}`;
+        const title = safeText(task.title);
+        const inline = `${scan} — ${title}`;
+        if (displayColumns(inline) <= context.columns - displayColumns(PLUMB)) {
+            lines.push(...plumbFacts([inline], context.columns));
+        }
+        else {
+            lines.push(...plumbFacts([`${scan} —`], context.columns));
+            lines.push(...plumbBlock(title, context.columns));
+        }
+    }
+    return lines;
+}
+function renderContractRow(row, report, context, selection) {
+    const hot = contractHot(row);
+    const compact = !hot && selection !== "contract";
+    const title = row.title ?? "title unavailable";
+    const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
+    const lines = [identityLine(contractMark(row), row.id)];
+    lines.push(...plumbFacts(compact ? [title, phase, ...targetFacts(row)] : [title], context.columns));
+    if (!compact)
+        lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
+    lines.push(...plumbFacts([workspaceState(row)], context.columns));
+    if (showWorkspacePath(row, hot || selection === "contract")
+        && row.workspaceObservation.kind !== "unappointed"
+        && row.workspaceObservation.location.kind === "worktree") {
+        lines.push(plumbPath(row.workspaceObservation.location.path));
+    }
+    lines.push(...renderGates(row.gates.reports, report.observedAt, context.columns, selection === "contract"));
+    if (row.holder.kind === "held")
+        lines.push(...plumbFacts([`task ${row.holder.taskId}`], context.columns));
+    if (row.holder.kind === "unavailable")
+        lines.push(...plumbFacts(["holder unavailable"], context.columns));
+    for (const attached of row.fleet) {
+        const aliases = attached.aliases.length === 0 ? "" : ` (${attached.aliases.join(" ")})`;
+        lines.push(...plumbFacts([`akuma ${attached.id}${aliases}`], context.columns));
+    }
+    if (selection === "contract")
+        lines.push(...renderNamespaceTasks(row, context));
+    return lines;
+}
+function renderContracts(report, context) {
     const section = report.contracts;
     if (section.kind === "absent")
         return sectionAbsent("KEIYAKU", context.columns);
@@ -204,37 +253,21 @@ function renderContracts(report, context, selection) {
         ...section.value.rows.filter((row) => !contractHot(row)),
     ];
     const lines = [aperture("KEIYAKU", context.columns)];
-    for (const row of rows) {
-        const hot = contractHot(row);
-        const compact = !hot && selection !== "contract";
-        const title = row.title ?? "title unavailable";
-        const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
-        lines.push(identityLine(contractMark(row), row.id));
-        lines.push(...plumbFacts(compact
-            ? [title, phase, ...targetFacts(row)]
-            : [title], context.columns));
-        if (!compact)
-            lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
-        lines.push(...plumbFacts([workspaceState(row)], context.columns));
-        if (showWorkspacePath(row, hot || selection === "contract")
-            && row.workspaceObservation.kind !== "unappointed"
-            && row.workspaceObservation.location.kind === "worktree") {
-            lines.push(plumbPath(row.workspaceObservation.location.path));
-        }
-        lines.push(...renderGates(row.gates.reports, report.observedAt, context.columns, selection === "contract"));
-        if (row.holder.kind === "held")
-            lines.push(...plumbFacts([`task ${row.holder.taskId}`], context.columns));
-        if (row.holder.kind === "unavailable")
-            lines.push(...plumbFacts(["holder unavailable"], context.columns));
-        for (const attached of row.fleet) {
-            const aliases = attached.aliases.length === 0 ? "" : ` (${attached.aliases.join(" ")})`;
-            lines.push(...plumbFacts([`akuma ${attached.id}${aliases}`], context.columns));
-        }
-    }
+    for (const row of rows)
+        lines.push(...renderContractRow(row, report, context, "world"));
     const attention = rows.filter(contractHot).length;
     lines.push(aperture(`${rows.length} keiyaku · ${attention} attention`, context.columns));
     return lines;
 }
+function renderSelectedContract(report, context) {
+    const section = report.contracts;
+    if (section.kind === "absent")
+        return [`${PLUMB}keiyaku absent`];
+    if (section.kind === "failed")
+        return [tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
+    const row = section.value.rows[0];
+    return row === undefined ? [`${PLUMB}keiyaku absent`] : renderContractRow(row, report, context, "contract");
+}
 function renderTasks(report, context) {
     const section = report.tasks;
     if (section.kind === "absent")
@@ -335,10 +368,12 @@ function splitHorizon(report, columns) {
     return [`kanshi ${HORIZON}${RULE.repeat(left)} ${aggregate} ${HORIZON}${RULE.repeat(right)} ${world}`];
 }
 export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
+    if (selection === "contract")
+        return renderSelectedContract(report, context).join("\n");
     return [
         ...splitHorizon(report, context.columns),
         "",
-        ...renderContracts(report, context, selection),
+        ...renderContracts(report, context),
         "",
         ...renderTasks(report, context),
         "",

package/build/src/cli/render/receipt.d.ts

@@ -10,10 +10,11 @@ type HookFailure = Extract<Lag, {
 export declare function receiptRow(lines: string[], mark: string, label: string, segments: readonly ReceiptSegment[], columns: number): void;
 export declare function receiptPayload(lines: string[], label: string, payload: string): void;
 export declare function outcomeLines(mark: "✓" | "!" | "?", verb: string, word: "accepted" | "refused" | "retry", contract: string | undefined, columns?: number): string[];
+export declare function titleLines(mark: string, title: string, contract: string, columns?: number): string[];
 export declare function hookFailureSummary(failure: HookFailure): string;
 export declare function appendHookPayload(lines: string[], failure: HookFailure): void;
 export declare function reuseLines(reuse: VerificationReuse | undefined, columns: number): readonly string[];
-export declare function stopLines(label: "verification" | "claim", stop: VerificationStop | PlacementStop, columns: number, addressed: string): readonly string[];
+export declare function stopLines(label: "verification" | "completion", stop: VerificationStop | PlacementStop, columns: number, addressed: string): readonly string[];
 export declare function cleanupLines(cleanup: NonNullable<AcceptedDeliverResult["cleanup"]>, columns: number): readonly string[];
 export declare function leakLines(leak: NonNullable<AcceptedDeliverResult["leak"]>, columns: number): readonly string[];
 export {};

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

@@ -30,6 +30,13 @@ export function outcomeLines(mark, verb, word, contract, columns = 80) {
         return [inline];
     return [`${base} —`, `  ${safeText(contract)}`];
 }
+export function titleLines(mark, title, contract, columns = 80) {
+    const base = `${mark} ${title}`;
+    const inline = `${base} — ${contract}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return [`${base} —`, `  ${safeText(contract)}`];
+}
 export function hookFailureSummary(failure) {
     if (failure.kind === "timeout" || failure.kind === "unknown-exit")
         return failure.kind;
@@ -52,6 +59,32 @@ export function reuseLines(reuse, columns) {
         return [];
     return renderOpaqueBlock(`reuse verification ${reuse.entry} ${reuse.verdict}`, "   ", columns);
 }
+function prerequisiteRows(stop, columns) {
+    if (!("refusal" in stop) || stop.refusal?.kind !== "prerequisites-unsatisfied")
+        return [];
+    const lines = [];
+    for (const prerequisite of stop.refusal.unmet) {
+        receiptRow(lines, " ", "prerequisite", [
+            { text: prerequisite.contractId, opaque: true },
+            { text: "·" },
+            { text: prerequisite.state },
+        ], columns);
+    }
+    return lines;
+}
+function targetMovedDetail(stop) {
+    if ("integratedAt" in stop) {
+        return [
+            { text: stop.target, opaque: true },
+            { text: `${stop.integratedAt} -> ${stop.observed}`, opaque: true },
+            { text: `attempts=${stop.attempts}` },
+        ];
+    }
+    return [
+        { text: stop.target, opaque: true },
+        { text: `${stop.expected} -> ${stop.observed}`, opaque: true },
+    ];
+}
 export function stopLines(label, stop, columns, addressed) {
     const detail = [];
     if ("refusal" in stop && stop.refusal !== undefined) {
@@ -69,11 +102,13 @@ export function stopLines(label, stop, columns, addressed) {
             detail.push({ text: `command=${stop.command}` }, { text: hookFailureSummary(stop.detail), opaque: true });
         }
         else if (stop.failure === "target-moved") {
-            detail.push({ text: stop.target, opaque: true }, { text: `${stop.expected} -> ${stop.observed}`, opaque: true });
+            detail.push(...targetMovedDetail(stop));
         }
     }
     const lines = [];
-    receiptRow(lines, "!", label, detail, columns);
+    const state = label === "verification" ? "failed" : "blocked";
+    receiptRow(lines, "!", label, [{ text: state }, { text: "·" }, ...detail], columns);
+    lines.push(...prerequisiteRows(stop, columns));
     if ("failure" in stop && stop.failure === "environment-failure" && "command" in stop) {
         appendHookPayload(lines, stop.detail);
     }

package/build/src/cli/render/terminal.d.ts

@@ -23,8 +23,6 @@ export declare function renderBoundedTextBlock(value: string, input: Readonly<{
     truncated?: boolean;
 }>): readonly string[];
 export declare function safeText(value: string): string;
-export declare function renderFacts(primary: string, facts: readonly string[], columns: number): readonly string[];
 export declare function renderTextBlock(value: string, indent: string, columns: number): readonly string[];
 export declare function renderOpaqueBlock(value: string, indent: string, columns: number): readonly string[];
-export declare function renderVoiceRuler(left: string, right: string, columns: number): string;
 export declare function tone(value: string, kind: "dim" | "alert", color: boolean): string;

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

@@ -110,28 +110,6 @@ export function renderBoundedTextBlock(value, input) {
 export function safeText(value) {
     return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => /\s/u.test(character) ? " " : "�");
 }
-export function renderFacts(primary, facts, columns) {
-    const head = safeText(primary);
-    const clean = facts.map(safeText);
-    if (clean.length === 0)
-        return [head];
-    const inline = `${head}  ${clean.join(" · ")}`;
-    if (displayColumns(inline) <= columns)
-        return [inline];
-    const lines = [head];
-    let current = "  ";
-    for (const fact of clean) {
-        const candidate = current === "  " ? `${current}${fact}` : `${current} · ${fact}`;
-        if (current !== "  " && displayColumns(candidate) > columns) {
-            lines.push(current);
-            current = `  ${fact}`;
-        }
-        else
-            current = candidate;
-    }
-    lines.push(current);
-    return lines;
-}
 export function renderTextBlock(value, indent, columns) {
     const words = safeText(value).trim().split(/\s+/u).filter((word) => word.length > 0);
     if (words.length === 0)
@@ -183,13 +161,6 @@ export function renderOpaqueBlock(value, indent, columns) {
     }
     return lines;
 }
-export function renderVoiceRuler(left, right, columns) {
-    const width = Math.max(20, Math.min(80, columns));
-    const occupied = displayColumns(left) + displayColumns(right) + 2;
-    if (occupied >= width)
-        return `${left}\n${"─".repeat(Math.max(1, width - displayColumns(right) - 1))} ${right}`;
-    return `${left} ${"─".repeat(width - occupied)} ${right}`;
-}
 export function tone(value, kind, color) {
     if (!color)
         return value;

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

@@ -1,5 +1,5 @@
 import { renderObservation } from "./board.js";
-import { renderAccepted, renderRetry } from "./contract.js";
+import { renderAccepted, renderContractHistory, renderRetry } from "./contract.js";
 import { renderKanshiText } from "./kanshi.js";
 import { renderRefusal } from "./refusal.js";
 import { renderCatalogText } from "./catalog.js";
@@ -11,6 +11,8 @@ export function renderText(result, context) {
         return renderKanshiText(result.report, context, result.selection);
     if (result.kind === "catalog")
         return renderCatalogText(result.catalog);
+    if (result.kind === "contract-history")
+        return renderContractHistory(result.history);
     if (result.kind === "region")
         return renderRegionText(result.region);
     if (result.kind === "accepted")

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

@@ -1,4 +1,4 @@
-import type { AuditReport, ContractId, Fact, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
+import type { AuditReport, ContractHistory, ContractId, Fact, 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";
@@ -11,11 +11,19 @@ export type BindDraftReceipt = Readonly<{
     warning: string;
 }>;
 export type Effect = ReconcileReport["effects"][number];
-export type AcceptedFact = Readonly<{
+type AcceptedFactEnvelope = Readonly<{
     contract: ContractId;
     entry: string;
-    kind: Fact["kind"];
 }>;
+export type AcceptedFact = (AcceptedFactEnvelope & Readonly<{
+    kind: Exclude<Fact["kind"], "reintegrated">;
+    data?: never;
+}>) | (AcceptedFactEnvelope & Readonly<{
+    kind: "reintegrated";
+    data: Extract<Fact, {
+        kind: "reintegrated";
+    }>["data"];
+}>);
 export type Lag = ReconcileReport["lag"][number];
 type MutationEnvelope = Pick<MutationResult<unknown>, "head" | "effects" | "settlement">;
 export type AcceptedEnvelope = Readonly<{
@@ -29,6 +37,7 @@ export type AcceptedEnvelope = Readonly<{
 }>;
 export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     verb: "bind";
+    workspace: "worktree" | "here";
     target: string | null;
     verification?: never;
     verificationReuse?: never;
@@ -36,8 +45,11 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     cleanup?: never;
     leak?: never;
     report?: never;
-    workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }> & RegionObservation;
 export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     verb: "amend";
@@ -50,9 +62,14 @@ export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     leak?: never;
     report?: never;
     workspace?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }> & RegionObservation;
 export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     verb: "deliver";
+    verificationVerdict?: "satisfied" | "unsatisfied";
     verification?: VerificationStop;
     verificationReuse?: VerificationReuse;
     placement?: PlacementStop;
@@ -64,23 +81,34 @@ export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
     verb: "review";
+    verdict: "satisfied" | "unsatisfied";
+    verificationVerdict?: "satisfied" | "unsatisfied";
+    verification?: VerificationStop;
+    verificationReuse?: VerificationReuse;
     placement?: PlacementStop;
     workspace?: Review["workspace"];
+    cleanup?: MutationResult<unknown>["cleanup"];
+    leak?: MutationResult<unknown>["leak"];
     target?: never;
-    verification?: never;
-    verificationReuse?: never;
-    cleanup?: never;
-    leak?: never;
     overlaps?: never;
     overlapFailure?: never;
     report?: never;
     diff?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
     verb: "arc";
+    chapter: Readonly<{
+        seq: number;
+        title: string;
+    }>;
     target?: never;
     verification?: never;
     verificationReuse?: never;
@@ -92,9 +120,13 @@ export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    note?: never;
 }>;
 export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     verb: "abandon";
+    note?: string;
     target?: never;
     verification?: never;
     verificationReuse?: never;
@@ -106,6 +138,9 @@ export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
 }>;
 export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     verb: "audit";
@@ -120,6 +155,10 @@ export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     overlapFailure?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedResult = AcceptedBindResult | AcceptedAmendResult | AcceptedDeliverResult | AcceptedReviewResult | AcceptedArcResult | AcceptedAbandonResult | AcceptedAuditResult;
 export type RefusedResult = Readonly<{
@@ -158,5 +197,9 @@ export type CatalogResult = Readonly<{
     kind: "catalog";
     catalog: Catalog;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult;
+export type ContractHistoryResult = Readonly<{
+    kind: "contract-history";
+    history: ContractHistory;
+}>;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult;
 export {};

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

@@ -6,4 +6,5 @@ export type SelectedContract = Readonly<{
 }>;
 export declare function contractFromInput(repo: Repo, value: string): SelectedContract;
 export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
+export declare function canonicalContractSelector(selector: string): ContractId;
 export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;

package/build/src/cli/selectors.js

@@ -50,12 +50,7 @@ export function resolveContextualContract(board, selector, scope) {
         return resolveShortContract(board.rows, selector);
     return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
 }
-export function resolveKanshiContract(report, selector) {
-    if (report.contracts.kind !== "present") {
-        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
-    }
-    if (selector.startsWith("@"))
-        return resolveShortContract(report.contracts.value.rows, selector);
+export function canonicalContractSelector(selector) {
     try {
         identitySegments({ family: "kei", value: selector });
     }
@@ -64,3 +59,11 @@ export function resolveKanshiContract(report, selector) {
     }
     return selector;
 }
+export function resolveKanshiContract(report, selector) {
+    if (report.contracts.kind !== "present") {
+        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
+    }
+    if (selector.startsWith("@"))
+        return resolveShortContract(report.contracts.value.rows, selector);
+    return canonicalContractSelector(selector);
+}

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

@@ -1,6 +1,6 @@
 import { type DerivedFileAction } from "./coordination/durable-file.js";
 import { type ContractId, type ContractState } from "./core/facts/types.js";
-import { type GitRepository } from "./git/repository.js";
+import { type GitRepository } from "./git/process.js";
 import { type PlaceRegister } from "./workspace-place.js";
 export declare function renderContractGuidance(state: ContractState): string;
 export type ContractFileEffect = Readonly<{
@@ -40,5 +40,4 @@ export type ContractReservation = Readonly<{
 export declare function reserveContractWorktree(repository: GitRepository, contract: ContractId): Promise<ContractReservation>;
 export declare function withContractWorktreeAppointment<T>(repository: GitRepository, action: () => T | Promise<T>): Promise<T>;
 export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
-export declare function removeContractWorktreeAppointment(repository: GitRepository, contract: ContractId): Promise<void>;
 export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister): Promise<ContractWorktreeResult>;

package/build/src/contract-worktree.js

@@ -3,9 +3,10 @@ import { join } from "node:path";
 import { acquireSqliteTransactionLock } from "./coordination/sqlite-transaction-lock.js";
 import { createFileDurablyExclusive, repairDerivedFile, } from "./coordination/durable-file.js";
 import { contractId } from "./core/facts/types.js";
-import { GitPlumbingError, runGit, worktreeGitDirectory, worktreeRoot, } from "./git/repository.js";
+import { worktreeGitDirectory, worktreeRoot, } from "./git/repository.js";
+import { GitPlumbingError, runGit } from "./git/process.js";
 import { worktreePath } from "./git/workspace.js";
-import { appointmentFor, placeRegisterPath, readPlaceRegister, } from "./workspace-place.js";
+import { appointmentFor, placeRegisterPath, } from "./workspace-place.js";
 const IGNORE_BYTES = ".gitignore\nKEIYAKU.md\n";
 const APPOINTMENT_DESCRIPTION = "This is a read-only projection. Do not edit manually.";
 function appointmentBytes(contract) {
@@ -48,6 +49,9 @@ const FULFILLMENT = [
     "### Deliverer", "",
     "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
     "When an Arc is active, stay within that current chapter.",
+    "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.", "",
     "### Reviewer", "",
     "Review this Contract worktree against the complete Contract.",
@@ -129,12 +133,6 @@ export async function releaseContractWorktree(repository, contract) {
     }
     catch { /* reservation cleanup is best effort */ }
 }
-export async function removeContractWorktreeAppointment(repository, contract) {
-    const appointment = await readContractAppointment(repository);
-    if (appointment.kind !== "appointed" || appointment.contract !== contract)
-        return;
-    await unlink(appointment.path);
-}
 async function repair(repository, worktree, relativePath, bytes) {
     const path = join(worktree, relativePath);
     if (await isTracked(repository, relativePath))
@@ -235,7 +233,7 @@ export async function projectContractWorktree(repository, state, register) {
     if (state.coordinates.workspace === "here") {
         return await here(repository, state, renderContractGuidance(state));
     }
-    const appointed = appointmentFor(register ?? await readPlaceRegister(repository), state.id);
+    const appointed = register === undefined ? undefined : appointmentFor(register, state.id);
     if (appointed === undefined) {
         return {
             effects: [],

package/build/src/core/facts/codec.js

@@ -6,6 +6,7 @@ const VERSION_BY_KIND = {
     amend: 1,
     bound: 1,
     deliver: 1,
+    reintegrated: 1,
     attestation: 1,
     claimed: 1,
     arc: 1,
@@ -182,6 +183,14 @@ function validateData(kind, value) {
                 },
             };
         }
+        case "reintegrated": {
+            const object = requireRecord(value, path);
+            requireKeys(object, ["predecessor", "snapshot"], path);
+            return {
+                predecessor: brandedValue(object.predecessor, `${path}.predecessor`, snapshotId),
+                snapshot: brandedValue(object.snapshot, `${path}.snapshot`, snapshotId),
+            };
+        }
         case "attestation":
             return validateAttestation(value, path);
         case "claimed": {

package/build/src/core/facts/fold.js

@@ -24,6 +24,7 @@ function stateFromBind(id, head, bind, attestations) {
         terms: cloneTerms(bind.data.terms),
         bound: null,
         delivery: null,
+        currentIntegration: null,
         attestations,
         terminal: null,
     };
@@ -55,7 +56,18 @@ function foldEntry(state, entry, attestations) {
         case "deliver":
             if (state.bound === null)
                 foldError("deliver requires bound");
-            return { ...state, delivery: entry };
+            return { ...state, delivery: entry, currentIntegration: { ...entry.data.integration } };
+        case "reintegrated":
+            if (state.delivery === null)
+                foldError("reintegrated requires a deliver");
+            return {
+                ...state,
+                currentIntegration: {
+                    predecessor: entry.data.predecessor,
+                    snapshot: entry.data.snapshot,
+                    changeId: state.delivery.data.integration.changeId,
+                },
+            };
         case "attestation":
             attestations.push(entry);
             return { ...state, attestations };

package/build/src/core/facts/types.d.ts

@@ -85,6 +85,11 @@ export type DeliverData = Readonly<{
         requireBranchesToBeUpToDate: boolean;
     }>;
 }>;
+export type CurrentIntegration = DeliverData["integration"];
+export type ReintegratedData = Readonly<{
+    predecessor: SnapshotId;
+    snapshot: SnapshotId;
+}>;
 export type AttestationData = Readonly<{
     gate: Gate;
     subject: DependencyKeySet;
@@ -116,11 +121,12 @@ export type BindEntry = JournalEnvelope<"bind", BindData>;
 type AmendEntry = JournalEnvelope<"amend", AmendData>;
 type BoundEntry = JournalEnvelope<"bound", BoundData>;
 type DeliverEntry = JournalEnvelope<"deliver", DeliverData>;
+export type ReintegratedEntry = JournalEnvelope<"reintegrated", ReintegratedData>;
 export type AttestationEntry = JournalEnvelope<"attestation", AttestationData>;
 type ClaimedEntry = JournalEnvelope<"claimed", ClaimedData>;
 export type ArcEntry = JournalEnvelope<"arc", ArcData>;
 type AbandonedEntry = JournalEnvelope<"abandoned", AbandonedData>;
-export type JournalEntry = BindEntry | AmendEntry | BoundEntry | DeliverEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
+export type JournalEntry = BindEntry | AmendEntry | BoundEntry | DeliverEntry | ReintegratedEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
 export type FactKind = JournalEntry["kind"];
 type ContractTerminal = ClaimedEntry | AbandonedEntry;
 export type ContractState = Readonly<{
@@ -130,6 +136,7 @@ export type ContractState = Readonly<{
     terms: ContractTerms;
     bound: BoundEntry | null;
     delivery: DeliverEntry | null;
+    currentIntegration: CurrentIntegration | null;
     attestations: readonly AttestationEntry[];
     currentArc?: ArcEntry;
     terminal: ContractTerminal | null;

package/build/src/core/subject.js

@@ -65,12 +65,13 @@ export function parseDependencyKeySet(value) {
     return decodeDependencyKeySet(value).canonical;
 }
 function currentKeys(state) {
+    const integration = state.currentIntegration ?? state.delivery?.data.integration;
     return new Set([
         encodeKey({ kind: "document", value: state.terms.document.key }),
         ...state.terms.segments.map((value) => encodeKey({ kind: "segment", value })),
-        ...(state.delivery === null ? [] : [
-            encodeKey({ kind: "snapshot", value: state.delivery.data.integration.snapshot }),
-            encodeKey({ kind: "change", value: state.delivery.data.integration.changeId }),
+        ...(integration === undefined ? [] : [
+            encodeKey({ kind: "snapshot", value: integration.snapshot }),
+            encodeKey({ kind: "change", value: integration.changeId }),
         ]),
     ]);
 }

package/build/src/core/verbs/placement.d.ts

@@ -5,9 +5,17 @@ type PlacementInput = Readonly<{
     actor?: ActorId;
     at: string;
 }>;
+export type UnmetPrerequisite = Readonly<{
+    contractId: ContractId;
+    state: "missing" | "active" | "abandoned";
+}>;
 export type PlacementRefusal = Readonly<{
-    kind: "contract-missing" | "delivery-missing" | "terminal" | "prerequisites-unsatisfied" | "gates-unsatisfied";
+    kind: "contract-missing" | "delivery-missing" | "terminal" | "gates-unsatisfied";
+    contractId: ContractId;
+}> | Readonly<{
+    kind: "prerequisites-unsatisfied";
     contractId: ContractId;
+    unmet: readonly UnmetPrerequisite[];
 }>;
 export declare function decidePlacement({ input, attempt, observation }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;
 export {};