@astrosheep/keiyaku 4.6.2 → 4.6.3

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

@@ -19,9 +19,9 @@ function contractStatusTone(row, observedAt) {
     if (contractHasError(row))
         return "alert";
     const phaseAge = elapsedMilliseconds(row.phaseAt, observedAt);
-    if (row.phase === "delivered" && phaseAge !== null && phaseAge >= REVIEW_ATTENTION_MS)
+    if (row.phase === "bound" && row.delivery !== null && phaseAge !== null && phaseAge >= REVIEW_ATTENTION_MS)
         return "attention";
-    if (row.phase === "bound" && phaseAge !== null && phaseAge >= PENDING_ATTENTION_MS)
+    if (row.phase === "bound" && row.delivery === null && phaseAge !== null && phaseAge >= PENDING_ATTENTION_MS)
         return "attention";
     const journalAge = elapsedMilliseconds(row.lastJournalAt, observedAt);
     return journalAge !== null && journalAge <= RECENT_TONE_MS ? "recent" : null;
@@ -153,34 +153,28 @@ function renderSelectedContractRow(row, report, context, abbreviations) {
         lines.push(...outcome.map((fact) => (fact.startsWith("  ") ? fact : `  ${safeText(fact)}`)));
         return lines;
     }
-    if (row.phase === "bound") {
-        lines.push(...semanticBlock("gates", row.gates.reports.map(gateFact), context));
-        lines.push(...semanticBlock("prerequisites", row.after.filter((edge) => edge.endpoint.kind !== "claimed").map(afterWording), context));
-        lines.push(...semanticBlock("ball", [progressStrip(row)], context));
-        const akuma = linkedAkumaSummary(row, report);
-        if (akuma !== undefined)
-            lines.push(...semanticBlock("akuma", [akuma], context));
-        if (row.worktreePath !== null)
-            lines.push(...semanticBlock("worktree", [`worktree  ${row.worktreePath}`], context));
-    }
-    else {
-        lines.push(...semanticBlock("ball", [progressStrip(row)], context));
-        lines.push(...semanticBlock("prerequisites", row.after.filter((edge) => edge.endpoint.kind !== "claimed").map(afterWording), context));
-        if (row.delivery !== null) {
-            lines.push(...semanticBlock("candidate", [
-                `candidate  ${displayGitId(row.delivery.tenderSnapshot, abbreviations)}`,
-                `integration result  ${displayGitId(row.delivery.integration.snapshot, abbreviations)}${row.verification?.kind === "recorded" && row.verification.snapshot === row.delivery.integration.snapshot ? ` · verification ${row.verification.verdict}` : ""}${row.targetObservation?.drift === true ? " · target moved since" : ""}`,
-                ...(row.targetObservation?.drift === true ? targetMovementFacts(row, abbreviations) : []),
-            ], context));
-        }
+    const deniedReview = row.gates.reports.find((gate) => gate.gate === "reviewed" && gate.current.kind === "attested" && gate.current.verdict === "unsatisfied");
+    lines.push(...semanticBlock("ball", [progressStrip(row)], context));
+    lines.push(...semanticBlock("gates", row.gates.reports
+        .filter((gate) => gate.current.kind !== "missing")
+        .filter((gate) => gate !== deniedReview || gate.current.kind !== "attested" || gate.current.summary === undefined)
+        .map(gateFact), context));
+    lines.push(...semanticBlock("prerequisites", row.after.filter((edge) => edge.endpoint.kind !== "claimed").map(afterWording), context));
+    if (row.delivery !== null) {
+        lines.push(...semanticBlock("candidate", [
+            `candidate  ${displayGitId(row.delivery.tenderSnapshot, abbreviations)}`,
+            `integration result  ${displayGitId(row.delivery.integration.snapshot, abbreviations)}${row.verification?.kind === "recorded" && row.verification.snapshot === row.delivery.integration.snapshot ? ` · verification ${row.verification.verdict}` : ""}${row.targetObservation?.drift === true ? " · target moved since" : ""}`,
+            ...(row.targetObservation?.drift === true ? targetMovementFacts(row, abbreviations) : []),
+        ], context));
         lines.push(...semanticBlock("verification", staleVerificationFacts(row), context));
-        const deniedReview = row.gates.reports.find((gate) => gate.gate === "reviewed" && gate.current.kind === "attested" && gate.current.verdict === "unsatisfied");
-        lines.push(...semanticBlock("gates", row.gates.reports
-            .filter((gate) => gate !== deniedReview || gate.current.kind !== "attested" || gate.current.summary === undefined)
-            .map(gateFact), context));
-        if (deniedReview?.current.kind === "attested" && deniedReview.current.summary !== undefined)
-            lines.push(...payload("review  ×", deniedReview.current.summary, context));
     }
+    if (deniedReview?.current.kind === "attested" && deniedReview.current.summary !== undefined)
+        lines.push(...payload("review  ×", deniedReview.current.summary, context));
+    const akuma = linkedAkumaSummary(row, report);
+    if (akuma !== undefined)
+        lines.push(...semanticBlock("akuma", [akuma], context));
+    if (row.worktreePath !== null)
+        lines.push(...semanticBlock("worktree", [`worktree  ${row.worktreePath}`], context));
     lines.push(...semanticBlock("alarms", liveAlarms(row, report), context));
     return lines;
 }
@@ -209,7 +203,7 @@ function renderWorldContractRow(row, report, context) {
 function renderContracts(report, context) {
     const section = report.contracts;
     if (section.kind === "absent")
-        return ["CONTRACTS // absent", "", "  contracts absent"];
+        return ["CONTRACTS // absent"];
     if (section.kind === "failed")
         return ["CONTRACTS // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     if (section.value.rows.length === 0)
@@ -238,7 +232,7 @@ function taskFailureFact(failure) {
 function renderTasks(report, context) {
     const section = report.tasks;
     if (section.kind === "absent")
-        return ["TASKS // absent", "", "  tasks absent"];
+        return ["TASKS // absent"];
     if (section.kind === "failed")
         return [
             "TASKS // unavailable",

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

@@ -1,5 +1,5 @@
 import type { ExecutionCleanup, ExecutionStop, PartialOutcomeEnvelope, ReconciliationLag } from "../../index.js";
-import type { PlacementStop, VerificationReuse, VerificationStop } from "../../index.js";
+import type { PlacementStop, VerificationStop } from "../../index.js";
 export type ReceiptSegment = Readonly<{
     text: string;
     opaque?: boolean;
@@ -14,7 +14,6 @@ export declare function refusalLines(verb: string, facts: readonly string[], col
 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[];
 /**
  * The pending margin statement: the not-yet-happened requirements a refused placement awaits. A gate in stale
  * state awaits the same event; when every unmet gate already holds a recorded verdict there is nothing pending and

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

@@ -64,11 +64,6 @@ export function appendHookPayload(lines, failure) {
     if (failure.stderr !== undefined && failure.stderr.length > 0)
         receiptPayload(lines, "stderr", failure.stderr);
 }
-export function reuseLines(reuse, columns) {
-    if (reuse === undefined)
-        return [];
-    return renderOpaqueBlock(`reuse  verified · ${reuse.verdict}`, "  ", columns);
-}
 function prerequisiteRows(stop, columns) {
     if (!("refusal" in stop) || stop.refusal?.kind !== "prerequisites-unsatisfied")
         return [];
@@ -97,7 +92,7 @@ function gateAlarmRows(stop, columns) {
             continue;
         receiptRow(lines, "!", eventNoun(gate), [{ text: `· ${current.verdict}` }, { text: `· at ${current.at}` }], columns);
         if (current.summary !== undefined)
-            receiptPayload(lines, `  summary ${gate}`, current.summary);
+            receiptPayload(lines, "  summary", current.summary);
     }
     return lines;
 }

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

@@ -104,7 +104,8 @@ function refusalFacts(refusal, indent, columns, addressed) {
     if (identity !== undefined)
         lines.push(`${indent}contract  ${safeText(identity)}`);
     if ("diagnostic" in refusal && typeof refusal.diagnostic === "string")
-        lines.push(`${indent}detail  ${safeText(refusal.diagnostic)}`);
+        for (const detail of refusal.diagnostic.split("\n"))
+            lines.push(`${indent}detail  ${safeText(detail)}`);
     return lines;
 }
 export function renderRefusalFacts(refusal, indent, columns, addressed) {

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

@@ -246,7 +246,8 @@ function renderBatchItem(verb, item, columns) {
     if (item.outcome.kind === "retry")
         return `? ${verb}  ${item.id}  ${item.outcome.reason}`;
     const facts = projectRefusal(item.outcome.refusal);
-    return refusalLines(verb, [`task  ${item.id}`, `reason  ${facts.diagnostic}`, ...(facts.facts ?? [])], columns).join("\n");
+    const rest = (facts.facts ?? []).filter((fact) => fact !== `task  ${item.id}`);
+    return refusalLines(verb, [`task  ${item.id}`, `reason  ${facts.diagnostic}`, ...rest], columns).join("\n");
 }
 function renderBatch(verb, batch, columns) {
     return batch.items.map((item) => renderBatchItem(verb, item, columns)).join("\n");

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

@@ -4,7 +4,6 @@ import { changeId, actorId, contractId, documentKey, documentSegmentKey, entryUl
 const VERSION_BY_KIND = {
     bind: 1,
     amend: 1,
-    bound: 1,
     deliver: 1,
     reintegrated: 1,
     attestation: 1,
@@ -158,11 +157,6 @@ function validateData(kind, value) {
         }
         case "amend":
             return termsValue(value, path);
-        case "bound": {
-            const object = requireRecord(value, path);
-            requireKeys(object, [], path);
-            return {};
-        }
         case "deliver": {
             const object = requireRecord(value, path);
             requireKeys(object, ["tenderSnapshot", "integration", "method", "policy"], path);

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

@@ -22,7 +22,6 @@ function stateFromBind(id, head, bind, attestations) {
         head,
         coordinates: cloneCoordinates(bind.data.coordinates),
         terms: cloneTerms(bind.data.terms),
-        bound: null,
         delivery: null,
         currentIntegration: null,
         attestations,
@@ -49,13 +48,7 @@ function foldEntry(state, entry, attestations) {
             foldError("bind may appear only once");
         case "amend":
             return { ...state, terms: cloneTerms(entry.data) };
-        case "bound":
-            if (state.bound !== null)
-                foldError("bound may appear only once");
-            return { ...state, bound: entry };
         case "deliver":
-            if (state.bound === null)
-                foldError("deliver requires bound");
             return { ...state, delivery: entry, currentIntegration: { ...entry.data.integration } };
         case "reintegrated":
             if (state.delivery === null)

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

@@ -72,7 +72,6 @@ export type BindData = Readonly<{
     terms: ContractTerms;
 }>;
 export type AmendData = ContractTerms;
-export type BoundData = Readonly<Record<string, never>>;
 export type DeliverData = Readonly<{
     tenderSnapshot: SnapshotId;
     integration: Readonly<{
@@ -118,14 +117,13 @@ type JournalEnvelope<Kind extends string, Data> = Readonly<{
 }>;
 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 | ReintegratedEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
+export type JournalEntry = BindEntry | AmendEntry | DeliverEntry | ReintegratedEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
 export type FactKind = JournalEntry["kind"];
 type ContractTerminal = ClaimedEntry | AbandonedEntry;
 export type ContractState = Readonly<{
@@ -133,7 +131,6 @@ export type ContractState = Readonly<{
     head: ContractHead | null;
     coordinates: ContractCoordinates;
     terms: ContractTerms;
-    bound: BoundEntry | null;
     delivery: DeliverEntry | null;
     currentIntegration: CurrentIntegration | null;
     attestations: readonly AttestationEntry[];

package/build/src/core/verbs/deliver.js

@@ -11,26 +11,14 @@ export function decideDeliver({ input, attempt, observation, }) {
     }
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
-    const entries = [];
-    if (state.bound === null)
-        entries.push({
-            v: 1,
-            kind: "bound",
-            contract: input.contractId,
-            entry: attempt.entryUlids[0],
-            at: input.at,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            data: {},
-        });
     const deliver = {
         v: 1,
         kind: "deliver",
         contract: input.contractId,
-        entry: attempt.entryUlids[state.bound === null ? 1 : 0],
+        entry: attempt.entryUlids[0],
         at: input.at,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data: input.preparation.data,
     };
-    entries.push(deliver);
-    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, entries }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, entries: [deliver] }] } };
 }

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

@@ -26,16 +26,16 @@ type BindAttemptInput = Readonly<{
 export declare function admitBindWithAppointment(input: BindAttemptInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
 }>, {
+    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+    contractId: ContractId;
+} | {
     kind: "verification-declaration-invalid";
     contractId?: ContractId | undefined;
-} | {
-    kind: "target-missing" | "unborn-head" | "invalid-target";
 } | {
     kind: "fork-source-moved";
     contractId: ContractId;
 } | {
-    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-    contractId: ContractId;
+    kind: "unborn-head" | "target-missing" | "invalid-target";
 } | {
     kind: "fork-source-missing" | "fork-source-unavailable";
     contractId: ContractId;
@@ -76,16 +76,16 @@ export declare function admitMarkdownBind(input: Readonly<{
 }>): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
 }>, {
+    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+    contractId: ContractId;
+} | {
     kind: "verification-declaration-invalid";
     contractId?: ContractId | undefined;
-} | {
-    kind: "target-missing" | "unborn-head" | "invalid-target";
 } | {
     kind: "fork-source-moved";
     contractId: ContractId;
 } | {
-    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-    contractId: ContractId;
+    kind: "unborn-head" | "target-missing" | "invalid-target";
 } | {
     kind: "fork-source-missing" | "fork-source-unavailable";
     contractId: ContractId;
@@ -107,16 +107,16 @@ export declare function prepareMarkdownBind(input: Readonly<{
         result: IntentOutcome<Readonly<{
             contractId: ContractId;
         }>, {
+            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+            contractId: ContractId;
+        } | {
             kind: "verification-declaration-invalid";
             contractId?: ContractId | undefined;
-        } | {
-            kind: "target-missing" | "unborn-head" | "invalid-target";
         } | {
             kind: "fork-source-moved";
             contractId: ContractId;
         } | {
-            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-            contractId: ContractId;
+            kind: "unborn-head" | "target-missing" | "invalid-target";
         } | {
             kind: "fork-source-missing" | "fork-source-unavailable";
             contractId: ContractId;
@@ -126,16 +126,16 @@ export declare function prepareMarkdownBind(input: Readonly<{
         result: IntentOutcome<Readonly<{
             contractId: ContractId;
         }>, {
+            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+            contractId: ContractId;
+        } | {
             kind: "verification-declaration-invalid";
             contractId?: ContractId | undefined;
-        } | {
-            kind: "target-missing" | "unborn-head" | "invalid-target";
         } | {
             kind: "fork-source-moved";
             contractId: ContractId;
         } | {
-            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-            contractId: ContractId;
+            kind: "unborn-head" | "target-missing" | "invalid-target";
         } | {
             kind: "fork-source-missing" | "fork-source-unavailable";
             contractId: ContractId;
@@ -146,16 +146,16 @@ export declare function prepareMarkdownBind(input: Readonly<{
     result: IntentOutcome<Readonly<{
         contractId: ContractId;
     }>, {
+        kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+        contractId: ContractId;
+    } | {
         kind: "verification-declaration-invalid";
         contractId?: ContractId | undefined;
-    } | {
-        kind: "target-missing" | "unborn-head" | "invalid-target";
     } | {
         kind: "fork-source-moved";
         contractId: ContractId;
     } | {
-        kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-        contractId: ContractId;
+        kind: "unborn-head" | "target-missing" | "invalid-target";
     } | {
         kind: "fork-source-missing" | "fork-source-unavailable";
         contractId: ContractId;

package/build/src/library/bind.js

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { decodeContractDocument } from "../body/decode.js";
+import { decodeCanonicalContractDocument } from "../body/render.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { mintIdentitySegment } from "../identity/mint.js";
@@ -92,7 +93,7 @@ export async function admitForkBindWithAppointment(input) {
         });
     }
     const markdown = sourceDocument.document.bytes.replace(/^\s*#\s*[^\r\n]*(?:\r?\n|$)/u, `# Fork · ${sourceDocument.title}${sourceDocument.document.bytes.includes("\r\n") ? "\r\n" : "\n"}`);
-    const document = decodeContractDocument(markdown, { requireTimeout: true });
+    const document = decodeCanonicalContractDocument(markdown, { requireTimeout: true });
     const terms = contractTerms(document, source.terms.gates, source.terms.after);
     const admission = await attemptCandidates({
         scope: input.scope,

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

@@ -1,5 +1,6 @@
 /** @architectureCompositionRoot */
 import { type LibraryExecution } from "../akuma/requests.js";
+import type { BindTargetSelection } from "../protocol/bind.js";
 import type { ContractObservation } from "../protocol/read/status.js";
 import type { BindOutcome } from "./contract-outcomes.js";
 import type { BindInput, ContractList, ContractListInput, ContractObservationInput, KeiyakuSelectInput, LocalContractComposition } from "./contract-types.js";
@@ -31,9 +32,11 @@ export type KeiyakuLibrary = Readonly<{
  * The one private Contract composition constructor. `Keiyaku.with` fixes local execution; CLI and
  * Body pass their captured internal channel explicitly here instead of a second constructor. The
  * carrier is a positional argument, never a field of the public construction input, so no runtime
- * value reaching the public surface can select a private channel.
+ * value reaching the public surface can select a private channel. `omittedMarkdownTarget` is the
+ * internal bind intent an edge supplies for a Markdown bind whose caller omitted the target; the
+ * public package-root composition leaves it targetless.
  */
-export declare function composeContractLibrary(execution: LibraryExecution, createHandle: typeof createKeiyakuHandle, input?: LocalContractComposition): KeiyakuLibrary;
+export declare function composeContractLibrary(execution: LibraryExecution, createHandle: typeof createKeiyakuHandle, input?: LocalContractComposition, omittedMarkdownTarget?: BindTargetSelection): KeiyakuLibrary;
 export declare function listKeiyaku(input: ContractListInput): Promise<ContractList>;
 export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
 export declare function readContractValue<Value>(operation: () => Promise<Value>): Promise<Value>;

package/build/src/library/contract-composition.js

@@ -13,12 +13,14 @@ import { scopeForRepo } from "./repo.js";
  * The one private Contract composition constructor. `Keiyaku.with` fixes local execution; CLI and
  * Body pass their captured internal channel explicitly here instead of a second constructor. The
  * carrier is a positional argument, never a field of the public construction input, so no runtime
- * value reaching the public surface can select a private channel.
+ * value reaching the public surface can select a private channel. `omittedMarkdownTarget` is the
+ * internal bind intent an edge supplies for a Markdown bind whose caller omitted the target; the
+ * public package-root composition leaves it targetless.
  */
-export function composeContractLibrary(execution, createHandle, input) {
+export function composeContractLibrary(execution, createHandle, input, omittedMarkdownTarget = { kind: "targetless" }) {
     const composition = captureLocalContractComposition(input);
     return Object.freeze({
-        bind: (operation) => bindKeiyaku(operation, createHandle, execution, composition),
+        bind: (operation) => bindKeiyaku(operation, createHandle, execution, composition, omittedMarkdownTarget),
         select: (operation) => selectKeiyaku(operation, createHandle, execution, composition),
         list: (operation) => listKeiyaku(operation),
         observe: (operation) => observeKeiyaku(operation),

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

@@ -1,7 +1,13 @@
 /** @architectureCompositionRoot */
 import { type ExecutionContext } from "../akuma/requests.js";
+import type { BindTargetSelection } from "../protocol/bind.js";
 import type { BindOutcome } from "./contract-outcomes.js";
 import { type LocalContractCompositionCapture } from "./contract-settings.js";
 import type { BindInput } from "./contract-types.js";
 import type { createKeiyakuHandle } from "./keiyaku.js";
-export declare function bindKeiyaku(input: BindInput, createHandle: typeof createKeiyakuHandle, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Promise<BindOutcome>;
+/**
+ * One Contract bind. `omittedMarkdownTarget` is the internal composition input an edge
+ * supplies for a Markdown bind whose caller omitted the target: the public package-root
+ * composition leaves it targetless, while the CLI names the invocation branch.
+ */
+export declare function bindKeiyaku(input: BindInput, createHandle: typeof createKeiyakuHandle, execution?: ExecutionContext, composition?: LocalContractCompositionCapture, omittedMarkdownTarget?: BindTargetSelection): Promise<BindOutcome>;

package/build/src/library/contract-creation.js

@@ -1,6 +1,6 @@
 /** @architectureCompositionRoot */
 import { localExecutionContext } from "../akuma/requests.js";
-import { decodeContractDocument } from "../body/decode.js";
+import { decodeCanonicalContractDocument } from "../body/render.js";
 import { regionWarnings } from "../body/region.js";
 import { contractId } from "../core/facts/types.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
@@ -33,6 +33,7 @@ function bindInput(input, composition) {
             if (typeof forkOf !== "string")
                 throw new TypeError("forkOf must be a ContractId");
         }
+        const derived = forkOf === undefined ? derivedGates(composition, gateNames(values.gates)) : undefined;
         return {
             forkOf: forkOf === undefined ? undefined : contractId(forkOf),
             scope: scopeForRepo(values.repo),
@@ -40,12 +41,17 @@ function bindInput(input, composition) {
             actor,
             target: values.target,
             task: forkOf === undefined ? taskOption(values.task) : undefined,
-            gates: forkOf === undefined ? derivedGates(composition, gateNames(values.gates)) : undefined,
+            gates: derived,
             after: forkOf === undefined ? normalizedList(values.after, "after", contractId) : undefined,
         };
     });
 }
-export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
+/**
+ * One Contract bind. `omittedMarkdownTarget` is the internal composition input an edge
+ * supplies for a Markdown bind whose caller omitted the target: the public package-root
+ * composition leaves it targetless, while the CLI names the invocation branch.
+ */
+export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition(), omittedMarkdownTarget = { kind: "targetless" }) {
     const prepared = bindInput(input, composition);
     const hooks = derivedHooks(composition);
     const { forkOf, scope, document, target, actor } = prepared;
@@ -78,7 +84,7 @@ export async function bindKeiyaku(input, createHandle, execution = localExecutio
                     }
                     if (document === undefined)
                         throw new Error("Markdown bind requires its prepared document");
-                    return await markdownBind(prepared, document, hooks, scope, channel, accumulator, handle);
+                    return await markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget);
                 })();
                 return completed;
             }, (error) => {
@@ -162,11 +168,11 @@ async function reconcileAll(accumulator, id, scope, channel, hooks) {
     }
 }
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
-async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle) {
+async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget) {
     const { task, target, actor, gates, after } = prepared;
     if (gates === undefined || after === undefined)
         throw new Error("Markdown bind requires prepared terms");
-    const targetSelection = target !== undefined ? { kind: "explicit", target } : { kind: "targetless" };
+    const targetSelection = target !== undefined ? { kind: "explicit", target } : omittedMarkdownTarget;
     const admission = await prepareMarkdownBind({
         scope,
         channel,
@@ -183,10 +189,14 @@ async function markdownBind(prepared, document, hooks, scope, channel, accumulat
     if (leading.kind !== "accepted")
         return expected(undefined, leading);
     const id = leading.value.contractId;
-    accumulator.extendConclusions(id, { keiyaku: handle(id), warnings: regionWarnings(document.region) });
-    const value = await bindComplete(accumulator, id, scope, channel, leading, hooks, async () => bindValue(handle(id), await observeRegion(scope, channel, id, document.region), regionWarnings(document.region)));
+    const warnings = regionWarnings(document.region);
+    accumulator.extendConclusions(id, {
+        keiyaku: handle(id),
+        warnings,
+    });
+    const value = await bindComplete(accumulator, id, scope, channel, leading, hooks, async () => bindValue(handle(id), await observeRegion(scope, channel, id, document.region), warnings));
     return acceptedOutcome("bind", id, accumulator, value);
 }
 function parseMarkdown(markdown) {
-    return decodeContractDocument(markdown, { requireTimeout: true });
+    return decodeCanonicalContractDocument(markdown, { requireTimeout: true });
 }

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

@@ -16,6 +16,7 @@ export declare class ContractExecution {
     private get scope();
     private get execution();
     private get composition();
+    private amendInput;
     amend(input: AmendInput): Promise<AmendOutcome>;
     /** One promise with an optional observation callback; observation never delays custody. */
     deliver(input?: DeliverInput, options?: MutationObservation): Promise<DeliverOutcome>;

package/build/src/library/contract-execution.js

@@ -44,16 +44,20 @@ export class ContractExecution {
     get composition() {
         return this.seat.composition;
     }
-    async amend(input) {
-        const { markdown, gates, prerequisites, actor } = validated(() => {
+    amendInput(input) {
+        return validated(() => {
             const values = requireInput(input, "amend input", ["actor", "markdown", "gates", "after"]);
+            const derived = values.gates === undefined ? undefined : derivedGates(this.composition, gateNames(values.gates));
             return {
                 markdown: values.markdown === undefined ? undefined : requireMarkdown(values.markdown),
-                gates: values.gates === undefined ? undefined : derivedGates(this.composition, gateNames(values.gates)),
+                gates: derived,
                 prerequisites: values.after === undefined ? undefined : normalizedList(values.after, "after", contractId),
                 actor: actorOption(values.actor).actor,
             };
         });
+    }
+    async amend(input) {
+        const { markdown, gates, prerequisites, actor } = this.amendInput(input);
         const hooks = derivedHooks(this.composition);
         const amendmentPlan = markdown === undefined ? undefined : validated(() => prepareAmendDocument(markdown));
         validated(() => {
@@ -97,7 +101,11 @@ export class ContractExecution {
                 leading: accepted,
                 hooks,
                 verificationResidueRecorded: false,
-                value: () => ({ documentDiff: diff, changes, ...region }),
+                value: () => ({
+                    documentDiff: diff,
+                    changes,
+                    ...region,
+                }),
             });
             return acceptedOutcome("amend", this.id, accumulator, value);
         });

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

@@ -11,7 +11,7 @@ export type LocalContractCompositionCapture = Readonly<{
 /**
  * Hooks, freshness, and gate bundles are read from the captured Settings only at the operation
  * that consumes them. Bare core (omitted Settings) keeps empty hooks, false freshness, and
- * literal gate words; a broken selected namespace fails before any admission.
+ * built-in gate words; a broken selected namespace fails before any admission.
  */
 export declare function derivedHooks(composition: LocalContractCompositionCapture): WorktreeHooks;
 /** The two Settings-derived Contract policies one mutating operation may consume. */
@@ -20,6 +20,6 @@ export declare function derivedContractPolicy(composition: LocalContractComposit
     requireBranchesToBeUpToDate: boolean;
 }>;
 export declare function gateNames(value: unknown): readonly string[] | undefined;
-/** Bare words and configured bundles share validation, first-seen accumulation, and freezing. */
+/** Built-in words and configured bundles share validation, first-seen accumulation, and freezing. */
 export declare function derivedGates(composition: LocalContractCompositionCapture, names: readonly string[] | undefined): readonly Gate[];
 export declare function captureLocalContractComposition(input?: LocalContractComposition): LocalContractCompositionCapture;