@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/cli/runtime.js

@@ -5,6 +5,30 @@ import { safeText } from "./render/terminal.js";
 function writeCliStream(stream, body) {
     stream.write(body.endsWith("\n") ? body : `${body}\n`);
 }
+export async function writeExecutionProgress(events, stream = process.stderr) {
+    const { renderExecutionProgress } = await import("./render/execution-progress.js");
+    const terminal = stream;
+    await renderExecutionProgress(events, {
+        stream: terminal,
+        context: {
+            columns: terminal.isTTY === true && Number.isInteger(terminal.columns) ? (terminal.columns ?? 80) : 80,
+            color: false,
+        },
+    });
+}
+function cliCancellation() {
+    const controller = new AbortController();
+    const cancel = () => controller.abort(new Error("CLI cancellation requested"));
+    process.once("SIGINT", cancel);
+    process.once("SIGTERM", cancel);
+    return {
+        signal: controller.signal,
+        close() {
+            process.removeListener("SIGINT", cancel);
+            process.removeListener("SIGTERM", cancel);
+        },
+    };
+}
 export async function writeTask(command, result) {
     const { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } = await import("./render/task.js");
     const context = {
@@ -114,7 +138,7 @@ function writeWorldScopeRefusal(error, command) {
     const body = command.output === "json"
         ? JSON.stringify(error.refusal)
         : [
-            `✕ selector  ${error.refusal.kind}`,
+            `× selector  ${error.refusal.kind}`,
             `  world  ${safeText(error.refusal.world)}`,
             ...error.refusal.ids.map((id) => `  given  ${safeText(id)}`),
             `  accepts  ${guide.accepts}`,
@@ -136,15 +160,20 @@ async function commandFailureText(error, command) {
             }, "selector");
         }
         const { renderRefusalFacts } = await import("./render/refusal.js");
-        return [`✕ ${command.command} refused`, ...renderRefusalFacts(error.refusal, "  ", displayContext().columns)].join("\n");
+        return [`× ${command.command} refused`, ...renderRefusalFacts(error.refusal, "  ", displayContext().columns)].join("\n");
     }
-    return `✕ ${command.command} failed\n  diagnostic  ${safeText(diagnostic)}`;
+    return `× ${command.command} failed\n  diagnostic  ${safeText(diagnostic)}`;
 }
 export async function runCliCommand(invocation) {
     const command = invocation.command;
+    const cancellation = cliCancellation();
     try {
         const { invoke } = await import("./invoke.js");
-        const result = await invoke(invocation, { cwd: process.cwd() });
+        const result = await invoke(invocation, {
+            cwd: process.cwd(),
+            signal: cancellation.signal,
+            progress: writeExecutionProgress,
+        });
         return await writeResult(command, result);
     }
     catch (error) {
@@ -177,4 +206,7 @@ export async function runCliCommand(invocation) {
         writeCliStream(process.stderr, await commandFailureText(error, command));
         return error instanceof CliUsageError ? 1 : 3;
     }
+    finally {
+        cancellation.close();
+    }
 }

package/build/src/cli/usage.js

@@ -34,9 +34,9 @@ export function unknownCommandGuide(guide, given) {
 }
 export function renderUsageMessage(diagnostic, guide, kind = "usage") {
     if (guide === undefined) {
-        return `✕ ${kind}\n  diagnostic  ${diagnostic}`;
+        return `× ${kind}\n  diagnostic  ${diagnostic}`;
     }
-    const lines = [`✕ ${kind}  ${guide.scope}`];
+    const lines = [`× ${kind}  ${guide.scope}`];
     if (!guide.hideDiagnostic && diagnostic.length > 0) {
         lines.push(`  diagnostic  ${diagnostic}`);
     }

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

@@ -0,0 +1 @@
+export declare function installedPackageVersion(): Promise<string>;

package/build/src/cli/version.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+const PACKAGE_NAME = "@astrosheep/keiyaku";
+export async function installedPackageVersion() {
+    const manifest = JSON.parse(await readFile(owningManifestUrl(), "utf8"));
+    if (!isOwningManifest(manifest)) {
+        throw new Error(`Keiyaku package manifest must name ${PACKAGE_NAME} and contain a nonempty version`);
+    }
+    return manifest.version;
+}
+function owningManifestUrl() {
+    const relativePath = import.meta.url.endsWith("/src/cli/version.ts")
+        ? "../../package.json"
+        : import.meta.url.endsWith("/build/src/cli/version.js")
+            ? "../../../package.json"
+            : undefined;
+    if (relativePath === undefined)
+        throw new Error("Keiyaku package metadata has an unsupported module layout");
+    return new URL(relativePath, import.meta.url);
+}
+function isOwningManifest(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const manifest = value;
+    return manifest.name === PACKAGE_NAME && typeof manifest.version === "string" && manifest.version.trim().length > 0;
+}

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

@@ -16,11 +16,17 @@ export type HookFailure = Readonly<{
     truncated: boolean;
 }> | Readonly<{
     kind: "timeout";
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
 }> | Readonly<{
     kind: "spawn-error";
     diagnostic: string;
 }> | Readonly<{
     kind: "unknown-exit";
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
 }>;
 export type WorktreeHookLag = Readonly<{
     kind: "worktree-hook-failed";
@@ -42,13 +48,19 @@ export type HookCommandRun = Readonly<{
     kind: "ok";
 }> | Readonly<{
     kind: "cancelled";
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
 }> | Readonly<{
     kind: "failed";
     name: string;
     failure: HookFailure;
 }>;
 /** Execute an ordered command list without lifecycle state. Scratch owns this policy. */
-export declare function runHookCommands(worktree: string, commands: readonly HookCommand[], signal?: AbortSignal, environment?: NodeJS.ProcessEnv): Promise<HookCommandRun>;
+export declare function runHookCommands(worktree: string, commands: readonly HookCommand[], signal?: AbortSignal, environment?: NodeJS.ProcessEnv, onOutput?: (output: Readonly<{
+    stream: "stdout" | "stderr";
+    text: string;
+}>) => void): Promise<HookCommandRun>;
 export type HookPhaseRun = Readonly<{
     lag: WorktreeHookLag | null;
     runs: readonly string[];

package/build/src/git/hooks.js

@@ -98,7 +98,7 @@ function failedOutcome(outcome) {
     return outcome;
 }
 /** Execute an ordered command list without lifecycle state. Scratch owns this policy. */
-export async function runHookCommands(worktree, commands, signal, environment) {
+export async function runHookCommands(worktree, commands, signal, environment, onOutput) {
     for (const value of commands) {
         const outcome = await runProcess({
             argv: value.argv,
@@ -106,6 +106,7 @@ export async function runHookCommands(worktree, commands, signal, environment) {
             cwd: worktree,
             ...(signal === undefined ? {} : { signal }),
             ...(environment === undefined ? {} : { env: environment }),
+            ...(onOutput === undefined ? {} : { onOutput }),
         });
         if (outcome.kind === "cancelled")
             return outcome;

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

@@ -49,7 +49,7 @@ export type WorkspaceChangeCounts = Readonly<{
 }>;
 export type ConflictRecovery = Readonly<{
     materialize: "deliver --materialize-conflict --include-dirty";
-    continue: "deliver --include-dirty";
+    deliver: "deliver --include-dirty";
     staging: "not-required";
 }>;
 export declare const conflictRecovery: ConflictRecovery;

package/build/src/git/workspace.js

@@ -195,7 +195,7 @@ export async function unmergedWorkspacePaths(repository, workspace) {
 }
 export const conflictRecovery = Object.freeze({
     materialize: "deliver --materialize-conflict --include-dirty",
-    continue: "deliver --include-dirty",
+    deliver: "deliver --include-dirty",
     staging: "not-required",
 });
 function countsOf(changes) {

package/build/src/identity/mint.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mint one identity segment from a fitted stem by drawing a fresh random suffix
+ * and letting the caller admit the candidate. A collision redraws the suffix
+ * within the attempt budget; exhaustion returns the last collision rather than
+ * lengthening the identity.
+ */
+export declare function mintIdentitySegment<Value>(input: Readonly<{
+    stem: string;
+    attempts: number;
+    drawSuffix: () => string;
+    attempt: (segment: string) => Promise<Value>;
+    collision: (value: Value) => boolean;
+}>): Promise<Value>;

package/build/src/identity/mint.js

@@ -0,0 +1,26 @@
+const IDENTITY_SUFFIX_PATTERN = /^[0-9a-f]{4}$/u;
+function requireIdentitySuffix(value) {
+    if (!IDENTITY_SUFFIX_PATTERN.test(value)) {
+        throw new Error("identity suffix must be four lowercase hexadecimal digits");
+    }
+    return value;
+}
+/**
+ * Mint one identity segment from a fitted stem by drawing a fresh random suffix
+ * and letting the caller admit the candidate. A collision redraws the suffix
+ * within the attempt budget; exhaustion returns the last collision rather than
+ * lengthening the identity.
+ */
+export async function mintIdentitySegment(input) {
+    if (!Number.isSafeInteger(input.attempts) || input.attempts < 1) {
+        throw new Error("identity mint attempt budget must be a positive safe integer");
+    }
+    let result;
+    for (let index = 0; index < input.attempts; index += 1) {
+        const suffix = requireIdentitySuffix(input.drawSuffix());
+        result = await input.attempt(`${input.stem}-${suffix}`);
+        if (!input.collision(result))
+            return result;
+    }
+    return result;
+}

package/build/src/identity/normalize.d.ts

@@ -1,6 +1,10 @@
 export declare function normalizeIdentityStem(input: Readonly<{
     source: string;
 }>): string;
+export declare function fitIdentityStemWords(input: Readonly<{
+    stem: string;
+    maxCodePoints: number;
+}>): string;
 export declare function fitIdentityStem(input: Readonly<{
     stem: string;
     maxBytes: number;

package/build/src/identity/normalize.js

@@ -21,6 +21,36 @@ export function normalizeIdentityStem(input) {
     }
     return result;
 }
+export function fitIdentityStemWords(input) {
+    if (!Number.isSafeInteger(input.maxCodePoints) || input.maxCodePoints < 1) {
+        throw new Error("identity stem code point budget must be a positive safe integer");
+    }
+    const words = input.stem.split("-");
+    let fitted = truncateGraphemes(words[0], input.maxCodePoints);
+    let count = [...fitted].length;
+    for (const word of words.slice(1)) {
+        const candidate = count + 1 + [...word].length;
+        if (candidate > input.maxCodePoints)
+            break;
+        fitted += `-${word}`;
+        count = candidate;
+    }
+    if (fitted.length === 0)
+        throw new Error("identity stem is empty after fitting");
+    return fitted;
+}
+function truncateGraphemes(value, maxCodePoints) {
+    let result = "";
+    let count = 0;
+    for (const { segment } of GRAPHEMES.segment(value)) {
+        const size = [...segment].length;
+        if (count + size > maxCodePoints)
+            break;
+        result += segment;
+        count += size;
+    }
+    return result;
+}
 export function fitIdentityStem(input) {
     if (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1) {
         throw new Error("identity stem byte budget must be a positive safe integer");

package/build/src/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./library/keiyaku.js";
+export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
+export type { AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaSignalOptions, AkumaTellOptions, InterruptReceipt, KillEvidence, JsonSchema, JsonSchemaDocument, AkuId, AkumaStatus, ActivityHistory, ActivityRow, AllowedAction, AllowedActions, } from "./akuma/index.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";

package/build/src/index.js

@@ -1,3 +1,4 @@
 export * from "./library/keiyaku.js";
+export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";

package/build/src/kanshi/read.js

@@ -15,7 +15,7 @@ import { readDocuments } from "../protocol/read/documents.js";
 import { contractId } from "../core/facts/types.js";
 import { selectKanshi, selectRegion } from "./select.js";
 import { FLEET_SNAPSHOT_ROWS, FLEET_VISIBLE_ROWS } from "./fleet.js";
-import { observeRecentTaskStatus } from "../task/index.js";
+import { observeRecentTaskStatus, TaskAuthorityCorruptionError } from "../task/index.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -224,6 +224,15 @@ function joinTasks(rows, holders, observeContract) {
         return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
     });
 }
+/** Attribute a Task board failure to the malformed document that caused it, when one is known. */
+function taskFailure(error) {
+    return {
+        message: diagnostic(error),
+        ...(error instanceof TaskAuthorityCorruptionError && error.coordinate !== undefined
+            ? { coordinate: error.coordinate }
+            : {}),
+    };
+}
 async function readTaskWorld(path) {
     if (path === null)
         return { kind: "absent" };
@@ -231,14 +240,18 @@ async function readTaskWorld(path) {
         return { kind: "present", observation: await observeTaskBoard(path) };
     }
     catch (error) {
-        return { kind: "failed", failure: { message: diagnostic(error) } };
+        return { kind: "failed", failure: taskFailure(error) };
     }
 }
+/**
+ * A selected Contract's own Task namespace view. A failed Task board is reported once by the
+ * board's Task section, so the entity block omits it rather than repeating the same row.
+ */
 function namespaceTaskSection(board, id) {
     if (board.kind === "absent")
         return { kind: "absent" };
     if (board.kind === "failed")
-        return { kind: "failed", failure: board.failure };
+        return undefined;
     return { kind: "present", value: board.observation.selectNamespace(contractNamespace(id)) };
 }
 async function readTasks(path, holders, observeContract) {
@@ -247,7 +260,7 @@ async function readTasks(path, holders, observeContract) {
     return observeRecentTaskStatus(path, { limit: 10 }).then((recent) => ({
         kind: "present",
         value: { root: path, hasMore: recent.hasMore, rows: joinTasks(recent.rows, holders, observeContract) },
-    }), (error) => ({ kind: "failed", failure: { message: diagnostic(error) } }));
+    }), (error) => ({ kind: "failed", failure: taskFailure(error) }));
 }
 async function joinAkuma(path, observeContract, dispatches, aliases) {
     if (aliases.kind !== "present")

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

@@ -17,6 +17,7 @@ export type Section<Value> = Readonly<{
     kind: "failed";
     failure: Readonly<{
         message: string;
+        coordinate?: string;
     }>;
 }>;
 export type ContractEndpointObservation = ContractDisposition | "missing" | "unavailable";

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

@@ -54,6 +54,7 @@ export type CallInput = Readonly<{
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
     schema?: Schema<unknown>;
+    initiator?: string;
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";
@@ -89,6 +90,7 @@ export type BornCall = Readonly<{
     schemaTell?: Readonly<{
         body: string;
         schema: Schema<unknown>;
+        initiator?: string;
     }>;
 }>;
 export type ForkInput = Readonly<{

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

@@ -148,7 +148,7 @@ async function emitCalledSignal(input) {
 async function admitCall(input) {
     const born = await input.world.admit(input.call, input.context);
     const akuma = born.kind === "requested" ? born.id : born.allocated.id;
-    void emitCalledSignal({
+    await emitCalledSignal({
         path: input.path,
         ...(input.settings === undefined ? {} : { settings: input.settings }),
         born,
@@ -242,26 +242,29 @@ async function resolveAliasStage(path, alias, dispatch, akuma) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
+const CALL_INPUT_KEYS = [
+    "path",
+    "archetype",
+    "body",
+    "cwd",
+    "readonly",
+    "mode",
+    "timeoutMs",
+    "home",
+    "settings",
+    "contract",
+    "alias",
+    "allowed",
+    "schema",
+    "initiator",
+];
 async function prepareCall(input, context) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, [
-        "path",
-        "archetype",
-        "body",
-        "cwd",
-        "readonly",
-        "mode",
-        "timeoutMs",
-        "home",
-        "settings",
-        "contract",
-        "alias",
-        "allowed",
-        "schema",
-    ], "Keiyaku.call input");
+    onlyKeys(values, CALL_INPUT_KEYS, "Keiyaku.call input");
     const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
+    const initiator = values.initiator === undefined ? undefined : text(values.initiator, "initiator");
     const readonlyRequested = callReadonly(values.readonly, "readonly must be true").readonly;
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
@@ -279,6 +282,7 @@ async function prepareCall(input, context) {
     const call = {
         archetype,
         ...(values.schema === undefined ? { body } : {}),
+        ...(initiator === undefined ? {} : { initiator }),
         ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(values.schema === undefined ? {} : { schema: values.schema }),
@@ -305,7 +309,15 @@ async function prepareCall(input, context) {
         timeoutMs,
         dispatch,
         alias: aliasStage,
-        ...(values.schema === undefined ? {} : { schemaTell: { body, schema: values.schema } }),
+        ...(values.schema === undefined
+            ? {}
+            : {
+                schemaTell: {
+                    body,
+                    schema: values.schema,
+                    ...(initiator === undefined ? {} : { initiator }),
+                },
+            }),
     };
 }
 async function publishCall(born, execution) {
@@ -326,8 +338,12 @@ async function publishCall(born, execution) {
                 target: handle.id,
                 body: tell.body,
                 schema: tell.schema,
+                ...(tell.initiator === undefined ? {} : { initiator: tell.initiator }),
             })
-            : PublicAkuma.select(born.path, handle.id).tell(tell.body, { schema: tell.schema }));
+            : PublicAkuma.select(born.path, handle.id).tell(tell.body, {
+                schema: tell.schema,
+                ...(tell.initiator === undefined ? {} : { initiator: tell.initiator }),
+            }));
         if (born.mode === "detach")
             void pending.catch(() => undefined);
         else

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

@@ -1,3 +1,4 @@
+import type { ExecutionObserver } from "../protocol/execution-observation.js";
 import type { ActorId, ContractId } from "../core/facts/types.js";
 import { type AuditReport } from "../protocol/audit.js";
 import { type RepositoryScope } from "../protocol/operations.js";
@@ -24,4 +25,5 @@ export declare function auditContract(input: Readonly<{
     contractId: ContractId;
     input: AuditOptions;
     composition?: AuditComposition;
+    observe?: ExecutionObserver;
 }>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -11,6 +11,7 @@ export async function auditContract(input) {
     return withContractExecution({
         scope: input.scope,
         contractId: input.contractId,
+        ...(input.observe === undefined ? {} : { observe: input.observe }),
         hooks: composition?.hooks ?? worktreeHooksOption(undefined),
         ...(input.input.signal === undefined ? {} : { signal: input.input.signal }),
     }, "audit", async ({ scope, channel, progress }) => {

package/build/src/library/bind.js

@@ -2,16 +2,17 @@ import { randomBytes } from "node:crypto";
 import { decodeContractDocument } from "../body/decode.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
+import { mintIdentitySegment } from "../identity/mint.js";
+import { fitIdentityStemWords, normalizeIdentityStem } from "../identity/normalize.js";
 import { bindOperation } from "../protocol/bind.js";
 import { stateOperation } from "../protocol/operations.js";
 import { claimTaskHolder, claimTaskHolderWithFence } from "../settlement/holder.js";
 import { KeiyakuRefused } from "./refusal.js";
 import { contractTerms, documentDerivation } from "./input.js";
-function candidateId(title, collision) {
-    const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
-    const suffix = collision === 0 ? "" : `-${randomBytes(8).toString("hex")}`;
-    return contractIdFromSegment(`${stem}${suffix}`);
+const CONTRACT_ID_CODE_POINTS = 32;
+const CONTRACT_ID_ATTEMPTS = 4;
+function drawContractSuffix() {
+    return randomBytes(2).toString("hex");
 }
 async function attempt(input, id) {
     return bindOperation({
@@ -33,16 +34,17 @@ async function attempt(input, id) {
     });
 }
 async function attemptCandidates(input) {
-    let result;
-    for (let collision = 0; collision <= 3; collision += 1) {
-        const id = candidateId(input.title, collision);
-        result = await attempt(input, id);
-        if (result.kind === "accepted")
-            return result;
-        if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
-            return result;
-    }
-    return result;
+    const stem = fitIdentityStemWords({
+        stem: normalizeIdentityStem({ source: input.title }) || "contract",
+        maxCodePoints: CONTRACT_ID_CODE_POINTS,
+    });
+    return await mintIdentitySegment({
+        stem,
+        attempts: CONTRACT_ID_ATTEMPTS,
+        drawSuffix: drawContractSuffix,
+        attempt: (segment) => attempt(input, contractIdFromSegment(segment)),
+        collision: (result) => result.kind === "refused" && result.refusal.kind === "contract-exists",
+    });
 }
 export async function admitBindWithAppointment(input) {
     return await attemptCandidates(input);
@@ -86,7 +88,7 @@ export async function admitForkBindWithAppointment(input) {
         throw error;
     }
     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);
+    const document = decodeContractDocument(markdown, { requireTimeout: true });
     const terms = contractTerms(document, source.terms.gates, source.terms.after);
     const admission = await attemptCandidates({
         scope: input.scope,

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

@@ -90,6 +90,7 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
             status: {
                 id: import("./keiyaku.js").AkuId;
                 life: "killed" | "hung" | "untidy" | "running" | "asleep" | "stranded";
+                allowed: import("./keiyaku.js").AllowedActions;
                 timeline: {
                     reportedChanges: readonly {
                         sequence: number;

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

@@ -20,7 +20,9 @@ type BindInput = Readonly<{
 type BindResult<Handle> = Readonly<Omit<MutationResult<Handle>, "value"> & {
     keiyaku: Handle;
     workspace?: ContractWorkspaceLocation;
-} & RegionObservation>;
+} & RegionObservation & {
+    warnings?: readonly string[];
+}>;
 type HandleFactory<Handle> = (contractId: ContractId, scope: RepositoryScope) => Handle;
 export declare function bindKeiyaku<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
 export declare function parseMarkdownBindDocument(markdown: string): import("../body/types.js").DecodedContractDocument;

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

@@ -7,10 +7,11 @@ import { completionInput, completeHolderMutation, completeMutation } from "./mut
 import { reconcileLagScope } from "./reconcile.js";
 import { requireAccepted } from "./refusal.js";
 import { observeRegion } from "./region.js";
+import { regionWarnings } from "../body/region.js";
 import { scopeForRepo } from "./repo.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { placeRegisterPath, readManagedWorktreeAppointment, } from "../workspace-place.js";
-async function acceptedBindResult(result, region, scope, contractId) {
+async function acceptedBindResult(result, region, scope, contractId, warnings = []) {
     const { value: keiyaku, ...base } = result;
     const appointment = await readManagedWorktreeAppointment(scope, contractId);
     const registerPath = placeRegisterPath(scope);
@@ -34,6 +35,7 @@ async function acceptedBindResult(result, region, scope, contractId) {
         pending: scopedAppointmentLag.length === 0
             ? base.pending
             : [...base.pending, { surface: "reconciliation", required: true }],
+        ...(warnings.length === 0 ? {} : { warnings }),
         ...region,
     };
 }
@@ -85,7 +87,7 @@ export async function bindKeiyaku(input, createHandle) {
     return bindMarkdownFromValues(values, "targetless", createHandle);
 }
 export function parseMarkdownBindDocument(markdown) {
-    return decodeContractDocument(requireMarkdown(markdown));
+    return decodeContractDocument(requireMarkdown(markdown), { requireTimeout: true });
 }
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input, createHandle) {
@@ -133,6 +135,6 @@ async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
                 admission: admission.admission,
                 requireAccepted,
             });
-        return await acceptedBindResult(result, await observeRegion(scope, channel, id, document.region), scope, id);
+        return await acceptedBindResult(result, await observeRegion(scope, channel, id, document.region), scope, id, regionWarnings(document.region));
     });
 }

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

@@ -1,3 +1,4 @@
+import type { ExecutionObserver } from "../protocol/execution-observation.js";
 import type { ActorId, ContractId } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import { type IntegrationConflictMaterialized } from "../protocol/deliver.js";
@@ -13,6 +14,7 @@ type CommonExecutionInput = Readonly<{
     actor?: ActorId;
     signal?: AbortSignal;
     hooks: WorktreeHooks;
+    observe?: ExecutionObserver;
 }>;
 export type DeliveryExecutionInput = CommonExecutionInput & Readonly<{
     message?: string;