@astrosheep/keiyaku 4.0.3 → 4.0.5

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

@@ -2,8 +2,8 @@ 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 GitRepository } from "../git/process.js";
+import { type TargetPlacementRefusal } from "../git/target-placement.js";
 import { type AcceptedAdmission } from "./attempt.js";
 import { type ProtocolResult } from "./run.js";
 export type PlacementExecutionFailure = Readonly<{
@@ -25,17 +25,8 @@ type PlacementProtocolInput = Readonly<{
     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>;
+/** Hold the existing target-placement fence for one owner callback. */
+export declare function runUnderTargetPlacementFence<T>(repository: GitRepository, target: string, run: () => Promise<T>, onReleaseFailure?: (result: T, error: unknown) => T | PlacementExecutionFailure): Promise<T | PlacementExecutionFailure>;
 /** 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

@@ -4,8 +4,8 @@ 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 { GitPlumbingError } from "../git/process.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { prepareProtocolAttempt, runProtocol, } from "./run.js";
 function placementFailure(error) {
@@ -20,18 +20,6 @@ function expectedOperationalDiagnostic(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]);
@@ -74,7 +62,7 @@ async function runFencedPlacement(repository, input, protocol) {
     return { kind: "exhausted" };
 }
 /** Hold the existing target-placement fence for one owner callback. */
-async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
+export async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
     let held;
     try {
         held = await acquireTargetPlacementFence(repository, target);

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

@@ -1,5 +1,5 @@
 import type { ContractTargetLag, ContractWorkspaceObservation } from "../../git/workspace.js";
-import type { GitRepository } from "../../git/repository.js";
+import type { GitRepository } from "../../git/process.js";
 import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
 import type { ContractId, ContractState, DeliverData, SnapshotId } from "../../core/facts/types.js";
@@ -46,6 +46,8 @@ export type ContractObservation = Readonly<{
 }>;
 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(observation: GitReadObservation): Promise<ContractBoard>;
+export declare function readContractBoard(observation: GitReadObservation, selected?: ContractId): Promise<ContractBoard>;
+/** Observe one Contract and its target from one fresh ref epoch. */
+export declare function readContractObservation(observation: GitReadObservation, id: ContractId): Promise<ContractObservation>;
 /** 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

@@ -67,7 +67,9 @@ async function rowFor(repository, state, bindAt, targetObservation, register) {
         workspaceObservation,
         target: state.coordinates.target ?? null,
         targetLag,
-        delivery: state.delivery?.data ?? null,
+        delivery: state.delivery === null || state.currentIntegration === null
+            ? null
+            : { ...state.delivery.data, integration: state.currentIntegration },
         targetObservation,
         gates: {
             reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
@@ -76,7 +78,15 @@ async function rowFor(repository, state, bindAt, targetObservation, register) {
     };
 }
 /** Build the Contract board from one immutable git observation. */
-export async function readContractBoard(observation) {
+export async function readContractBoard(observation, selected) {
+    if (selected !== undefined) {
+        const contract = await readContractObservation(observation, selected);
+        return {
+            root: observation.repository.primaryWorktree,
+            state: observation.snapshot.commit,
+            rows: contract.kind === "missing" ? [] : [contract.row],
+        };
+    }
     const observed = await observeActiveContractWorld(observation);
     const register = await readPlaceRegister(observation.repository);
     const rows = [];
@@ -90,18 +100,20 @@ export async function readContractBoard(observation) {
     return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
+export async function readContractObservation(observation, id) {
+    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)),
+        };
+}
+/** 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)),
-            };
-    });
+    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id));
 }

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

@@ -0,0 +1,35 @@
+import { type ReconcileResult } from "../git/reconcile.js";
+import type { ContractId, ContractState } from "../core/facts/types.js";
+import type { WorktreeHooks } from "../git/hooks.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import type { MutationOperationInput, RepositoryScope } from "./operations.js";
+export type ReconcileReport = ReconcileResult;
+type ReconcileObservation = Readonly<{
+    state: ContractState | null;
+    report: ReconcileReport;
+}>;
+type ReconcileOptions = Readonly<{
+    hooks: WorktreeHooks;
+    retryHooks: boolean;
+    retainTerminalWorktree?: boolean;
+    place?: string;
+    places?: ReadonlyMap<ContractId, string>;
+}>;
+export declare function reconcileOperation(input: MutationOperationInput & ReconcileOptions): Promise<ReconcileObservation>;
+type RepoReconcileItem = Readonly<{
+    contractId: ContractId;
+    state: ContractState | null;
+    report: ReconcileReport;
+}>;
+type RepoReconcileReport = Readonly<{
+    contracts: readonly RepoReconcileItem[];
+}>;
+export declare function worldContractStates(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+}>): Promise<readonly ContractState[]>;
+export declare function reconcileAllOperation(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+}> & ReconcileOptions): Promise<RepoReconcileReport>;
+export {};

package/build/src/protocol/reconcile.js

@@ -0,0 +1,41 @@
+import { reconcile, reconcileBatch, reconcileObservationFailure } from "../git/reconcile.js";
+import { observeContractWorld } from "../git/observe.js";
+import { withGitReadObservation } from "../git/read-observation.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+export async function reconcileOperation(input) {
+    try {
+        const observation = await reconcile({
+            repository: input.scope,
+            channel: input.channel,
+            contractId: input.contractId,
+            hooks: input.hooks,
+            retryHooks: input.retryHooks,
+            ...(input.retainTerminalWorktree === undefined ? {} : { retainTerminalWorktree: input.retainTerminalWorktree }),
+            ...(input.place === undefined ? {} : { place: input.place }),
+        });
+        return { state: observation.state, report: observation.result };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { state: null, report: reconcileObservationFailure(error) };
+    }
+}
+export async function worldContractStates(input) {
+    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
+    return [...observation.contracts.values()].flatMap((value) => value.state === null ? [] : [value.state]);
+}
+export async function reconcileAllOperation(input) {
+    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
+    const contracts = (await reconcileBatch(input.scope, input.channel, observation.contracts.keys(), {
+        hooks: input.hooks,
+        retryHooks: input.retryHooks,
+        retainTerminalWorktree: input.retainTerminalWorktree ?? false,
+        ...(input.places === undefined ? {} : { places: input.places }),
+    })).map((item) => ({
+        contractId: item.contract,
+        state: item.state,
+        report: item.result,
+    }));
+    return { contracts };
+}

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

@@ -0,0 +1,31 @@
+import type { ActorId, ContractId, ReintegratedData } from "../core/facts/types.js";
+import { type ReintegrateRefusal } from "../core/verbs/reintegrate.js";
+import { type IntegrationPreparationRefusal } from "../git/integration.js";
+import type { GitRepository } from "../git/process.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type AcceptedAdmission } from "./attempt.js";
+import type { ProtocolTerminal } from "./run.js";
+import { type PlacementExecutionFailure } from "./placement.js";
+type TargetMissing = Readonly<{
+    kind: "target-missing";
+    contractId: ContractId;
+}>;
+export type ReintegrationRefusal = ReintegrateRefusal | TargetMissing | IntegrationPreparationRefusal;
+export type ReintegrationResult = (AcceptedAdmission & Readonly<{
+    value: ReintegratedData;
+}>) | Readonly<{
+    kind: "refused";
+    refusal: ReintegrationRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: ProtocolTerminal;
+}> | PlacementExecutionFailure;
+type ReintegrationInput = Readonly<{
+    channel: GitDecodeChannel;
+    repository: GitRepository;
+    contractId: ContractId;
+    target: string;
+    actor?: ActorId;
+}>;
+export declare function reintegrateOperation(input: ReintegrationInput): Promise<ReintegrationResult>;
+export {};

package/build/src/protocol/reintegrate.js

@@ -0,0 +1,74 @@
+import { contractState } from "../core/facts/observation.js";
+import { decideReintegrate, } from "../core/verbs/reintegrate.js";
+import { materializeReintegrationSnapshot, persistedTender, planIntegration, } from "../git/integration.js";
+import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { timestamp } from "./operations.js";
+import { runUnderTargetPlacementFence } from "./placement.js";
+async function runReintegration(input) {
+    const attempts = mintAttempts({ entryCount: 1 });
+    for (let index = 0; index < attempts.length; index += 1) {
+        const attempt = attempts[index];
+        const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
+        const state = contractState(observation.decision, input.contractId);
+        let preparation;
+        let assertions = [];
+        if (state === null || state.delivery === null || state.currentIntegration === null) {
+            preparation = {
+                kind: "refused",
+                refusal: {
+                    kind: state === null ? "contract-missing" : "delivery-missing",
+                    contractId: input.contractId,
+                },
+            };
+        }
+        else {
+            const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
+            if (planned.kind === "refused") {
+                preparation = planned;
+            }
+            else {
+                const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
+                preparation = {
+                    kind: "prepared",
+                    data: { predecessor: planned.data.predecessor, snapshot },
+                };
+                assertions = [{ ref: input.target, oid: planned.data.predecessor }];
+            }
+        }
+        const decision = decideReintegrate({
+            input: {
+                contractId: input.contractId,
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                at: timestamp(),
+                preparation,
+            },
+            attempt,
+            observation: observation.decision,
+        });
+        if (decision.kind === "refused")
+            return { kind: "refused", refusal: decision.refusal };
+        const result = await admitDecidedOffer({
+            channel: input.channel,
+            repository: input.repository,
+            decisionObservation: observation,
+            attempt,
+            offer: decision.offer,
+            primaryContract: input.contractId,
+            assertions,
+        });
+        if (result.kind === "accepted") {
+            if (preparation.kind !== "prepared")
+                throw new Error("accepted reintegration has no preparation");
+            return { ...result, value: preparation.data };
+        }
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    return { kind: "retry", reason: { kind: "exhausted" } };
+}
+export async function reintegrateOperation(input) {
+    return await runUnderTargetPlacementFence(input.repository, input.target, async () => await runReintegration(input));
+}

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

@@ -0,0 +1,33 @@
+import { type WorkspaceDirtyDelta } from "../git/tender.js";
+import type { AttestationData, ContractState, DeliverData } from "../core/facts/types.js";
+import { type AttestationRefusal } from "../core/verbs/attestation.js";
+import { type CompletionEvidence } from "./completion.js";
+import type { DocumentDerivation, IntentOutcome, MutationOperationInput, RepositoryScope } from "./operations.js";
+type ReviewPreparationRefusal = Readonly<{
+    kind: "worktree-missing";
+    contractId: import("../core/facts/types.js").ContractId;
+}> | import("../git/tender.js").DirtyWorkspaceRefusal;
+type ReviewRefusal = AttestationRefusal | ReviewPreparationRefusal;
+type ReviewOperationInput = MutationOperationInput & Readonly<{
+    verdict: AttestationData["verdict"];
+    summary?: string;
+    deriveDocument?: (state: ContractState) => DocumentDerivation;
+}>;
+export type ReviewValue = CompletionEvidence & Readonly<{
+    workspace?: WorkspaceDirtyDelta;
+}>;
+export declare function prepareReview(repository: RepositoryScope, stage: Readonly<{
+    contractId: import("../core/facts/types.js").ContractId;
+    coordinates: ContractState["coordinates"];
+}>): Promise<{
+    kind: "prepared";
+    data: Readonly<{
+        changeId: DeliverData["integration"]["changeId"];
+        workspace?: WorkspaceDirtyDelta;
+    }>;
+} | {
+    kind: "refused";
+    refusal: ReviewPreparationRefusal;
+}>;
+export declare function reviewOperation(input: ReviewOperationInput): Promise<IntentOutcome<ReviewValue, ReviewRefusal>>;
+export {};

package/build/src/protocol/review.js

@@ -0,0 +1,148 @@
+import { worktreeChangeId } from "../git/integration.js";
+import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, } from "../git/tender.js";
+import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { dependencyKeySet } from "../core/subject.js";
+import { contractState } from "../core/facts/observation.js";
+import { gate } from "../core/facts/types.js";
+import { decideAttestation } from "../core/verbs/attestation.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { admitted } from "./outcome.js";
+import { completeCandidate } from "./completion.js";
+import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
+import { timestamp } from "./operations.js";
+const REVIEWED = gate("reviewed");
+async function captureReviewableWorktree(repository, stage) {
+    const appointed = stage.coordinates.workspace === "worktree"
+        ? appointmentFor(await readPlaceRegister(repository), stage.contractId)
+        : undefined;
+    const tender = await captureTender(repository, {
+        ...stage,
+        ...(appointed === undefined ? {} : { place: appointed.place }),
+    });
+    if (tender.kind === "refused")
+        return tender;
+    if (tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, stage.contractId, tender.data) };
+    }
+    const workspace = await dirtyTenderDelta(repository, tender.data);
+    return {
+        kind: "prepared",
+        data: {
+            changeId: await worktreeChangeId(repository, stage, tender.data),
+            tender: tender.data,
+            ...(workspace === undefined ? {} : { workspace }),
+        },
+    };
+}
+export async function prepareReview(repository, stage) {
+    const prepared = await captureReviewableWorktree(repository, stage);
+    if (prepared.kind === "refused")
+        return prepared;
+    return {
+        kind: "prepared",
+        data: {
+            changeId: prepared.data.changeId,
+            ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
+        },
+    };
+}
+function reviewValue(value, completion = {}) {
+    return {
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...completion,
+    };
+}
+async function reviewAttempt(input, attempt) {
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(decisionObservation.decision, input.contractId);
+    let preparation;
+    let workspace;
+    let tender;
+    if (state !== null) {
+        const prepared = await captureReviewableWorktree(input.scope, {
+            contractId: state.id,
+            coordinates: state.coordinates,
+        });
+        preparation = prepared.kind === "refused"
+            ? { kind: "refused", refusal: prepared.refusal }
+            : {
+                kind: "prepared",
+                data: {
+                    gate: REVIEWED,
+                    subject: dependencyKeySet([
+                        { kind: "document", value: state.terms.document.key },
+                        { kind: "change", value: prepared.data.changeId },
+                    ]),
+                    verdict: input.verdict,
+                    ...(input.summary === undefined ? {} : { summary: input.summary }),
+                },
+            };
+        if (prepared.kind === "prepared") {
+            workspace = prepared.data.workspace;
+            tender = prepared.data.tender;
+        }
+    }
+    const decision = decideAttestation({
+        input: {
+            contractId: input.contractId,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            at: timestamp(),
+            ...(preparation === undefined ? {} : { preparation }),
+        },
+        attempt,
+        observation: decisionObservation.decision,
+    });
+    if (decision.kind === "refused")
+        return { kind: "refused", refusal: decision.refusal };
+    const admission = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
+    if (admission.kind === "accepted")
+        return {
+            ...admission,
+            value: {
+                ...(workspace === undefined ? {} : { workspace }),
+                ...(tender === undefined ? {} : { tender }),
+            },
+        };
+    return admission;
+}
+export async function reviewOperation(input) {
+    const git = input.scope;
+    const attempts = mintAttempts({ entryCount: 1 });
+    let review = null;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const result = await reviewAttempt(input, attempts[index]);
+        if (result.kind === "accepted" || result.kind === "refused") {
+            review = result;
+            break;
+        }
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    if (review === null)
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    if (review.kind !== "accepted")
+        return review;
+    if (input.verdict !== "satisfied")
+        return admitted(review, reviewValue(review.value));
+    const derivation = input.deriveDocument?.(review.state);
+    const completed = await completeCandidate({
+        channel: input.channel,
+        repository: git,
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(review.state.coordinates.target === undefined ? {} : { target: review.state.coordinates.target }),
+        verification: derivation?.verification ?? { kind: "prepared", data: null },
+        initial: review,
+        verifyInitial: false,
+    });
+    return admitted(completed.admission, reviewValue(review.value, completed.evidence));
+}

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

@@ -1,6 +1,6 @@
 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 { GitRepository } from "../git/process.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";

package/build/src/runtime/proc/run.d.ts

@@ -51,6 +51,7 @@ export type OwnedProcess = Readonly<{
 export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;
 export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;
 export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
+export declare function runCrossPlatformProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
 export declare function consumeProcessStdout(input: ProcessInput, consume: (chunk: Buffer) => void): Promise<ProcessConsumption>;
 export {};

package/build/src/runtime/proc/run.js

@@ -2,6 +2,7 @@ import { execFile, spawn } from "node:child_process";
 import { open } from "node:fs/promises";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
+import crossSpawn from "cross-spawn";
 const TERMINATION_GRACE_MS = 250;
 const STREAM_TAIL_BYTES = 16 * 1024;
 function tailCapture(limit) {
@@ -138,10 +139,10 @@ function terminalOutcome(code, stdout, stderr, consuming) {
         truncated: (consuming ? false : stdout.truncated) || stderr.truncated,
     };
 }
-async function executeProcess(input, timeoutMs, consumeStdout) {
+async function executeProcess(input, timeoutMs, consumeStdout, spawnProcess = spawn) {
     if (input.signal?.aborted === true)
         return { outcome: { kind: "cancelled" }, pid: null };
-    const child = spawn(input.argv[0], input.argv.slice(1), {
+    const child = spawnProcess(input.argv[0], input.argv.slice(1), {
         cwd: input.cwd,
         env: input.env,
         detached: true,
@@ -223,6 +224,12 @@ export async function runProcess(input) {
         throw new Error("buffered process produced a stream consumer error");
     return result.outcome;
 }
+export async function runCrossPlatformProcess(input) {
+    const result = await executeProcess(input, input.timeoutMs, undefined, crossSpawn);
+    if (result.outcome.kind === "stream-error")
+        throw new Error("buffered process produced a stream consumer error");
+    return result.outcome;
+}
 export async function runProcessToExit(input) {
     const result = await executeProcess(input, undefined);
     if (result.outcome.kind === "stream-error")

package/build/src/settlement/fence.d.ts

@@ -1,5 +1,5 @@
 import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
-import { type GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { TaskId } from "../task/identity.js";
 export declare function settlementFencePath(repository: GitRepository, taskId: TaskId): string;
 export declare function acquireTaskSettlementFence(repository: GitRepository, taskId: TaskId): Promise<HeldSqliteTransactionLock>;

package/build/src/settlement/holder.d.ts

@@ -1,7 +1,7 @@
 import type { TreeUpdate } from "../core/facts/offer.js";
 import { type ContractId } from "../core/facts/types.js";
 import type { GitDecisionObservation } from "../git/observe.js";
-import { type GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "../git/read-observation.js";
 import { type TaskId } from "../task/identity.js";
 export declare function taskHolderObservationSelection(): GitTreeSelection;

package/build/src/settlement/settle.d.ts

@@ -1,7 +1,7 @@
 import { type ContractId, type ContractState } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { Effect } from "../git/reconcile.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { TaskId } from "../task/identity.js";
 export type SettlementAction = Readonly<{
     kind: "task";
@@ -29,6 +29,7 @@ export declare function deferredTaskHolderSettlement(input: Readonly<{
     taskId: TaskId;
     diagnostic: string;
 }>): SettlementReport;
+export declare function contractNamespace(id: ContractId): readonly [string];
 export type SettlementInput = Readonly<{
     repository: GitRepository;
     channel: GitDecodeChannel;

package/build/src/settlement/settle.js

@@ -7,6 +7,9 @@ import { World } from "../world.js";
 export function deferredTaskHolderSettlement(input) {
     return { actions: [], lags: [{ kind: "settlement-failed", surface: "task-holder", ...input }] };
 }
+export function contractNamespace(id) {
+    return [contractSegment(id)];
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -79,7 +82,7 @@ async function settleNamespace(state, effects, actions, lags) {
             actions.push({
                 kind: "namespace-context",
                 path: effect.path,
-                action: await repairNamespaceContext(world, [contractSegment(state.id)]),
+                action: await repairNamespaceContext(world, contractNamespace(state.id)),
             });
         }
         catch (error) {