@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/library/fleet.js

@@ -9,12 +9,23 @@ import { scopeForRepo } from "./repo.js";
 function source(path) {
     return Akuma.of(path);
 }
-async function contractFor(repo, id) {
-    const dispatch = repo === undefined ? null : await readDispatch(scopeForRepo(repo), id);
-    return dispatch?.contractId;
+function observationDiagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const NO_DISPATCH = { kind: "none" };
+async function dispatchAssociation(repo, id) {
+    if (repo === undefined)
+        return NO_DISPATCH;
+    try {
+        const dispatch = await readDispatch(scopeForRepo(repo), id);
+        return dispatch === null ? NO_DISPATCH : { kind: "associated", contractId: dispatch.contractId };
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: observationDiagnostic(error) };
+    }
 }
 function createdTaskDiagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
+    return observationDiagnostic(error);
 }
 async function createdTasksFor(path, statuses) {
     let board;
@@ -30,16 +41,23 @@ async function createdTasksFor(path, statuses) {
 async function observeAkuma(status, path, repo) {
     return (await observeAkumaSet([status], path, repo))[0];
 }
+async function observeAkumaStage(path, id, repo) {
+    try {
+        return { kind: "observed", ...await observeAkuma(await source(path).of({ id }).status(), path, repo) };
+    }
+    catch (error) {
+        if (error instanceof AkumaNotBornError)
+            throw error;
+        return { kind: "unobserved", diagnostic: observationDiagnostic(error) };
+    }
+}
 async function observeAkumaSet(statuses, path, repo) {
     const created = await createdTasksFor(path, statuses);
-    return await Promise.all(statuses.map(async (status, index) => {
-        const contractId = await contractFor(repo, status.id);
-        return {
-            status,
-            createdTasks: created[index],
-            ...(contractId === undefined ? {} : { contractId }),
-        };
-    }));
+    return await Promise.all(statuses.map(async (status, index) => ({
+        status,
+        contract: await dispatchAssociation(repo, status.id),
+        createdTasks: created[index],
+    })));
 }
 function timeout(value) {
     if (value === undefined)
@@ -69,31 +87,45 @@ function delay(milliseconds, signal) {
     });
 }
 const SHARED_ORDINARY_BUDGET = 30;
-async function observeWaitStatuses(path, ids, signal) {
+async function observeWaitRound(path, ids, signal) {
     signal?.throwIfAborted();
     if (ids.length <= 1) {
-        return await Promise.all(ids.map(async (id) => await source(path).of({ id }).status()));
+        return {
+            statuses: await Promise.all(ids.map(async (id) => await source(path).of({ id }).status())),
+            unobserved: [],
+        };
     }
     let remaining = SHARED_ORDINARY_BUDGET;
     const statuses = [];
+    const unobserved = [];
     for (const id of ids) {
         signal?.throwIfAborted();
-        const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
-        statuses.push(observed.status);
-        remaining -= observed.ordinarySelected;
+        try {
+            const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
+            statuses.push(observed.status);
+            remaining -= observed.ordinarySelected;
+        }
+        catch (error) {
+            if (error instanceof AkumaNotBornError)
+                throw error;
+            unobserved.push({ id, diagnostic: observationDiagnostic(error) });
+        }
     }
-    return statuses;
+    return { statuses, unobserved };
 }
 export async function executeWaitAkuma(input) {
     const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
     for (;;) {
-        const statuses = await observeWaitStatuses(input.path, input.ids, input.signal);
-        const settled = statuses.map((status) => status.life !== "running");
-        if ((input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean))
+        const round = await observeWaitRound(input.path, input.ids, input.signal);
+        const settled = round.statuses.map((status) => status.life !== "running");
+        const completed = round.statuses.length > 0
+            && (input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean));
+        if (completed
             || (deadline !== undefined && performance.now() >= deadline)) {
             return {
                 completion: input.completion,
-                observations: await observeAkumaSet(statuses, input.path, input.repo),
+                observations: await observeAkumaSet(round.statuses, input.path, input.repo),
+                unobserved: round.unobserved,
             };
         }
         await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())), input.signal);
@@ -109,7 +141,7 @@ export async function executeTellAkuma(input) {
     return {
         akuma: input.id,
         tell,
-        observation: await observeAkuma(await handle.status(), input.path, input.repo),
+        observation: await observeAkumaStage(input.path, input.id, input.repo),
     };
 }
 export async function executeKillAkuma(input) {
@@ -117,10 +149,12 @@ export async function executeKillAkuma(input) {
     const handles = input.ids.map((id) => source(input.path).of({ id }));
     const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
     input.signal?.throwIfAborted();
-    const statuses = await Promise.all(input.ids.map(async (id) => await source(input.path).of({ id }).status()));
-    const observations = await observeAkumaSet(statuses, input.path, input.repo);
     return {
-        results: input.ids.map((id, index) => ({ id, evidence: evidence[index], observation: observations[index] })),
+        results: await Promise.all(input.ids.map(async (id, index) => ({
+            id,
+            evidence: evidence[index],
+            observation: await observeAkumaStage(input.path, id, input.repo),
+        }))),
     };
 }
 function upstreamResult(outcome) {
@@ -130,22 +164,29 @@ function upstreamResult(outcome) {
         throw new AkumaNotBornError(outcome.failure.id);
     throw new Error(outcome.failure.diagnostic);
 }
-async function attachContract(repo, observation) {
-    if (repo === undefined || observation.contractId !== undefined)
+function needsDispatchAttach(association) {
+    return association.kind === "none";
+}
+async function attachObservationContract(repo, observation) {
+    if (repo === undefined || !needsDispatchAttach(observation.contract))
+        return observation;
+    return { ...observation, contract: await dispatchAssociation(repo, observation.status.id) };
+}
+async function attachObservationStage(repo, observation) {
+    if (repo === undefined || observation.kind !== "observed")
         return observation;
-    const contractId = await contractFor(repo, observation.status.id);
-    return contractId === undefined ? observation : { ...observation, contractId };
+    return { ...observation, ...(await attachObservationContract(repo, observation)) };
 }
 async function attachWaitContracts(repo, result) {
     return repo === undefined
         ? result
         : {
             ...result,
-            observations: await Promise.all(result.observations.map((observation) => attachContract(repo, observation))),
+            observations: await Promise.all(result.observations.map((observation) => attachObservationContract(repo, observation))),
         };
 }
 async function attachTellContract(repo, result) {
-    return repo === undefined ? result : { ...result, observation: await attachContract(repo, result.observation) };
+    return repo === undefined ? result : { ...result, observation: await attachObservationStage(repo, result.observation) };
 }
 async function attachKillContracts(repo, result) {
     return repo === undefined
@@ -154,7 +195,7 @@ async function attachKillContracts(repo, result) {
             ...result,
             results: await Promise.all(result.results.map(async (entry) => ({
                 ...entry,
-                observation: await attachContract(repo, entry.observation),
+                observation: await attachObservationStage(repo, entry.observation),
             }))),
         };
 }
@@ -262,7 +303,7 @@ export async function interruptAkuma(input) {
     const addressed = await addressAkuma(directAddress(values));
     const handle = source(addressed.path).of({ id: addressed.id });
     const receipt = await handle.interrupt(values.body);
-    const observation = await observeAkuma(await handle.status(), addressed.path, values.repo);
+    const observation = await observeAkumaStage(addressed.path, addressed.id, values.repo);
     return { id: addressed.id, receipt, observation };
 }
 export async function historyAkuma(input) {
@@ -276,18 +317,17 @@ export async function historyAkuma(input) {
         throw new TypeError("last must be a boolean");
     const addressed = await addressAkuma(directAddress(values));
     const handle = source(addressed.path).of({ id: addressed.id });
+    const contract = await dispatchAssociation(values.repo, addressed.id);
     if (values.last === true) {
         const answer = await handle.lastAnswer();
-        const contractId = await contractFor(values.repo, addressed.id);
         return answer.kind === "answer"
-            ? { kind: "last", id: addressed.id, answer: answer.answer, ...(contractId === undefined ? {} : { contractId }) }
-            : { kind: "no-answer", id: addressed.id, ...(contractId === undefined ? {} : { contractId }) };
+            ? { kind: "last", id: addressed.id, answer: answer.answer, contract }
+            : { kind: "no-answer", id: addressed.id, contract };
     }
     const history = await handle.history({
         ...(values.before === undefined ? {} : { before: values.before }),
         ...(values.since === undefined ? {} : { since: values.since }),
         ...(values.limit === undefined ? {} : { limit: values.limit }),
     });
-    const contractId = await contractFor(values.repo, addressed.id);
-    return { kind: "history", id: addressed.id, history, ...(contractId === undefined ? {} : { contractId }) };
+    return { kind: "history", id: addressed.id, history, contract };
 }

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

@@ -6,7 +6,6 @@ export declare function actorOption(actor: unknown): Readonly<{
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
-export declare function rejectUnknownFields(values: Record<string, unknown>, allowed: readonly string[], label: string): void;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;
 export declare function optionalSignal(value: unknown): AbortSignal | undefined;

package/build/src/library/input.js

@@ -22,11 +22,6 @@ export function requireInput(value, label) {
         throw new TypeError(`${label} must be an object`);
     return value;
 }
-export function rejectUnknownFields(values, allowed, label) {
-    for (const key of Object.keys(values))
-        if (!allowed.includes(key))
-            throw new TypeError(`${label} has unknown field: ${key}`);
-}
 export function optionalNonblank(value, label) {
     if (value === undefined)
         return undefined;

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

@@ -2,12 +2,13 @@ import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, typ
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
 import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
 import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId, } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";
@@ -21,8 +22,10 @@ export type { AkumaGlob } from "../identity/selector.js";
 export type { AkuId } from "../akuma/identity.js";
 export type { AllowedAction, AllowedActions } from "../akuma/allowed.js";
 export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
+export type { NukeInput, NukeResult, } from "./nuke.js";
+export type { NukeConfirmationRefusal, NukeConfirmationRequiredRefusal } from "./refusal.js";
 export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
-export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaTellInput, CreatedTaskObservation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
+export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellInput, AkumaUnobserved, CreatedTaskObservation, DispatchAssociation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
 export type Keiyaku = KeiyakuType;
 export declare const Keiyaku: Readonly<{
     prototype: KeiyakuHandle;
@@ -34,6 +37,7 @@ export declare const Keiyaku: Readonly<{
     interrupt: typeof interruptAkuma;
     kill: typeof killAkuma;
     ls: typeof listCatalog;
+    nuke: typeof nukeKeiyaku;
     list: typeof listKeiyaku;
     observe: typeof observeKeiyaku;
     of: typeof keiyakuOf;

package/build/src/library/keiyaku.js

@@ -2,6 +2,7 @@ import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, } f
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
 import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma, } from "./fleet.js";
 import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
@@ -17,6 +18,7 @@ export const Keiyaku = Object.freeze({
     interrupt: interruptAkuma,
     kill: killAkuma,
     ls: listCatalog,
+    nuke: nukeKeiyaku,
     list: listKeiyaku,
     observe: observeKeiyaku,
     of: keiyakuOf,

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

@@ -1,6 +1,7 @@
 import type { ContractHead, ContractId, JournalEntry } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import type { ReconcileReport, RepositoryScope } from "../protocol/operations.js";
+import type { ReconcileReport } from "../protocol/reconcile.js";
+import type { RepositoryScope } from "../protocol/operations.js";
 import type { IntentOutcome } from "../protocol/operations.js";
 import type { AcceptedObligations } from "../protocol/outcome.js";
 import { type SettlementReport } from "../settlement/settle.js";
@@ -30,6 +31,7 @@ type Completion<Value, PublicValue> = Readonly<{
     value: (result: Value) => PublicValue;
     hooks: WorktreeHooks;
 }>;
+export declare function completionInput<Value, PublicValue>(scope: RepositoryScope, channel: GitDecodeChannel, contractId: ContractId, value: (result: Value) => PublicValue, hooks: WorktreeHooks): Omit<Completion<Value, PublicValue>, "accepted">;
 export declare function completeMutation<Value, PublicValue>(input: Completion<Value, PublicValue>): Promise<MutationResult<PublicValue>>;
 export declare function completeHolderMutation<Value, PublicValue, Refusal>(input: Readonly<{
     completion: Omit<Completion<Value, PublicValue>, "accepted">;

package/build/src/library/mutation.js

@@ -1,5 +1,8 @@
 import { deferredTaskHolderSettlement } from "../settlement/settle.js";
 import { completeReconcile } from "./reconcile.js";
+export function completionInput(scope, channel, contractId, value, hooks) {
+    return { scope, channel, contractId, value, hooks };
+}
 export async function completeMutation(input) {
     const { scope, channel, contractId, accepted, value, hooks } = input;
     const report = await completeReconcile({ scope, channel, contractId, hooks, retryHooks: false });

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

@@ -0,0 +1,14 @@
+import type { WorldRoot } from "../world.js";
+export type NukeInput = Readonly<{
+    world: WorldRoot;
+    confirm?: string;
+}>;
+export type NukeResult = Readonly<{
+    kind: "success";
+    world: WorldRoot;
+}> | Readonly<{
+    kind: "failed";
+    world: WorldRoot;
+    diagnostic: string;
+}>;
+export declare function nukeKeiyaku(input: NukeInput): Promise<NukeResult>;

package/build/src/library/nuke.js

@@ -0,0 +1,54 @@
+import { stopAkuma } from "../akuma/nuke.js";
+import { nukeGit } from "../git/nuke.js";
+import { nukeTask } from "../task/operations.js";
+import { KeiyakuRefused } from "./refusal.js";
+import { requireInput, requireMarkdown } from "./input.js";
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function nukeInput(input) {
+    const value = requireInput(input, "nuke input");
+    const world = requireMarkdown(value.world, "world");
+    const confirm = value.confirm === undefined ? undefined : requireMarkdown(value.confirm, "confirm");
+    return { world, ...(confirm === undefined ? {} : { confirm }) };
+}
+export async function nukeKeiyaku(input) {
+    const value = nukeInput(input);
+    if (value.confirm === undefined) {
+        throw new KeiyakuRefused({ kind: "nuke-confirmation-required", world: value.world });
+    }
+    if (value.confirm !== value.world) {
+        throw new KeiyakuRefused({
+            kind: "nuke-confirmation-mismatch",
+            world: value.world,
+            confirmation: value.confirm,
+        });
+    }
+    try {
+        const deleteAkuma = await stopAkuma(value.world);
+        let failed = false;
+        let firstDiagnostic;
+        const attempt = async (owner) => {
+            try {
+                await owner;
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    firstDiagnostic = error;
+                }
+            }
+        };
+        await Promise.all([
+            attempt(deleteAkuma()),
+            attempt(nukeGit(value.world)),
+            attempt(nukeTask(value.world)),
+        ]);
+        if (failed)
+            throw firstDiagnostic;
+        return { kind: "success", world: value.world };
+    }
+    catch (error) {
+        return { kind: "failed", world: value.world, diagnostic: diagnostic(error) };
+    }
+}

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

@@ -1,6 +1,7 @@
 import type { ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { type ReconcileReport, type RepositoryScope } from "../protocol/operations.js";
+import { type ReconcileReport } from "../protocol/reconcile.js";
+import { type RepositoryScope } from "../protocol/operations.js";
 import { type SettlementReport } from "../settlement/settle.js";
 import type { WorktreeHooks } from "./configuration.js";
 import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";

package/build/src/library/reconcile.js

@@ -1,5 +1,7 @@
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { reconcileAllOperation, reconcileObservationFailure, reconcileOperation, stateOperation, worldContractStates, } from "../protocol/operations.js";
+import { reconcileAllOperation, reconcileOperation, worldContractStates, } from "../protocol/reconcile.js";
+import { reconcileObservationFailure } from "../git/reconcile.js";
+import { stateOperation } from "../protocol/operations.js";
 import { settle, settleAll } from "../settlement/settle.js";
 import { projectContractWorktree, } from "../contract-worktree.js";
 import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
@@ -11,6 +13,9 @@ function registerLag(scope, error) {
         diagnostic: error instanceof Error ? error.message : String(error),
     };
 }
+function hereConflict(diagnostic) {
+    throw new AuthorityCorruptionError(diagnostic);
+}
 function emptySettlement() {
     return { actions: [], lags: [] };
 }
@@ -89,7 +94,7 @@ export async function completeReconcile(input) {
         retainTerminalWorktree: true,
         ...appointed,
     });
-    const projection = await projectContractWorktree(input.scope, retained.state, appointment.register);
+    const projection = await projectContractWorktree(input.scope, retained.state, appointment.register, hereConflict);
     const settlement = await settle({
         repository: input.scope,
         channel: input.channel,
@@ -164,7 +169,7 @@ export async function completeRepoReconcile(input) {
         if (releaseEligible(contract.state, report, places.has(contract.contractId))) {
             released.push(contract.contractId);
         }
-        const projection = await projectContractWorktree(input.scope, contract.state, appointed);
+        const projection = await projectContractWorktree(input.scope, contract.state, appointed, hereConflict);
         contracts.push({
             contractId: contract.contractId,
             report: {

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

@@ -6,7 +6,16 @@ export type ContractAppointmentRefusal = Readonly<{
     path: string;
     contract?: ContractId;
 }>;
-export type KeiyakuRefusal = IntentRefusal | ContractAppointmentRefusal;
+export type NukeConfirmationRefusal = Readonly<{
+    kind: "nuke-confirmation-mismatch";
+    world: string;
+    confirmation: string;
+}>;
+export type NukeConfirmationRequiredRefusal = Readonly<{
+    kind: "nuke-confirmation-required";
+    world: string;
+}>;
+export type KeiyakuRefusal = IntentRefusal | ContractAppointmentRefusal | NukeConfirmationRefusal | NukeConfirmationRequiredRefusal;
 export type KeiyakuRetryReason = IntentRetry;
 export declare class KeiyakuRefused extends Error {
     readonly refusal: KeiyakuRefusal;

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

@@ -1,7 +1,7 @@
 import type { ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-import type { ContractDocumentProjection } from "../protocol/operations.js";
+import type { ContractDocumentProjection } from "../protocol/read/documents.js";
 export type RegionOverlap = Readonly<{
     contract: ContractId;
     patterns: readonly Readonly<{

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

@@ -1,10 +1,12 @@
-import { NoGitWorldError, type RepositoryScope } from "../protocol/operations.js";
+import { type RepositoryScope } from "../protocol/operations.js";
+import { NoGitWorldError } from "../git/repository.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type RepoContractReconcileReport, type RepoReconcileReport } from "./reconcile.js";
 export { NoGitWorldError };
 export type { RepoContractReconcileReport, RepoReconcileReport };
 export type RepoAtInput = Readonly<{
     path?: string;
+    gitPath?: string;
 }>;
 export type ReconcileInput = Readonly<{
     hooks?: WorktreeHooks;
@@ -16,6 +18,7 @@ export declare function reconcileInput(input: ReconcileInput | undefined): Reado
 }>;
 export declare class Repo {
     readonly root: string;
+    readonly cwd: string;
     private constructor();
     static at(input?: RepoAtInput): Promise<Repo>;
     currentBranch(): Promise<string | null>;

package/build/src/library/repo.js

@@ -1,12 +1,16 @@
-import { currentBranchOperation, NoGitWorldError, scopeOperation, } from "../protocol/operations.js";
+import { currentBranchOperation, scopeOperation, } from "../protocol/operations.js";
+import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { completeRepoReconcile, } from "./reconcile.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
-async function resolvePinnedScope(path) {
-    return await scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
+async function resolvePinnedScope(path, gitPath) {
+    return await scopeOperation({
+        coordinate: path === undefined ? process.cwd() : path,
+        ...(gitPath === undefined ? {} : { gitPath }),
+    });
 }
 export function reconcileInput(input) {
     const values = input === undefined ? undefined : requireInput(input, "reconcile input");
@@ -20,13 +24,15 @@ export function reconcileInput(input) {
 }
 export class Repo {
     root;
+    cwd;
     constructor(scope) {
         this.root = scope.primaryWorktree;
+        this.cwd = scope.invocationWorktree;
         REPO_SCOPES.set(this, scope);
     }
     static async at(input) {
         const values = input === undefined ? undefined : requireInput(input, "Repo.at input");
-        return new Repo(await resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
+        return new Repo(await resolvePinnedScope(optionalNonblank(values?.path, "repository path"), optionalNonblank(values?.gitPath, "Git executable path")));
     }
     async currentBranch() {
         return await currentBranchOperation({ scope: scopeForRepo(this) });

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

@@ -0,0 +1,9 @@
+import { type AbandonRefusal } from "../core/verbs/abandon.js";
+import type { GitTreeSelection } from "../git/read-observation.js";
+import type { CompanionDecorator } from "./run.js";
+import type { IntentOutcome, MutationOperationInput } from "./operations.js";
+export declare function abandonOperation(input: MutationOperationInput & Readonly<{
+    note?: string;
+    decorateOffer?: CompanionDecorator;
+    observationSelection?: GitTreeSelection;
+}>): Promise<IntentOutcome<void, AbandonRefusal>>;

package/build/src/protocol/abandon.js

@@ -0,0 +1,15 @@
+import { decideAbandon } from "../core/verbs/abandon.js";
+import { admitIntent } from "./intent.js";
+import { complete } from "./outcome.js";
+import { timestamp } from "./operations.js";
+export async function abandonOperation(input) {
+    return complete(await admitIntent(input.channel, input.scope, {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+        ...(input.note === undefined ? {} : { note: input.note }),
+    }, decideAbandon, {
+        ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
+        ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
+    }), undefined);
+}

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

@@ -0,0 +1,16 @@
+import type { AmendData, ContractTerms } from "../core/facts/types.js";
+import { type AmendRefusal } from "../core/verbs/amend.js";
+import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
+import type { MutationOperationInput, IntentOutcome } from "./operations.js";
+type AmendOperationInput = MutationOperationInput & Readonly<{
+    source?: ContractTerms;
+    deriveAmendment?: (source: ContractTerms) => Readonly<{
+        terms: AmendData;
+        verification: VerificationDeclarationPreparation;
+    }>;
+}>;
+type Amendment = Readonly<{
+    source: ContractTerms;
+}> & ReturnType<NonNullable<AmendOperationInput["deriveAmendment"]>>;
+export declare function amendOperation(input: AmendOperationInput): Promise<IntentOutcome<Amendment, AmendRefusal | VerificationDeclarationRefusal>>;
+export {};

package/build/src/protocol/amend.js

@@ -0,0 +1,77 @@
+import { extendContractsForAdmissionAt, observeContractsForAdmissionAt } from "../git/observe.js";
+import { contractState } from "../core/facts/observation.js";
+import { decideAmend } from "../core/verbs/amend.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { admitted } from "./outcome.js";
+import { timestamp } from "./operations.js";
+async function extendPrerequisiteClosureAt(channel, observation, seeds) {
+    let current = observation;
+    const visited = new Set();
+    let pending = [...seeds];
+    while (pending.length > 0) {
+        const batch = [...new Set(pending.filter((id) => !visited.has(id)))];
+        pending = [];
+        if (batch.length === 0)
+            break;
+        current = await extendContractsForAdmissionAt(channel, current, batch);
+        for (const id of batch) {
+            visited.add(id);
+            const state = contractState(current.decision, id);
+            if (state !== null)
+                pending.push(...state.terms.after);
+        }
+    }
+    return current;
+}
+export async function amendOperation(input) {
+    const attempts = mintAttempts({ entryCount: 1 });
+    let source = input.source;
+    for (let index = 0; index < attempts.length; index += 1) {
+        let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+        const state = contractState(observation.decision, input.contractId);
+        if (source === undefined && state !== null)
+            source = state.terms;
+        const amendment = source === undefined || input.deriveAmendment === undefined
+            ? undefined
+            : { source, ...input.deriveAmendment(source) };
+        if (amendment !== undefined) {
+            observation = await extendPrerequisiteClosureAt(input.channel, observation, [...new Set([...(state?.terms.after ?? []), ...amendment.terms.after])]);
+        }
+        const preparation = amendment === undefined
+            ? undefined
+            : amendment.verification.kind === "prepared"
+                ? { kind: "prepared", data: amendment.terms }
+                : { kind: "refused", refusal: amendment.verification.refusal };
+        const decision = decideAmend({
+            input: {
+                contractId: input.contractId,
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                at: timestamp(),
+                ...(amendment === undefined ? {} : { source: amendment.source }),
+                ...(preparation === undefined ? {} : { preparation }),
+            },
+            attempt: attempts[index],
+            observation: observation.decision,
+        });
+        if (decision.kind === "refused")
+            return decision;
+        const admission = await admitDecidedOffer({
+            channel: input.channel,
+            repository: input.scope,
+            decisionObservation: observation,
+            attempt: attempts[index],
+            offer: decision.offer,
+            primaryContract: input.contractId,
+        });
+        if (admission.kind === "accepted") {
+            if (amendment === undefined)
+                throw new Error("accepted amendment is missing its document derivation");
+            return admitted(admission, amendment);
+        }
+        if (admission.kind === "publication-failed")
+            return { kind: "retry", reason: admission };
+        if (admission.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: admission };
+    }
+    return { kind: "retry", reason: { kind: "exhausted" } };
+}