@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/library/fleet.js

@@ -1,19 +1,63 @@
-import { Akuma, } from "../akuma/index.js";
-import { readActionFeedbackStatus, readBudgetedStatus } from "../akuma/akuma.js";
+import { Akuma, AkumaNotBornError, } from "../akuma/index.js";
+import { readBudgetedStatus, tellAkumaWithId } from "../akuma/akuma.js";
+import { injectedBodyRequests, requestBodyKill, requestBodyTell, requestBodyWait, } from "../akuma/requests.js";
 import { readDispatch } from "../dispatch/index.js";
+import { observeTaskBoard } from "../task/operations.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
-function source(path, settings) {
-    return Akuma.of(path, settings);
+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);
 }
-async function statusView(status, repo) {
-    const contractId = await contractFor(repo, status.id);
-    return contractId === undefined ? { status } : { status, contractId };
+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 observationDiagnostic(error);
+}
+async function createdTasksFor(path, statuses) {
+    let board;
+    try {
+        board = await observeTaskBoard(path);
+    }
+    catch (error) {
+        const failed = { kind: "failed", diagnostic: createdTaskDiagnostic(error) };
+        return statuses.map(() => failed);
+    }
+    return statuses.map((status) => ({ kind: "present", rows: board.selectCreatedBy(status.id) }));
+}
+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) => ({
+        status,
+        contract: await dispatchAssociation(repo, status.id),
+        createdTasks: created[index],
+    })));
 }
 function timeout(value) {
     if (value === undefined)
@@ -23,28 +67,142 @@ function timeout(value) {
     }
     return value;
 }
-function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+function delay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(signal?.reason ?? new Error("upstream request aborted"));
+        };
+        timer = setTimeout(done, milliseconds);
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+    });
 }
 const SHARED_ORDINARY_BUDGET = 30;
-async function observeWaitStatuses(path, ids, settings) {
+async function observeWaitRound(path, ids, signal) {
+    signal?.throwIfAborted();
     if (ids.length <= 1) {
-        return await Promise.all(ids.map(async (id) => await source(path, settings).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) {
-        const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
-        statuses.push(observed.status);
-        remaining -= observed.ordinarySelected;
+        signal?.throwIfAborted();
+        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 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(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);
+    }
+}
+export async function executeTellAkuma(input) {
+    input.signal?.throwIfAborted();
+    const handle = source(input.path).of({ id: input.id });
+    const tell = input.tellId === undefined
+        ? await handle.tell(input.body)
+        : await tellAkumaWithId(input.path, input.id, input.body, input.tellId, input.recordedAt);
+    input.signal?.throwIfAborted();
+    return {
+        akuma: input.id,
+        tell,
+        observation: await observeAkumaStage(input.path, input.id, input.repo),
+    };
+}
+export async function executeKillAkuma(input) {
+    input.signal?.throwIfAborted();
+    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();
+    return {
+        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) {
+    if (outcome.kind === "returned")
+        return outcome.result;
+    if (outcome.failure.kind === "akuma-not-born")
+        throw new AkumaNotBornError(outcome.failure.id);
+    throw new Error(outcome.failure.diagnostic);
+}
+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;
+    return { ...observation, ...(await attachObservationContract(repo, observation)) };
+}
+async function attachWaitContracts(repo, result) {
+    return repo === undefined
+        ? result
+        : {
+            ...result,
+            observations: await Promise.all(result.observations.map((observation) => attachObservationContract(repo, observation))),
+        };
+}
+async function attachTellContract(repo, result) {
+    return repo === undefined ? result : { ...result, observation: await attachObservationStage(repo, result.observation) };
+}
+async function attachKillContracts(repo, result) {
+    return repo === undefined
+        ? result
+        : {
+            ...result,
+            results: await Promise.all(result.results.map(async (entry) => ({
+                ...entry,
+                observation: await attachObservationStage(repo, entry.observation),
+            }))),
+        };
 }
 function directAddress(values) {
     return {
         path: values.path,
         akuma: values.akuma,
-        ...(values.settings === undefined ? {} : { settings: values.settings }),
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
@@ -52,18 +210,17 @@ function setAddress(values) {
     return {
         path: values.path,
         akuma: values.akuma,
-        ...(values.settings === undefined ? {} : { settings: values.settings }),
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
 export async function statusAkuma(input) {
     const addressed = await addressAkuma(input);
-    return await statusView(await source(addressed.path, addressed.settings).of({ id: addressed.id }).status(), input.repo);
+    return await observeAkuma(await source(addressed.path).of({ id: addressed.id }).status(), addressed.path, input.repo);
 }
 export async function waitAkuma(input) {
     const values = requireInput(input, "Keiyaku.wait input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "repo", "completion", "timeoutMs"].includes(key)) {
+        if (!["path", "akuma", "repo", "completion", "timeoutMs"].includes(key)) {
             throw new TypeError(`Keiyaku.wait input has unknown field: ${key}`);
         }
     }
@@ -72,82 +229,105 @@ export async function waitAkuma(input) {
     if (addressed.ids.length > 1 && completion !== "any" && completion !== "all") {
         throw new TypeError("completion must be any or all when waiting for multiple Akuma");
     }
-    if (completion !== undefined && completion !== "any" && completion !== "all")
+    if (completion !== undefined && completion !== "any" && completion !== "all") {
         throw new TypeError("completion must be any or all");
+    }
     const selected = completion ?? "all";
     const timeoutMs = timeout(values.timeoutMs);
-    const deadline = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
-    for (;;) {
-        const statuses = await observeWaitStatuses(addressed.path, addressed.ids, addressed.settings);
-        const settled = statuses.map((status) => status.life !== "running");
-        if ((selected === "any" ? settled.some(Boolean) : settled.every(Boolean))
-            || (deadline !== undefined && performance.now() >= deadline)) {
-            return { completion: selected, statuses: await Promise.all(statuses.map(async (status) => await statusView(status, values.repo))) };
-        }
-        await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())));
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyWait({
+            directory: requests,
+            targets: addressed.ids,
+            completion: selected,
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        });
+        return await attachWaitContracts(values.repo, upstreamResult(outcome));
     }
+    return await executeWaitAkuma({
+        path: addressed.path,
+        ids: addressed.ids,
+        completion: selected,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    });
 }
 export async function killAkuma(input) {
     const addressed = await addressAkumaSet(input);
-    const handles = addressed.ids.map((id) => source(addressed.path, addressed.settings).of({ id }));
-    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
-    const observations = await Promise.all(addressed.ids.map(async (id) => await statusView(await readActionFeedbackStatus(addressed.path, id), input.repo)));
-    return {
-        results: addressed.ids.map((id, index) => ({
-            id,
-            evidence: evidence[index],
-            observation: observations[index],
-        })),
-    };
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyKill({ directory: requests, targets: addressed.ids });
+        return await attachKillContracts(input.repo, upstreamResult(outcome));
+    }
+    return await executeKillAkuma({
+        path: addressed.path,
+        ids: addressed.ids,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+    });
 }
 export async function tellAkuma(input) {
     const values = requireInput(input, "Keiyaku.tell input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+        if (!["path", "akuma", "body", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.tell input has unknown field: ${key}`);
+        }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
-    const tell = await handle.tell(values.body);
-    return { akuma: addressed.id, tell, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyTell({
+            directory: requests,
+            target: addressed.id,
+            body: values.body,
+        });
+        return await attachTellContract(values.repo, upstreamResult(outcome));
+    }
+    return await executeTellAkuma({
+        path: addressed.path,
+        id: addressed.id,
+        body: values.body,
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    });
 }
 export async function interruptAkuma(input) {
     const values = requireInput(input, "Keiyaku.interrupt input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+        if (!["path", "akuma", "body", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.interrupt input has unknown field: ${key}`);
+        }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const addressed = await addressAkuma(directAddress(values));
-    const receipt = await source(addressed.path, addressed.settings).of({ id: addressed.id }).interrupt(values.body);
-    return { id: addressed.id, receipt, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    const handle = source(addressed.path).of({ id: addressed.id });
+    const receipt = await handle.interrupt(values.body);
+    const observation = await observeAkumaStage(addressed.path, addressed.id, values.repo);
+    return { id: addressed.id, receipt, observation };
 }
 export async function historyAkuma(input) {
     const values = requireInput(input, "Keiyaku.history input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "before", "since", "limit", "last", "repo"].includes(key)) {
+        if (!["path", "akuma", "before", "since", "limit", "last", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.history input has unknown field: ${key}`);
         }
     }
     if (values.last !== undefined && typeof values.last !== "boolean")
         throw new TypeError("last must be a boolean");
     const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
+    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;
@@ -91,6 +86,7 @@ export function contractTerms(document, gates, after) {
 export function documentDerivation(document, gates, contractId) {
     return {
         document: document.document.key,
+        bytes: document.document.bytes,
         title: document.title,
         verification: prepareVerificationDeclaration({
             gates,

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

@@ -5,10 +5,9 @@ import { listCatalog } from "./catalog.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, } from "./configuration.js";
-export { worktreeHooksFrom } from "../git/hooks.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, 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, 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";
@@ -20,9 +19,10 @@ export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
 export type { AkumaAlias } from "../identity/selector.js";
 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 { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
-export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaStatusView, AkumaTellInput, 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;

package/build/src/library/keiyaku.js

@@ -5,8 +5,7 @@ import { listCatalog } from "./catalog.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, } from "./configuration.js";
-export { worktreeHooksFrom } from "../git/hooks.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
 export const Keiyaku = Object.freeze({
     prototype: KeiyakuHandle.prototype,

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";

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";

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;

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");
@@ -26,7 +30,7 @@ export class Repo {
     }
     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 {};