@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/protocol/outcome.d.ts

@@ -1,18 +1,29 @@
 import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
+import type { WorktreeLeak } from "../git/scratch.js";
+import type { ReconcileResult } from "../git/reconcile.js";
 import type { AcceptedAdmission } from "./attempt.js";
+import type { VerificationCleanupFailure } from "./intent.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
+export type AcceptedProtocolStep = AcceptedAdmission & Readonly<{
+    physical?: ReconcileResult;
+}>;
+export type AcceptedObligations = Readonly<{
+    cleanup?: VerificationCleanupFailure;
+    leak?: WorktreeLeak;
+}>;
 export type IntentOutcome<Value, Refusal = never> = Readonly<{
     kind: "accepted";
     facts: readonly JournalEntry[];
     head: ContractHead;
     value: Value;
-}> | Readonly<{
+    physical?: ReconcileResult;
+} & AcceptedObligations> | Readonly<{
     kind: "refused";
     refusal: Refusal;
 }> | Readonly<{
     kind: "retry";
     reason: ProtocolTerminal;
 }>;
-export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value): IntentOutcome<Value, Refusal>;
-export declare function admitted<Value, Refusal = never>(admission: AcceptedAdmission, value: Value): IntentOutcome<Value, Refusal>;
+export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult, obligations?: AcceptedObligations): IntentOutcome<Value, Refusal>;
+export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
 export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;

package/build/src/protocol/outcome.js

@@ -1,10 +1,18 @@
-export function accepted(state, facts, value) {
+export function accepted(state, facts, value, physical, obligations) {
     if (state.head === null)
         throw new Error("accepted contract is missing its journal head");
-    return { kind: "accepted", facts, head: state.head, value };
+    return {
+        kind: "accepted",
+        facts,
+        head: state.head,
+        value,
+        ...(physical === undefined ? {} : { physical }),
+        ...(obligations?.cleanup === undefined ? {} : { cleanup: obligations.cleanup }),
+        ...(obligations?.leak === undefined ? {} : { leak: obligations.leak }),
+    };
 }
 export function admitted(admission, value) {
-    return accepted(admission.state, admission.facts, value);
+    return accepted(admission.state, admission.facts, value, admission.physical);
 }
 export function complete(result, value) {
     if (result.kind === "refused")

package/build/src/protocol/placement.d.ts

@@ -0,0 +1,41 @@
+import type { ActorId, ContractId, SnapshotId } from "../core/facts/types.js";
+import { type PlacementRefusal } from "../core/verbs/placement.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type ReconcileResult } from "../git/reconcile.js";
+import { type GitRepository } from "../git/repository.js";
+import { type TargetPlacementObservationInput, type TargetPlacementRefusal } from "../git/target-placement.js";
+import { type AcceptedAdmission } from "./attempt.js";
+import { type ProtocolResult } from "./run.js";
+export type PlacementExecutionFailure = Readonly<{
+    kind: "placement-failed";
+    diagnostic: string;
+}>;
+export type TargetMovedStop = Readonly<{
+    kind: "target-moved";
+    contractId: ContractId;
+    target: string;
+    expected: SnapshotId;
+    observed: SnapshotId | null;
+}>;
+export type PlacementProtocolResult<ExtraRefusal = never> = (AcceptedAdmission & Readonly<{
+    physical?: ReconcileResult;
+}>) | Exclude<ProtocolResult<PlacementRefusal | TargetPlacementRefusal | ExtraRefusal>, AcceptedAdmission> | TargetMovedStop | PlacementExecutionFailure;
+type PlacementProtocolInput = Readonly<{
+    contractId: ContractId;
+    actor?: ActorId;
+    at: string;
+}>;
+export type ProspectiveTargetPreview = Readonly<{
+    kind: "ready";
+}> | Readonly<{
+    kind: "refused";
+    refusal: TargetPlacementRefusal;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+/** Observe prospective target followability without fencing or placing. */
+export declare function observeProspectiveTargetPlacement(repository: GitRepository, input: TargetPlacementObservationInput): Promise<ProspectiveTargetPreview>;
+/** Run the sole placement adjudicator inside the target's physical fence. */
+export declare function admitPlacement<ExtraRefusal = never>(channel: GitDecodeChannel, repository: GitRepository, target: string | undefined, input: PlacementProtocolInput, onDeliveryMissing?: () => Promise<PlacementProtocolResult<ExtraRefusal> | undefined>): Promise<PlacementProtocolResult<ExtraRefusal>>;
+export {};

package/build/src/protocol/placement.js

@@ -0,0 +1,147 @@
+import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { contractState } from "../core/facts/observation.js";
+import { decidePlacement } from "../core/verbs/placement.js";
+import { observeGitForAdmissionAt } from "../git/observe.js";
+import { reconcileEffectFailure } from "../git/reconcile.js";
+import { GitPlumbingError } from "../git/repository.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, observeTargetPlacement, } from "../git/target-placement.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { prepareProtocolAttempt, runProtocol, } from "./run.js";
+function placementFailure(error) {
+    return { kind: "placement-failed", diagnostic: error instanceof Error ? error.message : String(error) };
+}
+function expectedOperationalDiagnostic(error) {
+    if (error instanceof GitPlumbingError || error instanceof SqliteTransactionLockError) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    throw error;
+}
+function expectedPlacementFailure(error) {
+    return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
+}
+/** Observe prospective target followability without fencing or placing. */
+export async function observeProspectiveTargetPlacement(repository, input) {
+    try {
+        const observed = await observeTargetPlacement(repository, input);
+        return observed.kind === "ready"
+            ? { kind: "ready" }
+            : { kind: "refused", refusal: observed.refusal };
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: expectedOperationalDiagnostic(error) };
+    }
+}
+async function runFencedPlacement(repository, input, protocol) {
+    for (let index = 0; index < protocol.attempts.length; index += 1) {
+        const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
+        if (prepared.kind === "refused")
+            return prepared;
+        const state = contractState(prepared.observation.decision, input.contractId);
+        if (state === null)
+            throw new Error("placement offer has no contract state");
+        if (prepared.offer.target === undefined)
+            throw new Error("targeted placement offer is missing its target movement");
+        const observed = await observeTargetHead(repository, prepared.offer.target.target);
+        if (observed !== prepared.offer.target.expectedOid) {
+            return {
+                kind: "target-moved",
+                contractId: input.contractId,
+                target: prepared.offer.target.target,
+                expected: prepared.offer.target.expectedOid,
+                observed,
+            };
+        }
+        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
+        if (physical.kind === "refused")
+            return physical;
+        const result = await admitDecidedOffer({
+            channel: protocol.channel,
+            repository,
+            decisionObservation: prepared.observation,
+            attempt: prepared.attempt,
+            offer: prepared.offer,
+            primaryContract: input.contractId,
+        });
+        if (result.kind === "accepted") {
+            return { ...result, physical: await followTargetPlacement(repository, physical.placement) };
+        }
+        if (result.kind === "publication-failed")
+            return result;
+        if (result.kind === "collision" && index + 1 === protocol.attempts.length)
+            return result;
+    }
+    return { kind: "exhausted" };
+}
+/** Hold the existing target-placement fence for one owner callback. */
+async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
+    let held;
+    try {
+        held = await acquireTargetPlacementFence(repository, target);
+    }
+    catch (error) {
+        return placementFailure(error);
+    }
+    let produced;
+    let result;
+    let exceptional;
+    try {
+        produced = await run();
+        result = produced;
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            exceptional = error;
+        else {
+            try {
+                result = expectedPlacementFailure(error);
+            }
+            catch (unexpected) {
+                exceptional = unexpected;
+            }
+        }
+    }
+    let releaseFailure;
+    try {
+        held.close();
+    }
+    catch (error) {
+        releaseFailure = error;
+    }
+    if (exceptional !== undefined)
+        throw exceptional;
+    if (result === undefined)
+        throw new Error("fenced target work produced no result");
+    if (releaseFailure !== undefined) {
+        return produced !== undefined && onReleaseFailure !== undefined
+            ? onReleaseFailure(produced, releaseFailure)
+            : placementFailure(releaseFailure);
+    }
+    return result;
+}
+function isDeliveryMissing(result) {
+    return result.kind === "refused" && result.refusal.kind === "delivery-missing";
+}
+/** Run the sole placement adjudicator inside the target's physical fence. */
+export async function admitPlacement(channel, repository, target, input, onDeliveryMissing) {
+    const attempts = mintAttempts({ entryCount: 1 });
+    const protocol = {
+        input,
+        channel,
+        repository,
+        contracts: [input.contractId],
+        attempts,
+        decide: decidePlacement,
+        observe: (observedRepository, observedChannel, contracts) => observeGitForAdmissionAt(observedRepository, observedChannel, contracts),
+    };
+    if (target === undefined)
+        return await runProtocol(protocol);
+    return await runUnderTargetPlacementFence(repository, target, async () => {
+        const result = await runFencedPlacement(repository, input, protocol);
+        if (onDeliveryMissing === undefined || !isDeliveryMissing(result))
+            return result;
+        return await onDeliveryMissing() ?? result;
+    }, (result, error) => result.kind === "accepted"
+        ? { ...result, physical: reconcileEffectFailure(error, result.physical) }
+        : placementFailure(error));
+}

package/build/src/protocol/read/documents.d.ts

@@ -1,8 +1,8 @@
-import type { GitRepository } from "../../git/repository.js";
+import type { GitReadObservation } from "../../git/read-observation.js";
 import type { ContractId } from "../../core/facts/types.js";
 export type ContractDocumentProjection = Readonly<{
     contract: ContractId;
     documentBytes: string;
 }>;
 /** Read every live contract document from one immutable Git snapshot. */
-export declare function readDocuments(repository: GitRepository): readonly ContractDocumentProjection[];
+export declare function readDocuments(observation: GitReadObservation): Promise<readonly ContractDocumentProjection[]>;

package/build/src/protocol/read/documents.js

@@ -1,11 +1,11 @@
-import { observeGit } from "../../git/observe.js";
+import { observeActiveContractWorld } from "../../git/observe.js";
 /** Read every live contract document from one immutable Git snapshot. */
-export function readDocuments(repository) {
-    const observed = observeGit(repository);
+export async function readDocuments(observation) {
+    const observed = await observeActiveContractWorld(observation);
     const documents = [];
     for (const [contract, observation] of observed.contracts) {
         const state = observation.state;
-        if (state === null || state.terminal !== null)
+        if (state === null)
             continue;
         documents.push({
             contract,

package/build/src/protocol/read/status.d.ts

@@ -1,6 +1,8 @@
+import type { ContractTargetLag, ContractWorkspaceObservation } from "../../git/workspace.js";
 import type { GitRepository } from "../../git/repository.js";
+import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
-import type { ContractId, SnapshotId } from "../../core/facts/types.js";
+import type { ContractId, ContractState, DeliverData, SnapshotId } from "../../core/facts/types.js";
 export type ContractPhase = "waiting" | "bound" | "pending-delivery" | "claimed" | "abandoned";
 export type ContractDisposition = "active" | "terminal";
 export type ContractGateCurrent = GateCurrent;
@@ -8,14 +10,23 @@ export type ContractGateReport = Readonly<{
     gate: string;
     current: ContractGateCurrent;
 }>;
+export type { ContractTargetLag, ContractWorkspaceObservation };
 export type ContractRow = Readonly<{
     id: ContractId;
+    title: string | null;
     phase: ContractPhase;
+    phaseAt: string;
     disposition: ContractDisposition;
     workspace: "worktree" | "here";
     worktreePath: string | null;
+    workspaceObservation: ContractWorkspaceObservation;
     target: string | null;
-    candidate: SnapshotId | null;
+    targetLag: ContractTargetLag;
+    delivery: DeliverData | null;
+    targetObservation: Readonly<{
+        head: SnapshotId | null;
+        drift: boolean;
+    }> | null;
     gates: Readonly<{
         reports: readonly ContractGateReport[];
         satisfied: boolean;
@@ -23,6 +34,7 @@ export type ContractRow = Readonly<{
 }>;
 export type ContractBoard = Readonly<{
     root: string;
+    state: SnapshotId | null;
     rows: readonly ContractRow[];
 }>;
 export type ContractObservation = Readonly<{
@@ -32,7 +44,8 @@ export type ContractObservation = Readonly<{
     kind: "present";
     row: ContractRow;
 }>;
+export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "delivery" | "bound">, bindAt: string): string;
 /** Build the Contract board from one immutable git observation. */
-export declare function readContractBoard(repository: GitRepository): ContractBoard;
-/** Observe one Contract without enumerating the Contract world. */
-export declare function readContractObservation(repository: GitRepository, id: ContractId): ContractObservation;
+export declare function readContractBoard(observation: GitReadObservation): Promise<ContractBoard>;
+/** Observe one Contract and its target from one fresh ref epoch. */
+export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId): Promise<ContractObservation>;

package/build/src/protocol/read/status.js

@@ -1,6 +1,18 @@
-import { observeGit, observeContract } from "../../git/observe.js";
-import { deliveryWorktreePath } from "../../git/reconcile.js";
+import { observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
+import { decodeContractDocument } from "../../body/decode.js";
+import { observeTargetLag, observeWorkspace, worktreePath, } from "../../git/workspace.js";
+import { appointmentFor, readPlaceRegister, } from "../../workspace-place.js";
 import { gateReports } from "../../core/facts/gate.js";
+function titleFor(state) {
+    try {
+        return decodeContractDocument(state.terms.document.bytes).title;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return null;
+        throw error;
+    }
+}
 function phaseFor(state) {
     if (state.terminal?.kind === "claimed")
         return "claimed";
@@ -12,17 +24,51 @@ function phaseFor(state) {
         return "bound";
     return "waiting";
 }
-function rowFor(repository, state) {
+export function phaseAtFor(state, bindAt) {
+    return state.terminal?.at ?? state.delivery?.at ?? state.bound?.at ?? bindAt;
+}
+async function managedWorkspaceFacts(repository, state, register, targetObservation) {
+    const appointed = appointmentFor(register, state.id);
+    if (appointed === undefined) {
+        return {
+            appointed,
+            workspaceObservation: { kind: "unappointed" },
+            targetLag: state.coordinates.target === undefined ? { kind: "none" } : { kind: "unknown" },
+        };
+    }
+    const path = worktreePath(repository, appointed.place);
+    const [workspaceObservation, targetLag] = await Promise.all([
+        observeWorkspace(repository, { kind: "worktree", path }, path),
+        observeTargetLag(repository, path, targetObservation?.head),
+    ]);
+    return { appointed, workspaceObservation, targetLag };
+}
+async function hereWorkspaceFacts(repository, targetObservation) {
+    const [workspaceObservation, targetLag] = await Promise.all([
+        observeWorkspace(repository, { kind: "here" }, repository.effectiveCwd),
+        observeTargetLag(repository, repository.effectiveCwd, targetObservation?.head),
+    ]);
+    return { appointed: undefined, workspaceObservation, targetLag };
+}
+async function rowFor(repository, state, bindAt, targetObservation, register) {
     const workspace = state.coordinates.workspace;
     const gates = gateReports(state);
+    const { appointed, workspaceObservation, targetLag } = workspace === "worktree"
+        ? await managedWorkspaceFacts(repository, state, register, targetObservation)
+        : await hereWorkspaceFacts(repository, targetObservation);
     return {
         id: state.id,
+        title: titleFor(state),
         phase: phaseFor(state),
+        phaseAt: phaseAtFor(state, bindAt),
         disposition: state.terminal === null ? "active" : "terminal",
         workspace,
-        worktreePath: workspace === "worktree" ? deliveryWorktreePath(repository, state.id) : null,
+        worktreePath: appointed === undefined ? null : worktreePath(repository, appointed.place),
+        workspaceObservation,
         target: state.coordinates.target ?? null,
-        candidate: state.delivery?.data.candidate ?? null,
+        targetLag,
+        delivery: state.delivery?.data ?? null,
+        targetObservation,
         gates: {
             reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
             satisfied: gates.satisfied,
@@ -30,18 +76,32 @@ function rowFor(repository, state) {
     };
 }
 /** Build the Contract board from one immutable git observation. */
-export function readContractBoard(repository) {
-    const observed = observeGit(repository);
+export async function readContractBoard(observation) {
+    const observed = await observeActiveContractWorld(observation);
+    const register = await readPlaceRegister(observation.repository);
     const rows = [];
     for (const value of observed.contracts.values()) {
         if (value.state === null)
             continue;
-        rows.push(rowFor(repository, value.state));
+        const state = value.state;
+        const bindAt = value.entries[0].at;
+        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor(observation.repository, state, bindAt, target, register)));
     }
-    return { root: repository.primaryWorktree, rows };
+    return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
 }
-/** Observe one Contract without enumerating the Contract world. */
-export function readContractObservation(repository, id) {
-    const state = observeContract(repository, id).state;
-    return state === null ? { kind: "missing", id } : { kind: "present", row: rowFor(repository, state) };
+/** Observe one Contract and its target from one fresh ref epoch. */
+export async function readContractObservationAt(repository, channel, id) {
+    return withContractReadObservationAt(repository, channel, id, async (observation) => {
+        const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
+        const record = observed.journals.get(id);
+        if (record === undefined)
+            throw new Error(`missing requested Contract observation: ${id}`);
+        const state = record.state;
+        return state === null
+            ? { kind: "missing", id }
+            : {
+                kind: "present",
+                row: await rowFor(observation.repository, state, record.entries[0].at, await observeDeliveryTargetAt(observation, state), await readPlaceRegister(observation.repository)),
+            };
+    });
 }

package/build/src/protocol/run.d.ts

@@ -1,5 +1,7 @@
 import { type GitDecisionObservation } from "../git/observe.js";
+import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/repository.js";
+import type { GitRefAssertion } from "../git/repository.js";
 import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
 import type { Offer, TreeUpdate } from "../core/facts/offer.js";
 import { type ContractId } from "../core/facts/types.js";
@@ -16,24 +18,64 @@ export type CompanionDecorator = (input: Readonly<{
     observation: GitDecisionObservation;
     contractId: ContractId;
     offer: Offer;
-}>) => readonly TreeUpdate[];
-type RunProtocolInput<Input extends Readonly<{
+}>) => readonly TreeUpdate[] | Promise<readonly TreeUpdate[]>;
+export type RunProtocolInput<Input extends Readonly<{
     contractId: ContractId;
-}>, Refusal> = Readonly<{
-    input: Input;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input> = Readonly<{
+    channel: GitDecodeChannel;
     repository: GitRepository;
     contracts: readonly ContractId[];
     attempts: readonly AttemptContext[];
     decide: (input: DecideInput<Input>) => OfferDecision<Refusal>;
     /** Override the targeted observer only for intents that need a full snapshot. */
-    observe?: (repository: GitRepository, contracts: readonly ContractId[]) => GitDecisionObservation;
+    observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
     /** Mint verb-owned entries from the exact size of this attempt's observation. */
     extendAttempt?: (attempt: AttemptContext, observedContractCount: number) => AttemptContext;
     /** Add opaque companions from the exact immutable observation for this attempt. */
     decorateOffer?: CompanionDecorator;
+    observationSelection?: GitTreeSelection;
+}> & (Readonly<{
+    input: Input;
+    prepareInput?: never;
+}> | Readonly<{
+    input: Seed;
+    prepareInput: (observation: GitDecisionObservation, input: Seed) => Readonly<{
+        kind: "prepared";
+        input: Input;
+        assertions?: readonly GitRefAssertion[];
+    }> | Readonly<{
+        kind: "refused";
+        refusal: Refusal;
+    }> | Promise<Readonly<{
+        kind: "prepared";
+        input: Input;
+        assertions?: readonly GitRefAssertion[];
+    }> | Readonly<{
+        kind: "refused";
+        refusal: Refusal;
+    }>>;
+}>);
+export type PreparedProtocolAttempt<Refusal> = Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "offered";
+    observation: GitDecisionObservation;
+    attempt: AttemptContext;
+    offer: Offer;
+    assertions: readonly GitRefAssertion[];
 }>;
+/** Form one decided offer without admitting or reinterpreting it. */
+export declare function prepareProtocolAttempt<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>, baseAttempt: AttemptContext): Promise<PreparedProtocolAttempt<Refusal>>;
 /** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
 export declare function runProtocol<Input extends Readonly<{
     contractId: ContractId;
-}>, Refusal>(input: RunProtocolInput<Input, Refusal>): ProtocolResult<Refusal>;
-export {};
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>): Promise<ProtocolResult<Refusal>>;

package/build/src/protocol/run.js

@@ -1,32 +1,60 @@
-import { observeContractsForAdmission } from "../git/observe.js";
+import { extendAdmissionPathsAt, observeContractsForAdmissionAt, } from "../git/observe.js";
 import { admitDecidedOffer } from "./attempt.js";
+/** Form one decided offer without admitting or reinterpreting it. */
+export async function prepareProtocolAttempt(input, baseAttempt) {
+    const decisionObservation = input.observe === undefined
+        ? await observeContractsForAdmissionAt(input.repository, input.channel, input.contracts, input.observationSelection)
+        : await input.observe(input.repository, input.channel, input.contracts);
+    const observation = decisionObservation.decision;
+    const preparedInput = "prepareInput" in input && input.prepareInput !== undefined
+        ? await input.prepareInput(decisionObservation, input.input)
+        : { kind: "prepared", input: input.input, assertions: [] };
+    if (preparedInput.kind === "refused")
+        return preparedInput;
+    const attempt = input.extendAttempt === undefined
+        ? baseAttempt
+        : input.extendAttempt(baseAttempt, observation.size);
+    const decision = input.decide({ input: preparedInput.input, attempt, observation });
+    if (decision.kind === "refused")
+        return decision;
+    const companions = input.decorateOffer === undefined
+        ? []
+        : await input.decorateOffer({
+            repository: input.repository,
+            observation: decisionObservation,
+            contractId: input.input.contractId,
+            offer: decision.offer,
+        });
+    const offer = companions.length === 0
+        ? decision.offer
+        : { ...decision.offer, companions: [...(decision.offer.companions ?? []), ...companions] };
+    const admissionObservation = companions.length === 0
+        ? decisionObservation
+        : await extendAdmissionPathsAt(input.channel, decisionObservation, companions.map(({ path }) => path));
+    return {
+        kind: "offered",
+        observation: admissionObservation,
+        attempt,
+        offer,
+        assertions: preparedInput.assertions ?? [],
+    };
+}
 /** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
-export function runProtocol(input) {
+export async function runProtocol(input) {
     const attempts = input.attempts;
-    const contracts = input.contracts;
-    const observe = input.observe ?? observeContractsForAdmission;
     for (let index = 0; index < attempts.length; index += 1) {
-        const baseAttempt = attempts[index];
-        const decisionObservation = observe(input.repository, contracts);
-        const observation = decisionObservation.decision;
-        const attempt = input.extendAttempt === undefined
-            ? baseAttempt
-            : input.extendAttempt(baseAttempt, observation.size);
-        const decision = input.decide({ input: input.input, attempt, observation });
-        if (decision.kind === "refused")
-            return { kind: "refused", refusal: decision.refusal };
-        const companions = input.decorateOffer === undefined
-            ? []
-            : input.decorateOffer({
-                repository: input.repository,
-                observation: decisionObservation,
-                contractId: input.input.contractId,
-                offer: decision.offer,
-            });
-        const offer = companions.length === 0
-            ? decision.offer
-            : { ...decision.offer, companions: [...(decision.offer.companions ?? []), ...companions] };
-        const result = admitDecidedOffer(input.repository, decisionObservation, attempt, offer, input.input.contractId);
+        const prepared = await prepareProtocolAttempt(input, attempts[index]);
+        if (prepared.kind === "refused")
+            return prepared;
+        const result = await admitDecidedOffer({
+            channel: input.channel,
+            repository: input.repository,
+            decisionObservation: prepared.observation,
+            attempt: prepared.attempt,
+            offer: prepared.offer,
+            primaryContract: input.input.contractId,
+            assertions: prepared.assertions,
+        });
         if (result.kind === "accepted" || result.kind === "publication-failed")
             return result;
         if (result.kind === "collision" && index + 1 === attempts.length)

package/build/src/runtime/proc/line-rpc.d.ts

@@ -1,3 +1,4 @@
+import { type StdioProcessExit } from "./stdio.js";
 export type LineRpcNotification = Readonly<{
     method: string;
     params?: Readonly<Record<string, unknown>>;
@@ -5,20 +6,14 @@ export type LineRpcNotification = Readonly<{
 export type LineRpcServerRequest = LineRpcNotification & Readonly<{
     id: number | string;
 }>;
-export type LineRpcExit = Readonly<{
-    code: number | null;
-    signal: NodeJS.Signals | null;
-    stderr: string;
-}>;
+export type LineRpcExit = StdioProcessExit;
 export declare class LineRpcProcess {
-    private readonly child;
+    private readonly process;
     private readonly pending;
     private readonly notifications;
     private readonly serverRequests;
-    private readonly exited;
     private nextId;
     private stdout;
-    private stderr;
     private closed;
     constructor(input: Readonly<{
         argv: readonly [string, ...string[]];
@@ -33,5 +28,6 @@ export declare class LineRpcProcess {
     private fail;
     request(method: string, params?: Readonly<Record<string, unknown>>): Promise<unknown>;
     notify(method: string): void;
+    endInputAndDrain(timeoutMs?: number): Promise<void>;
     close(force?: boolean): Promise<void>;
 }