@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/src/cli/parse.js

@@ -1,7 +1,7 @@
 import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
 import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
-import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS } from "./commands/contract.js";
+import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
 import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
@@ -69,9 +69,12 @@ function scanOption(command, argv, state, index) {
         return index;
     }
     const value = argv[index + 1];
-    if (value === undefined || value === "-" || value.startsWith("--"))
+    if (value === undefined)
         refuse(command, `${token} requires a value`);
-    if (isBlankInput(value))
+    if (kind !== "raw-value" && (value === "-" || value.startsWith("--"))) {
+        refuse(command, `${token} requires a value`);
+    }
+    if (kind !== "raw-value" && isBlankInput(value))
         refuse(command, `${token} requires a nonblank value`);
     if (kind === "repeat-value") {
         const values = state.flags[name];
@@ -121,7 +124,7 @@ function parseBind(parts) {
     const task = optionalFlag(parts.flags, "task");
     const target = optionalFlag(parts.flags, "target");
     const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    const gates = optionalFlag(parts.flags, "gates");
+    const gates = parseGateBundleNames(parts, "bind");
     return {
         command: "bind",
         ...(task === undefined ? {} : { task }),
@@ -138,7 +141,7 @@ function parseAmend(parts) {
     const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
     if (parts.flags["clear-after"] === true && after.length > 0)
         refuse("amend", "--clear-after and --after are mutually exclusive");
-    const gates = optionalFlag(parts.flags, "gates");
+    const gates = parseGateBundleNames(parts, "amend");
     if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
         refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
     }
@@ -153,6 +156,16 @@ function parseAmend(parts) {
         output: parts.output,
     };
 }
+function parseGateBundleNames(parts, command) {
+    const value = optionalFlag(parts.flags, "gates");
+    if (value === undefined)
+        return undefined;
+    const names = value.split(",");
+    if (names.some((name) => name.length === 0)) {
+        refuse(command, "--gates requires nonempty comma-separated names");
+    }
+    return names;
+}
 function parseDeliver(parts) {
     const contract = parts.positionals[0];
     const message = optionalFlag(parts.flags, "message");
@@ -240,14 +253,14 @@ function parseRegion(parts) {
 }
 function parseLs(parts) {
     const path = parts.positionals[0];
-    if (path === "task/")
+    if (path === "task" || path === "task/")
         return { command: "ls", query: { kind: "tasks" }, output: parts.output };
-    if (path === "kei/")
+    if (path === "kei" || path === "kei/")
         return { command: "ls", query: { kind: "contracts" }, output: parts.output };
     try {
         const query = parseAkumaCatalogPath(path);
         if (query === null)
-            refuse("ls", "ls requires an identity directory with a trailing slash");
+            refuse("ls", "ls requires a supported identity directory selector");
         return { command: "ls", query, output: parts.output };
     }
     catch (error) {

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

@@ -7,16 +7,27 @@ const VERB_WIDTH = 6;
 function identity(id, alias) {
     return `${id}${alias === undefined ? "" : ` (${alias})`}`;
 }
-function associatedIdentity(id, alias, contractId) {
+function associatedContractId(contract) {
+    return contract.kind === "associated" ? contract.contractId : undefined;
+}
+function associatedIdentity(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
     return `${identity(id, alias)}${contractId === undefined ? "" : ` [${contractId}]`}`;
 }
-function snapshotHeading(id, alias, contractId) {
+function snapshotHeading(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
     return [
         OPENING_STROKE,
         identity(id, alias),
         ...(contractId === undefined ? [] : [`└─ ${contractId}`]),
     ];
 }
+function contractFacts(contract) {
+    return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
+}
+function unobservedText(id, diagnostic) {
+    return `! ${id} unobserved: ${safeText(diagnostic)}`;
+}
 function lifeLabel(life) {
     if (life === "running")
         return "● running";
@@ -201,11 +212,12 @@ function snapshotText(view, context, options = {}) {
         : groupedEntries(snapshot.entries, context);
     const facts = [
         ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
+        ...contractFacts(view.contract),
         ...(options.facts ?? []),
     ];
     const footer = options.showLife === false ? [] : [`  ${lifeLabel(view.status.life)}`];
     return [
-        ...snapshotHeading(view.status.id, options.alias, view.contractId),
+        ...snapshotHeading(view.status.id, options.alias, view.contract),
         ...facts,
         ...activity,
         ...footer,
@@ -213,17 +225,33 @@ function snapshotText(view, context, options = {}) {
         ...renderTaskContextLines(view.createdTasks, context.columns),
     ].join("\n");
 }
+function observationStageText(id, observation, context, options = {}) {
+    if (observation.kind === "unobserved")
+        return unobservedText(id, observation.diagnostic);
+    return snapshotText(observation, context, options);
+}
+function waitText(result, context) {
+    const alias = result.alias;
+    const blocks = [
+        ...result.result.observations.map((observation) => snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) })),
+        ...result.result.unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
+    ];
+    return blocks.join("\n\n");
+}
 function historyText(command, result, context) {
     if (command.last)
         return result.mode === "last" ? result.answer : "no answer retained";
     if (result.mode !== "page")
         throw new Error("history result lacks page");
-    const contractId = result.historyResult.contractId;
-    return [...snapshotHeading(result.akuma, result.alias, contractId), ...groupedRows(result.history.rows, context, true)].join("\n");
+    return [...snapshotHeading(result.akuma, result.alias, result.historyResult.contract), ...groupedRows(result.history.rows, context, true)].join("\n");
 }
 function tellText(result, context) {
     const facts = typeof result.result.tell.wake === "string" ? [] : [`! error ${safeText(result.result.tell.wake.diagnostic)}`];
-    return snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }), facts, showLife: false });
+    return observationStageText(result.result.akuma, result.result.observation, context, {
+        ...(result.alias === undefined ? {} : { alias: result.alias }),
+        facts,
+        showLife: false,
+    });
 }
 function dispatchLines(stage) {
     if (stage.kind === "none" || stage.kind === "dispatched")
@@ -272,7 +300,9 @@ function callText(result, context) {
         facts.push(`alias failed ${result.result.alias.failure.kind} ${safeText(result.result.alias.failure.diagnostic)}`);
     const cwd = executionCwdLine(result.result);
     if (result.result.observation.kind === "detached") {
-        const lines = [...snapshotHeading(result.result.akuma, alias, contractId), ...cwd, ...restraint, ...facts];
+        const lines = [...snapshotHeading(result.result.akuma, alias, contractId === undefined
+                ? { kind: "none" }
+                : { kind: "associated", contractId }), ...cwd, ...restraint, ...facts];
         if (!callFailed(result.result)) {
             const selector = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : result.result.akuma;
             lines.push(`$ keiyaku -C ${result.world} wait ${selector} --timeout 5m`);
@@ -280,9 +310,14 @@ function callText(result, context) {
         return lines.join("\n");
     }
     if (result.result.observation.kind === "failed") {
-        return [...snapshotHeading(result.result.akuma, alias, contractId), ...cwd, ...restraint, ...facts, `! error ${safeText(result.result.observation.failure.diagnostic)}`].join("\n");
+        return [...snapshotHeading(result.result.akuma, alias, contractId === undefined
+                ? { kind: "none" }
+                : { kind: "associated", contractId }), ...cwd, ...restraint, ...facts, `! error ${safeText(result.result.observation.failure.diagnostic)}`].join("\n");
     }
-    return snapshotText({ status: result.result.observation.status, ...(contractId === undefined ? {} : { contractId }) }, context, {
+    return snapshotText({
+        status: result.result.observation.status,
+        contract: contractId === undefined ? { kind: "none" } : { kind: "associated", contractId },
+    }, context, {
         ...(alias === undefined ? {} : { alias }),
         facts: [...cwd, ...facts],
     });
@@ -299,17 +334,25 @@ export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
         case "call": return callText(result, context);
         case "status": return snapshotText(result.status, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) });
         case "wait":
-            return result.result.observations.map((observation) => snapshotText(observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
-        case "tell": return result.mode === "ordinary" ? tellText(result, context) : snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }), showLife: false });
+            return waitText(result, context);
+        case "tell":
+            return result.mode === "ordinary"
+                ? tellText(result, context)
+                : observationStageText(result.result.id, result.result.observation, context, {
+                    ...(result.alias === undefined ? {} : { alias: result.alias }),
+                    showLife: false,
+                });
         case "history":
             return historyText(command, result, context);
         case "fork": {
             if (result.receipt.kind !== "forked")
                 return result.receipt.kind === "unknown-history" ? `${result.receipt.at} has no matching retained answered turn` : result.receipt.kind === "provider-cannot-fork" ? `${result.receipt.provider} cannot fork` : result.receipt.diagnostic;
             const contractId = result.receipt.dispatch.kind === "dispatched" ? result.receipt.dispatch.dispatch.contractId : undefined;
-            return associatedIdentity(result.receipt.child, undefined, contractId);
+            return associatedIdentity(result.receipt.child, undefined, contractId === undefined
+                ? { kind: "none" }
+                : { kind: "associated", contractId });
         }
-        case "kill": return result.result.results.map((member) => snapshotText(member.observation, context, { facts: [`kill ${member.evidence}`], ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
+        case "kill": return result.result.results.map((member) => observationStageText(member.id, member.observation, context, { facts: [`kill ${member.evidence}`], ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
     }
 }
 function callExitCode(result) {

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

@@ -1,6 +1,6 @@
 import { cleanupLines, leakLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
-import { gitShortStat, renderBoundedTextBlock, renderOpaqueBlock, } from "./terminal.js";
+import { gitShortStat, renderOpaqueBlock, } from "./terminal.js";
 const CHILD = "  ";
 function workspaceEvidence(workspace, columns) {
     return renderOpaqueBlock(`workspace ${workspace.kind} ${workspace.path}`, CHILD, columns);
@@ -46,11 +46,7 @@ function verificationLines(verification, columns, addressed) {
         { text: `${verification.passed} of ${verification.total}` },
     ], columns);
     if (verification.summary !== undefined) {
-        lines.push(...renderBoundedTextBlock(verification.summary, {
-            first: `${CHILD}summary `,
-            continuation: CHILD,
-            columns,
-        }));
+        receiptPayload(lines, "summary", verification.summary);
     }
     return lines;
 }

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

@@ -201,10 +201,37 @@ function renderAcceptedAmend(result, columns) {
     lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
     return lines.join("\n");
 }
+function reintegrationLines(result, complete, columns) {
+    const reintegrated = result.facts.filter((fact) => fact.kind === "reintegrated");
+    if (reintegrated.length === 0)
+        return [];
+    const lines = [];
+    for (const fact of reintegrated) {
+        receiptRow(lines, " ", "re-integrated", [
+            { text: fact.data.predecessor, opaque: true },
+            { text: "->" },
+            { text: fact.data.snapshot, opaque: true },
+        ], columns);
+    }
+    if (result.verificationVerdict !== undefined) {
+        receiptRow(lines, " ", "verification re-run", [
+            { text: "·" },
+            { text: result.verificationVerdict },
+        ], columns);
+    }
+    if (complete) {
+        receiptRow(lines, " ", "target", [
+            { text: "->" },
+            { text: reintegrated.at(-1).data.snapshot, opaque: true },
+        ], columns);
+    }
+    return lines;
+}
 function renderAcceptedDeliver(result, columns) {
     const complete = result.facts.some((fact) => fact.kind === "claimed");
     const title = complete ? "delivered" : "deliver — not complete";
     const lines = titleLines("✓", title, result.contract, columns);
+    lines.push(...reintegrationLines(result, complete, columns));
     if (!complete)
         receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
     if (result.verification !== undefined) {
@@ -229,12 +256,20 @@ function renderAcceptedDeliver(result, columns) {
 function renderAcceptedReview(result, columns) {
     const complete = result.facts.some((fact) => fact.kind === "claimed");
     const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
+    lines.push(...reintegrationLines(result, complete, columns));
     receiptRow(lines, complete ? "✓" : "!", "contract", [
         { text: complete ? "complete" : "not complete" },
     ], columns);
     if (result.placement !== undefined) {
         lines.push(...stopLines("completion", result.placement, columns, result.contract));
     }
+    if (result.verification !== undefined) {
+        lines.push(...stopLines("verification", result.verification, columns, result.contract));
+    }
+    if (result.cleanup !== undefined)
+        pushBlock(lines, cleanupLines(result.cleanup, columns));
+    if (result.leak !== undefined)
+        pushBlock(lines, leakLines(result.leak, columns));
     lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
     return lines.join("\n");
 }
@@ -338,6 +373,11 @@ function journalBody(fact) {
                 `  require-branches-to-be-up-to-date ${String(policy.requireBranchesToBeUpToDate)}`,
             ];
         }
+        case "reintegrated":
+            return [
+                `  predecessor ${fact.data.predecessor}`,
+                `  snapshot ${fact.data.snapshot}`,
+            ];
         case "attestation": {
             const lines = [
                 `  gate ${fact.data.gate}`,

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

@@ -59,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) {
@@ -76,12 +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 = [];
     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/result.d.ts

@@ -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<{
@@ -80,18 +88,18 @@ export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
 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;
-    verificationVerdict?: never;
     chapter?: never;
     note?: never;
 }>;

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) {
@@ -132,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))
@@ -238,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 {};