@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/kanshi/read.js

@@ -1,18 +1,19 @@
 import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
-import { resolveHereContractWorkspace } from "../contract-worktree.js";
 import { observeTaskBoard } from "../task/operations.js";
 import { contractNamespace } from "../settlement/settle.js";
 import { Akuma } from "../akuma/index.js";
 import { readAliases } from "../alias/index.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { readTaskHolderProjectionAt } from "../settlement/holder.js";
+import { observeCurrentPhysicalIssue } from "../protocol/read/observation.js";
 import { readContractBoard } from "../protocol/read/status.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { readDocuments } from "../protocol/read/documents.js";
-import { readRegionDeclarations, validateRegionPath } from "../library/region.js";
+import { readRegionDeclarations, validateRegionPatterns } from "../library/region.js";
 import { contractId } from "../core/facts/types.js";
 import { selectKanshi, selectRegion } from "./select.js";
+import { FLEET_SNAPSHOT_ROWS, visibleFleetRows } from "./fleet.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -59,28 +60,14 @@ function regionSelection(value) {
             throw new TypeError("kanshi region contract must be a canonical ContractId");
         }
     }
-    if (selection.kind === "overlap") {
-        exactKeys(selection, ["kind", "contract"], "region selection");
-        if (selection.contract === undefined)
-            return { kind: "overlap" };
-        if (typeof selection.contract !== "string")
-            throw new TypeError("kanshi region contract must be a ContractId");
-        try {
-            return { kind: "overlap", contract: contractId(selection.contract) };
-        }
-        catch {
-            throw new TypeError("kanshi region contract must be a canonical ContractId");
-        }
-    }
     if (selection.kind === "path") {
-        exactKeys(selection, ["kind", "path"], "region selection");
+        exactKeys(selection, ["kind", "patterns"], "region selection");
         try {
-            validateRegionPath(selection.path);
+            return { kind: "path", patterns: validateRegionPatterns(selection.patterns) };
         }
         catch (error) {
             throw new TypeError(error instanceof Error ? error.message : String(error));
         }
-        return { kind: "path", path: selection.path };
     }
     throw new TypeError(`kanshi region selection kind is invalid: ${selection.kind}`);
 }
@@ -105,7 +92,9 @@ function coordinate(input) {
 }
 async function readRegion(observation, selection) {
     try {
-        const declarations = [...readRegionDeclarations(await readDocuments(observation))].sort((left, right) => left.contract.localeCompare(right.contract));
+        const declarations = [
+            ...readRegionDeclarations(await readDocuments(observation)),
+        ].sort((left, right) => left.contract.localeCompare(right.contract));
         return { kind: "present", value: selectRegion({ declarations, selection }) };
     }
     catch (error) {
@@ -122,17 +111,33 @@ async function readBranch(repo) {
         return null;
     }
 }
-async function readContracts(observation, selected) {
+async function readContracts(observation, include) {
     try {
         return {
             kind: "present",
-            value: await readContractBoard(observation, selected, async (id) => await resolveHereContractWorkspace(observation.repository, id)),
+            value: await readContractBoard(observation, include),
         };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
+async function attachSelectedIssue(observation, contracts, selected) {
+    if (contracts.kind !== "present")
+        return contracts;
+    try {
+        const rows = await Promise.all(contracts.value.rows.map(async (row) => {
+            if (row.id !== selected)
+                return row;
+            const issue = await observeCurrentPhysicalIssue(observation.repository, row);
+            return issue === undefined ? row : { ...row, issue };
+        }));
+        return { kind: "present", value: { ...contracts.value, rows } };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
 async function readHolders(observation) {
     try {
         return { kind: "present", value: await readTaskHolderProjectionAt(observation) };
@@ -191,7 +196,7 @@ function contractEndpointObserver(contracts) {
     const dispositions = contracts.kind === "present"
         ? new Map(contracts.value.rows.map((row) => [row.id, row.disposition]))
         : null;
-    return (id) => dispositions === null ? "unavailable" : dispositions.get(id) ?? "missing";
+    return (id) => (dispositions === null ? "unavailable" : (dispositions.get(id) ?? "missing"));
 }
 function joinTasks(rows, holders, observeContract) {
     const associations = new Map(holders.kind === "present"
@@ -249,23 +254,18 @@ async function joinAkuma(path, observeContract, dispatches, aliases) {
             return {
                 ...row,
                 aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
-                ...(dispatch === undefined ? {} : {
-                    contract: {
-                        id: dispatch.contractId,
-                        observed: observeContract(dispatch.contractId),
-                    },
-                }),
+                ...(dispatch === undefined
+                    ? {}
+                    : {
+                        contract: {
+                            id: dispatch.contractId,
+                            observed: observeContract(dispatch.contractId),
+                        },
+                    }),
             };
         });
-        const running = rows
-            .filter((row) => row.life === "running")
-            .sort((left, right) => {
-            const l = "lastActivityAt" in left && left.lastActivityAt !== null ? Date.parse(left.lastActivityAt) : -Infinity;
-            const r = "lastActivityAt" in right && right.lastActivityAt !== null ? Date.parse(right.lastActivityAt) : -Infinity;
-            return r - l;
-        })
-            .slice(0, 3);
-        const snapshots = new Map(await Promise.all(running.map(async (row) => {
+        const snapshotRows = visibleFleetRows(rows).slice(0, FLEET_SNAPSHOT_ROWS);
+        const snapshots = new Map(await Promise.all(snapshotRows.map(async (row) => {
             try {
                 return [row.id, (await Akuma.of(path).of({ id: row.id }).status()).timeline];
             }
@@ -306,7 +306,7 @@ async function readDispatches(observation) {
 }
 export async function observeKanshi(input) {
     const observedAt = new Date().toISOString();
-    const { world, repo } = coordinate(input);
+    const { world, repo, region, contract } = coordinate(input);
     const branch = await readBranch(repo);
     if (repo === undefined) {
         const contracts = { kind: "absent" };
@@ -317,18 +317,26 @@ export async function observeKanshi(input) {
         const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
         const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
         return {
-            report: { root: world, observedAt, branch, contracts, tasks, akuma, ...(input.region === undefined ? {} : { region: { kind: "absent" } }) },
+            report: {
+                root: world,
+                observedAt,
+                branch,
+                contracts,
+                tasks,
+                akuma,
+                ...(region === undefined ? {} : { region: { kind: "absent" } }),
+            },
             aliases,
         };
     }
     try {
         const repository = scopeForRepo(repo);
         return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, async (observation) => {
-            const [contractSection, holders, dispatches, region, board] = await Promise.all([
-                readContracts(observation, input.contract),
+            const [contractSection, holders, dispatches, regionSection, board] = await Promise.all([
+                readContracts(observation, contract),
                 readHolders(observation),
                 readDispatches(observation),
-                input.region === undefined ? Promise.resolve(undefined) : readRegion(observation, input.region),
+                region === undefined ? Promise.resolve(undefined) : readRegion(observation, region),
                 readTaskWorld(world),
             ]);
             const contracts = decorateContracts(contractSection, holders, (id) => namespaceTaskSection(board, id));
@@ -340,19 +348,23 @@ export async function observeKanshi(input) {
                 : dispatches.kind === "failed"
                     ? dispatches
                     : await joinAkuma(world, observeContract, dispatches.value, aliases);
-            const report = {
+            const assembled = {
                 root: world,
                 observedAt,
                 branch,
                 contracts: attachFleet(contracts, akuma),
                 tasks,
                 akuma,
-                ...(region === undefined ? {} : { region }),
+                ...(regionSection === undefined ? {} : { region: regionSection }),
             };
+            if (contract === undefined)
+                return { report: assembled, aliases };
+            const selected = selectKanshi({ report: assembled, contract });
             return {
-                report: input.contract === undefined
-                    ? report
-                    : selectKanshi({ report, contract: input.contract }),
+                report: {
+                    ...selected,
+                    contracts: await attachSelectedIssue(observation, selected.contracts, contract),
+                },
                 aliases,
             };
         }));
@@ -367,7 +379,7 @@ export async function observeKanshi(input) {
                 contracts: failure,
                 tasks: world === null ? { kind: "absent" } : failure,
                 akuma: world === null ? { kind: "absent" } : failure,
-                ...(input.region === undefined ? {} : { region: failure }),
+                ...(region === undefined ? {} : { region: failure }),
             },
             aliases: world === null ? { kind: "absent" } : failure,
         };

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

@@ -1,9 +1,12 @@
-import type { ContractBoard, ContractDisposition } from "../library/contract.js";
+import type { ContractBoard, ContractDisposition, ContractPhase } from "../library/contract.js";
+import type { CurrentPhysicalIssue } from "../protocol/read/observation.js";
 import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
 import type { AkumaList, AkumaListRow, UnbornAkumaListRow, ActivitySnapshot } from "../akuma/index.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { ContractId } from "../library/contract.js";
+import type { RegionOverlap } from "../library/region.js";
+export type { RegionOverlap };
 export type Section<Value> = Readonly<{
     kind: "present";
     value: Value;
@@ -28,10 +31,13 @@ export type ContractFleetAttachment = Readonly<{
     id: string;
     aliases: readonly AkumaAlias[];
 }>;
+export type { CurrentPhysicalIssue };
 export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
+    phase: ContractPhase;
     holder: ContractHolderObservation;
     fleet: readonly ContractFleetAttachment[];
     namespaceTasks: Section<readonly TaskRow[]>;
+    issue?: CurrentPhysicalIssue;
 }>;
 export type ContractKanshiBoard = Omit<ContractBoard, "rows"> & Readonly<{
     rows: readonly ContractKanshiRow[];
@@ -63,43 +69,25 @@ export type KanshiRegionSelection = Readonly<{
 }> | Readonly<{
     kind: "contract";
     contract: ContractId;
-}> | Readonly<{
-    kind: "overlap";
-    contract?: ContractId;
 }> | Readonly<{
     kind: "path";
-    path: string;
+    patterns: readonly [string, ...string[]];
 }>;
 export type RegionDeclaration = Readonly<{
     contract: ContractId;
     patterns: readonly string[];
 }>;
-export type RegionIntersection = Readonly<{
-    left: ContractId;
-    right: ContractId;
-    patterns: readonly Readonly<{
-        left: string;
-        right: string;
-    }>[];
-}>;
-export type RegionPathMatch = Readonly<{
-    contract: ContractId;
-    pattern: string;
-}>;
 export type RegionRead = Readonly<{
     kind: "declarations";
     declarations: readonly RegionDeclaration[];
 }> | Readonly<{
     kind: "contract";
     declaration: RegionDeclaration;
-}> | Readonly<{
-    kind: "overlap";
-    subject?: ContractId;
-    intersections: readonly RegionIntersection[];
+    overlaps: readonly RegionOverlap[];
 }> | Readonly<{
     kind: "path";
-    path: string;
-    matches: readonly RegionPathMatch[];
+    patterns: readonly string[];
+    overlaps: readonly RegionOverlap[];
 }>;
 export type KanshiReport = Readonly<{
     root: WorldRoot | null;

package/build/src/kanshi/select.js

@@ -1,13 +1,25 @@
-import { regionIntersections, regionPathMatches } from "../library/region.js";
+import { regionOverlaps } from "../library/region.js";
 export function selectKanshi(input) {
     const { report, contract } = input;
     return {
         ...report,
         contracts: report.contracts.kind === "present"
-            ? { kind: "present", value: { ...report.contracts.value, rows: report.contracts.value.rows.filter((row) => row.id === contract) } }
+            ? {
+                kind: "present",
+                value: {
+                    ...report.contracts.value,
+                    rows: report.contracts.value.rows.filter((row) => row.id === contract),
+                },
+            }
             : report.contracts,
         tasks: report.tasks.kind === "present"
-            ? { kind: "present", value: { ...report.tasks.value, rows: report.tasks.value.rows.filter((row) => row.contract?.id === contract) } }
+            ? {
+                kind: "present",
+                value: {
+                    ...report.tasks.value,
+                    rows: report.tasks.value.rows.filter((row) => row.contract?.id === contract),
+                },
+            }
             : report.tasks,
         akuma: report.akuma.kind === "present"
             ? {
@@ -28,26 +40,15 @@ export function selectRegion(input) {
         const declaration = declarations.find((value) => value.contract === selection.contract);
         if (declaration === undefined)
             throw new Error(`active contract not found: ${selection.contract}`);
-        return { kind: "contract", declaration };
-    }
-    if (selection.kind === "path") {
-        const matches = declarations.flatMap((declaration) => regionPathMatches(declaration.patterns, selection.path).map((pattern) => ({ contract: declaration.contract, pattern })));
-        return { kind: "path", path: selection.path, matches };
-    }
-    const intersections = [];
-    for (let leftIndex = 0; leftIndex < declarations.length; leftIndex += 1) {
-        for (let rightIndex = leftIndex + 1; rightIndex < declarations.length; rightIndex += 1) {
-            const left = declarations[leftIndex];
-            const right = declarations[rightIndex];
-            if (selection.contract !== undefined && left.contract !== selection.contract && right.contract !== selection.contract)
-                continue;
-            const patterns = regionIntersections(left.patterns, right.patterns);
-            if (patterns.length > 0)
-                intersections.push({ left: left.contract, right: right.contract, patterns });
-        }
+        return {
+            kind: "contract",
+            declaration,
+            overlaps: regionOverlaps(declaration.patterns, declarations.filter((value) => value.contract !== selection.contract)),
+        };
     }
-    if (selection.contract !== undefined && !declarations.some((value) => value.contract === selection.contract)) {
-        throw new Error(`active contract not found: ${selection.contract}`);
-    }
-    return { kind: "overlap", ...(selection.contract === undefined ? {} : { subject: selection.contract }), intersections };
+    return {
+        kind: "path",
+        patterns: selection.patterns,
+        overlaps: regionOverlaps(selection.patterns, declarations),
+    };
 }

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

@@ -1,5 +1,6 @@
 import { type AliasBinding } from "../alias/index.js";
 import { type AkuId } from "../akuma/identity.js";
+import { contractId } from "../core/facts/types.js";
 import { type AkumaAlias, type AkumaGlob } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { KanshiReport, Section } from "../kanshi/index.js";
@@ -27,7 +28,7 @@ export declare class AkumaWorldScopeError extends TypeError {
 }
 export type NamedAddress = Readonly<{
     kind: "contract";
-    id: string;
+    id: ReturnType<typeof contractId>;
 }> | Readonly<{
     kind: "akuma";
     id: AkuId;

package/build/src/library/address.js

@@ -46,11 +46,12 @@ export function resolveNamedAddress(input) {
     if (input.aliases.kind === "failed") {
         throw new TypeError("cannot resolve a named selector while Alias authority is failed");
     }
-    const contractMatches = (input.report.contracts.kind === "present" ? input.report.contracts.value.rows : []).filter((row) => row.disposition === "active"
-        && row.workspace === "worktree" && row.worktreePath !== null
-        && `@${row.id.slice("kei/".length)}` === alias);
+    const contractMatches = (input.report.contracts.kind === "present" ? input.report.contracts.value.rows : []).filter((row) => row.disposition === "active" &&
+        row.workspace === "worktree" &&
+        row.worktreePath !== null &&
+        `@${row.id.slice("kei/".length)}` === alias);
     const aliasId = input.aliases.kind === "present"
-        ? input.aliases.value.find((binding) => binding.alias === alias)?.akuId ?? null
+        ? (input.aliases.value.find((binding) => binding.alias === alias)?.akuId ?? null)
         : null;
     if (contractMatches.length > 0 && aliasId !== null)
         throw new TypeError(`ambiguous selector matches Contract and Akuma: ${selector}`);
@@ -127,7 +128,7 @@ async function contractMemberInWorld(path, id) {
 async function refuseForeignContractMembers(path, ids, contractMembers) {
     const foreign = [];
     for (const id of ids) {
-        if (contractMembers.has(id) && !await contractMemberInWorld(path, id))
+        if (contractMembers.has(id) && !(await contractMemberInWorld(path, id)))
             foreign.push(id);
     }
     if (foreign.length > 0)
@@ -147,9 +148,7 @@ export async function addressAkumaSet(input) {
     if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");
     }
-    const fleetIds = hasSelectorKind(selectors, "glob")
-        ? idsFromFleet(await world(path).list())
-        : [];
+    const fleetIds = hasSelectorKind(selectors, "glob") ? idsFromFleet(await world(path).list()) : [];
     const aliases = hasSelectorKind(selectors, "alias")
         ? new Map((await readAliases(path)).map((binding) => [binding.alias, binding.akuId]))
         : new Map();

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

@@ -2,7 +2,7 @@ import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
 import { Akuma, akumaCallExecution, callAkumaWithContext, } from "../akuma/akuma.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { publishDispatch, readDispatch, } from "../dispatch/index.js";
+import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { requireInput } from "./input.js";
@@ -23,7 +23,9 @@ function text(value, label) {
 function settingsOption(value) {
     if (value === undefined)
         return undefined;
-    if (typeof value !== "object" || value === null || typeof value.namespace !== "function") {
+    if (typeof value !== "object" ||
+        value === null ||
+        typeof value.namespace !== "function") {
         throw new TypeError("settings must be a Settings");
     }
     return value;
@@ -136,9 +138,6 @@ async function currentManagedContract(contract, contractId) {
     }
     if (state.terminal !== null)
         throw new KeiyakuRefused({ kind: "terminal", contractId: state.id });
-    if (state.coordinates.workspace !== "worktree") {
-        throw unavailableWorkspace(state.id, "is here");
-    }
     return state;
 }
 async function resolveCallExecution(input) {
@@ -167,7 +166,20 @@ async function resolveCallExecution(input) {
 }
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, ["path", "archetype", "body", "cwd", "readonly", "mode", "timeoutMs", "home", "settings", "contract", "alias", "allowed"], "Keiyaku.call input");
+    onlyKeys(values, [
+        "path",
+        "archetype",
+        "body",
+        "cwd",
+        "readonly",
+        "mode",
+        "timeoutMs",
+        "home",
+        "settings",
+        "contract",
+        "alias",
+        "allowed",
+    ], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
@@ -177,9 +189,7 @@ export async function callKeiyaku(input) {
     const timeoutMs = callTimeout(values.timeoutMs, mode);
     const home = homeOption(values.home);
     const settings = settingsOption(values.settings);
-    const alias = values.alias === undefined
-        ? undefined
-        : parseAkumaAlias(nonblank(values.alias, "alias"));
+    const alias = values.alias === undefined ? undefined : parseAkumaAlias(nonblank(values.alias, "alias"));
     const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
     const execution = await resolveCallExecution({
         path,
@@ -194,9 +204,7 @@ export async function callKeiyaku(input) {
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
     };
-    const handle = execution === undefined
-        ? await world.call(call)
-        : await callAkumaWithContext(world, call, { cwdCanonical: true });
+    const handle = execution === undefined ? await world.call(call) : await callAkumaWithContext(world, call, { cwdCanonical: true });
     const completedExecution = execution ?? akumaCallExecution(handle);
     if (completedExecution === undefined)
         throw new Error("Akuma call is missing its birth execution");

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

@@ -16,5 +16,4 @@ export declare function auditContract(input: Readonly<{
     scope: RepositoryScope;
     contractId: ContractId;
     input?: AuditInput;
-    resolveHereWorkspace?: (contractId: ContractId) => Promise<string | undefined>;
 }>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -2,7 +2,7 @@ import { decodeContractDocument } from "../body/decode.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { auditOperation } from "../protocol/audit.js";
 import { worktreeHooksOption } from "./configuration.js";
-import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput, } from "./input.js";
+import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput } from "./input.js";
 import { completeMutation } from "./mutation.js";
 import { requireAccepted } from "./refusal.js";
 function normalizeAuditInput(input) {
@@ -31,7 +31,6 @@ export async function auditContract(input) {
             requireBranchesToBeUpToDate: normalized.requireBranchesToBeUpToDate,
             ...(normalized.signal === undefined ? {} : { signal: normalized.signal }),
             ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
-            ...(input.resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace: input.resolveHereWorkspace }),
         }));
         return completeMutation({
             scope: input.scope,

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

@@ -1,22 +1,70 @@
+import { decodeContractDocument } from "../body/decode.js";
 import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { bindOperation } from "../protocol/bind.js";
-import type { IntentOutcome, RepositoryScope } from "../protocol/operations.js";
+import { bindOperation, type BindTargetSelection } from "../protocol/bind.js";
+import { type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
 import type { TaskId } from "../task/identity.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
-import type { KeiyakuRefusal } from "./refusal.js";
+import { type KeiyakuRefusal } from "./refusal.js";
 type BindAttemptInput = Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
     title: string;
     terms: Parameters<typeof bindOperation>[0]["terms"];
     verification: VerificationDeclarationPreparation;
-    workspace: "worktree" | "here";
-    target?: string;
+    workspace: "worktree";
+    targetSelection?: BindTargetSelection;
+    coordinates?: Readonly<{
+        start: import("../core/facts/types.js").SnapshotId;
+    }>;
+    source?: Parameters<typeof bindOperation>[0]["source"];
     task?: TaskId;
     actor?: ActorId;
 }>;
 export declare function admitBindWithAppointment(input: BindAttemptInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
 }>, KeiyakuRefusal>>;
+export declare function admitForkBindWithAppointment(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    sourceId: ContractId;
+    target?: string;
+    actor?: ActorId;
+}>): Promise<{
+    admission: IntentOutcome<Readonly<{
+        contractId: ContractId;
+    }>, KeiyakuRefusal>;
+    document: import("../body/types.js").DecodedContractDocument;
+}>;
+export declare function admitMarkdownBind(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    title: string;
+    terms: Parameters<typeof bindOperation>[0]["terms"];
+    verification: VerificationDeclarationPreparation;
+    workspace: "worktree";
+    targetSelection?: BindTargetSelection;
+    task?: TaskId;
+    actor?: ActorId;
+}>): Promise<IntentOutcome<Readonly<{
+    contractId: ContractId;
+}>, KeiyakuRefusal>>;
+export declare function prepareMarkdownBind(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    document: ReturnType<typeof decodeContractDocument>;
+    gates: readonly import("../core/facts/types.js").Gate[];
+    after: readonly ContractId[];
+    workspace: "worktree";
+    targetSelection?: BindTargetSelection;
+    task?: TaskId;
+    actor?: ActorId;
+}>): Promise<{
+    admission: import("../settlement/holder.js").TaskHolderAdmission<IntentOutcome<Readonly<{
+        contractId: ContractId;
+    }>, KeiyakuRefusal>> | null;
+    result: IntentOutcome<Readonly<{
+        contractId: ContractId;
+    }>, KeiyakuRefusal>;
+}>;
 export {};