@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/git/repository.js

@@ -1,8 +1,7 @@
-import { spawn } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { consumeProcessStdout } from "../runtime/proc/run.js";
 import { gitObjectId } from "./identity.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
 import { parseTreeObject, prepareTreeUpdate, treeUpdate, validPath, } from "./tree.js";
 export const GIT_REF = "refs/heads/keiyaku-state";
 export const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
@@ -25,21 +24,6 @@ export class NoGitWorldError extends Error {
         this.path = path;
     }
 }
-export class GitPlumbingError extends Error {
-    stdout;
-    stderr;
-    status;
-    pid;
-    constructor(input) {
-        super(input.message);
-        this.name = "GitPlumbingError";
-        this.stdout = Buffer.from(input.stdout ?? "");
-        this.stderr = Buffer.from(input.stderr);
-        this.status = input.status;
-        this.pid = input.pid ?? null;
-    }
-}
-const GIT_STDERR_BYTES = 16 * 1024;
 function worktreesFromPorcelain(output) {
     const fields = output.toString("utf8").split("\0");
     const worktrees = [];
@@ -79,20 +63,24 @@ export async function registeredWorktrees(repository) {
 export async function registeredWorktreePaths(repository) {
     return (await registeredWorktrees(repository)).map((worktree) => worktree.path);
 }
-export async function repositoryAt(cwd) {
+export async function repositoryAt(cwd, gitPath = "git") {
     if (typeof cwd !== "string" || cwd.length === 0) {
         throw new Error("repository path must be a nonempty string");
     }
     const effectiveCwd = resolve(cwd);
     const provisional = {
+        gitPath,
         effectiveCwd,
+        invocationWorktree: effectiveCwd,
         primaryWorktree: effectiveCwd,
         commonDirectory: effectiveCwd,
     };
+    let invocationWorktree;
     let primaryWorktree;
     let commonDirectory;
     try {
         primaryWorktree = (await registeredWorktreePaths(provisional))[0];
+        invocationWorktree = await worktreeRoot(provisional);
         commonDirectory = await absoluteGitPath(provisional, ["--git-common-dir"], "common Git directory");
     }
     catch (error) {
@@ -101,7 +89,7 @@ export async function repositoryAt(cwd) {
         }
         throw error;
     }
-    return { effectiveCwd, primaryWorktree, commonDirectory };
+    return { gitPath, effectiveCwd, invocationWorktree, primaryWorktree, commonDirectory };
 }
 async function absoluteGitPath(repository, args, label) {
     const value = (await runGit(repository, ["rev-parse", "--path-format=absolute", ...args])).toString("utf8").trim();
@@ -119,83 +107,6 @@ export async function worktreeGitDirectory(repository, worktree) {
 export async function worktreeRoot(repository) {
     return await absoluteGitPath(repository, ["--show-toplevel"], "worktree root");
 }
-function commandError(command, error) {
-    const candidate = error;
-    const stderr = candidate.stderr === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stderr);
-    const stdout = candidate.stdout === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stdout);
-    const detail = stderr.length === 0 ? candidate.message ?? "git command failed" : stderr.toString("utf8");
-    return new GitPlumbingError({
-        stdout,
-        stderr,
-        status: candidate.status ?? null,
-        message: `${command.join(" ")}: ${detail}`,
-        pid: candidate.pid ?? null,
-    });
-}
-async function executeGit(repository, args, input, environment) {
-    const stdout = [];
-    const stderr = [];
-    let stderrBytes = 0;
-    let inputError;
-    const child = spawn("git", [...args], {
-        cwd: repository.effectiveCwd,
-        ...(environment === undefined ? {} : { env: { ...process.env, ...environment } }),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-    });
-    child.stdout.on("data", (chunk) => stdout.push(chunk));
-    child.stderr.on("data", (chunk) => {
-        if (stderrBytes >= GIT_STDERR_BYTES)
-            return;
-        const retained = chunk.subarray(0, GIT_STDERR_BYTES - stderrBytes);
-        stderr.push(retained);
-        stderrBytes += retained.length;
-    });
-    child.stdin.on("error", (error) => { inputError = error; });
-    child.stdin.end(input);
-    const terminal = await new Promise((resolveTerminal) => {
-        child.once("error", (error) => resolveTerminal({ code: null, error }));
-        child.once("close", (code) => resolveTerminal({ code }));
-    });
-    const output = Buffer.concat(stdout);
-    if (terminal.code === 0 && inputError === undefined)
-        return output;
-    throw commandError(args, {
-        message: terminal.error?.message ?? inputError?.message ?? `git exited with status ${terminal.code ?? "unknown"}`,
-        stdout: output,
-        stderr: Buffer.concat(stderr),
-        status: terminal.code,
-        pid: child.pid,
-    });
-}
-export async function runGit(repository, args, input) {
-    return await executeGit(repository, args, input);
-}
-export async function consumeGitStdout(repository, args, consume) {
-    const result = await consumeProcessStdout({
-        argv: ["git", ...args],
-        cwd: repository.effectiveCwd,
-    }, consume);
-    const { outcome } = result;
-    if (outcome.kind === "terminal" && outcome.code === 0)
-        return;
-    const status = outcome.kind === "terminal" ? outcome.code : null;
-    const stderr = outcome.kind === "terminal" ? outcome.stderr : "";
-    const message = outcome.kind === "terminal"
-        ? `git exited with status ${outcome.code}`
-        : outcome.kind === "spawn-error" || outcome.kind === "stream-error"
-            ? outcome.diagnostic
-            : `git process ended with ${outcome.kind}`;
-    throw commandError(args, {
-        message,
-        stderr,
-        status,
-        pid: result.pid ?? undefined,
-    });
-}
-export async function runGitWithEnvironment(repository, args, input, environment) {
-    return await executeGit(repository, args, input, environment);
-}
 function assertOid(oid, label) {
     gitObjectId(oid, label);
 }
@@ -282,28 +193,6 @@ export async function readGitPaths(repository, requestedPaths) {
     await validateGitFormat(repository, paths);
     return { commit, tree, paths };
 }
-/** Add paths from the same immutable Git tree without rereading its ref. */
-export async function extendGitPaths(repository, snapshot, requestedPaths) {
-    for (const path of requestedPaths)
-        validPath(path);
-    if (snapshot.tree === null || requestedPaths.length === 0)
-        return snapshot;
-    const additions = parseTreeEntries(await runGit(repository, [
-        "ls-tree",
-        "-z",
-        "--full-tree",
-        snapshot.tree,
-        "--",
-        ...requestedPaths,
-    ]));
-    return { ...snapshot, paths: new Map([...snapshot.paths, ...additions]) };
-}
-/** Expand a targeted immutable snapshot to its complete already-pinned tree. */
-export async function expandGitSnapshot(repository, snapshot) {
-    if (snapshot.tree === null)
-        return snapshot;
-    return { ...snapshot, paths: await readTreeEntries(repository, snapshot.tree) };
-}
 export async function writeBlob(repository, bytes) {
     const oid = (await runGit(repository, ["hash-object", "-w", "--stdin"], bytes)).toString("utf8").trim();
     assertOid(oid, "written blob");

package/build/src/git/scratch.d.ts

@@ -1,5 +1,5 @@
 import type { SnapshotId } from "../core/facts/types.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type MaterializedScratchCandidate = Readonly<{
     cwd: string;
     dispose: () => Promise<WorktreeLeak | null>;

package/build/src/git/scratch.js

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { tryAcquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { gitObjectIdForSnapshot } from "./identity.js";
-import { runGit } from "./repository.js";
+import { runGit } from "./process.js";
 const SCRATCH_PREFIX = "keiyaku-v4-verify-";
 const SCRATCH_ROOT = await realpath(tmpdir());
 const SCRATCH_PATTERN = /^keiyaku-v4-verify-([0-9a-f]{24})$/;

package/build/src/git/target-placement.d.ts

@@ -1,7 +1,7 @@
 import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
 import type { RefOperation } from "../core/facts/offer.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type WorkspaceNotOnTargetRefusal = Readonly<{
     kind: "workspace-not-on-target";
     contractId: ContractId;
@@ -58,6 +58,7 @@ export type TargetPlacementObservationInput = Readonly<{
     coordinates: TargetedContractCoordinates;
     predecessor: SnapshotId;
     candidate: SnapshotId;
+    hereWorkspacePath?: string;
 }>;
 export type TargetPlacementObservation = Readonly<{
     kind: "ready";
@@ -86,7 +87,7 @@ export type AuditTargetAnswer = Readonly<{
 }>;
 /** Adjudicate the complete post-Verification audit target answer without placing. */
 export declare function adjudicateAuditTarget(repository: GitRepository, input: TargetPlacementObservationInput): Promise<AuditTargetAnswer>;
-export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation): Promise<TargetPlacementPreparation>;
+export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation, hereWorkspacePath?: string): Promise<TargetPlacementPreparation>;
 export declare function followTargetPlacement(repository: GitRepository, prepared: PreparedTargetPlacement): Promise<TargetPlacementPhysicalResult>;
 export declare function recoverTargetPlacement(repository: GitRepository, state: ContractState): Promise<TargetPlacementPhysicalResult>;
 export {};

package/build/src/git/target-placement.js

@@ -3,7 +3,8 @@ import { resolve } from "node:path";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { gitObjectId, gitObjectIdForSnapshot, gitRefLocator, mintSnapshotId } from "./identity.js";
 import { currentBranch } from "./observe.js";
-import { commonGitDirectory, consumeGitStdout, GitPlumbingError, readRef, registeredWorktrees, runGit, } from "./repository.js";
+import { commonGitDirectory, readRef, registeredWorktrees, } from "./repository.js";
+import { consumeGitStdout, GitPlumbingError, runGit, } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export async function observeTargetHead(repository, target) {
     const value = await readRef(repository, target);
@@ -162,9 +163,6 @@ async function indexMatchesTreeOnPaths(repository, path, tree, paths) {
 async function workspaceMatchesTreeOnPaths(repository, path, tree, workspaceTree, paths) {
     return (await gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths])).length === 0;
 }
-async function sourceWorktree(repository) {
-    return resolve((await runGit(repository, ["rev-parse", "--show-toplevel"])).toString("utf8").trim());
-}
 async function ordinaryPrecheck(repository, contractId, target, path) {
     const predecessor = gitObjectIdForSnapshot(target.expectedOid);
     const candidate = gitObjectIdForSnapshot(target.newOid);
@@ -201,7 +199,7 @@ export async function observeTargetPlacement(repository, input) {
     const worktrees = (await registeredWorktrees(repository))
         .filter((worktree) => worktree.branch === target.target)
         .sort((left, right) => left.path.localeCompare(right.path));
-    const hereSource = input.coordinates.workspace === "here" ? await sourceWorktree(repository) : null;
+    const hereSource = input.coordinates.workspace === "here" ? input.hereWorkspacePath ?? null : null;
     if (hereSource !== null) {
         const branch = await currentBranch(repository, hereSource);
         if (branch !== target.target) {
@@ -226,9 +224,10 @@ export async function observeTargetPlacement(repository, input) {
         }
         arms.push({ kind, path: worktree.path });
     }
-    if (hereSource !== null && !arms.some((arm) => arm.kind === "here")) {
+    if (input.coordinates.workspace === "here" && hereSource === null)
+        throw new Error("targeted here workspace is unappointed");
+    if (hereSource !== null && !arms.some((arm) => arm.kind === "here"))
         throw new Error("targeted here workspace is not a registered checkout of its target");
-    }
     return { kind: "ready", arms };
 }
 /** Adjudicate the complete post-Verification audit target answer without placing. */
@@ -253,8 +252,8 @@ export async function adjudicateAuditTarget(repository, input) {
         return { kind: "failed", diagnostic: error.message };
     }
 }
-export async function prepareTargetPlacement(repository, state, target) {
-    if (state.coordinates.target !== target.target || state.delivery?.data.integration.snapshot !== target.newOid) {
+export async function prepareTargetPlacement(repository, state, target, hereWorkspacePath) {
+    if (state.coordinates.target !== target.target || state.currentIntegration?.snapshot !== target.newOid) {
         throw new Error("placement state does not match its offered target movement");
     }
     const observation = await observeTargetPlacement(repository, {
@@ -262,6 +261,7 @@ export async function prepareTargetPlacement(repository, state, target) {
         coordinates: { ...state.coordinates, target: target.target },
         predecessor: target.expectedOid,
         candidate: target.newOid,
+        ...(hereWorkspacePath === undefined ? {} : { hereWorkspacePath }),
     });
     return observation.kind === "refused"
         ? observation
@@ -340,10 +340,11 @@ export async function recoverTargetPlacement(repository, state) {
     const delivery = state.delivery;
     if (state.terminal?.kind !== "claimed" || target === undefined || delivery === null)
         return { effects: [], lag: [] };
-    if (await readRef(repository, target) !== delivery.data.integration.snapshot)
+    const integration = state.currentIntegration;
+    if (integration === null || await readRef(repository, target) !== integration.snapshot)
         return { effects: [], lag: [] };
-    const candidateTree = await commitTree(repository, delivery.data.integration.snapshot);
-    const predecessorTree = await commitTree(repository, delivery.data.integration.predecessor);
+    const candidateTree = await commitTree(repository, integration.snapshot);
+    const predecessorTree = await commitTree(repository, integration.predecessor);
     const worktrees = (await registeredWorktrees(repository))
         .filter((worktree) => worktree.branch === target)
         .sort((left, right) => left.path.localeCompare(right.path));
@@ -354,8 +355,8 @@ export async function recoverTargetPlacement(repository, state) {
             const recovery = await recoverCheckout({
                 repository,
                 path: worktree.path,
-                predecessor: delivery.data.integration.predecessor,
-                candidate: delivery.data.integration.snapshot,
+                predecessor: integration.predecessor,
+                candidate: integration.snapshot,
                 predecessorTree,
                 candidateTree,
             });

package/build/src/git/tender.d.ts

@@ -1,12 +1,13 @@
 import type { Preparation } from "../core/decide.js";
 import type { ActorId, ContractCoordinates, ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export type TenderCaptureCoordinates = Readonly<{
     contractId: ContractId;
     coordinates: ContractCoordinates;
     place?: string;
+    workspacePath?: string;
 }>;
 export type TenderCaptureRefusal = Readonly<{
     kind: "worktree-missing";

package/build/src/git/tender.js

@@ -1,6 +1,7 @@
 import { access } from "node:fs/promises";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { decodeGitNumstat, GitPlumbingError, registeredWorktreePaths, runGit, runGitWithEnvironment, } from "./repository.js";
+import { decodeGitNumstat, registeredWorktreePaths, } from "./repository.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment, } from "./process.js";
 import { captureWorkspaceTree, worktreePath } from "./workspace.js";
 async function workspaceExists(repository, workspace, path) {
     const exists = await access(path).then(() => true, () => false);
@@ -8,8 +9,8 @@ async function workspaceExists(repository, workspace, path) {
         || (exists && (await registeredWorktreePaths(repository)).includes(path));
 }
 function workspaceFor(repository, input) {
-    if (input.coordinates.workspace === "here")
-        return repository.effectiveCwd;
+    if (input.workspacePath !== undefined)
+        return input.workspacePath;
     return input.place === undefined ? undefined : worktreePath(repository, input.place);
 }
 /** Capture the complete workspace tree through Git's private index mechanics. */

package/build/src/git/terminal-seal.d.ts

@@ -1,6 +1,7 @@
 import type { ContractState, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitOid, type GitRepository } from "./repository.js";
+import type { GitOid } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export type UnsealedBytes = Readonly<{
     kind: "unsealed-bytes";
@@ -33,6 +34,5 @@ export type TerminalWorkspaceObservation = Readonly<{
 export declare function terminalSealSnapshots(state: ContractState): readonly SnapshotId[];
 export declare function terminalSealExpectations(state: ContractState, objects: ReadonlyMap<GitOid, TerminalSealObject>): TerminalSealExpectations;
 export declare function unsealedWorkspaceBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations, workspace: WorkspaceTree): Promise<UnsealedBytes | null>;
-export declare function unsealedBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<UnsealedBytes | null>;
 export declare function observeTerminalWorkspace(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<TerminalWorkspaceObservation>;
 export {};

package/build/src/git/terminal-seal.js

@@ -1,12 +1,12 @@
 import { gitObjectId, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { runGit } from "./repository.js";
+import { runGit } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export function terminalSealSnapshots(state) {
     return [...new Set([
             state.coordinates.start,
             ...(state.delivery === null ? [] : [
                 state.delivery.data.tenderSnapshot,
-                state.delivery.data.integration.snapshot,
+                ...(state.currentIntegration === null ? [] : [state.currentIntegration.snapshot]),
             ]),
         ])];
 }
@@ -51,7 +51,7 @@ export function terminalSealExpectations(state, objects) {
                 state.coordinates.start,
                 ...(tenderParent === undefined ? [] : [tenderParent]),
                 tender,
-                state.delivery.data.integration.snapshot,
+                state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot,
             ])],
         trees: [...treeBySnapshot.values()],
         treeBySnapshot,
@@ -86,9 +86,6 @@ export async function unsealedWorkspaceBytes(repository, path, expected, workspa
         ...(headIsSealed ? {} : { head: workspace.head }),
     };
 }
-export async function unsealedBytes(repository, path, expected) {
-    return (await observeTerminalWorkspace(repository, path, expected)).unsealed;
-}
 export async function observeTerminalWorkspace(repository, path, expected) {
     const captured = await captureWorkspaceTree(repository, path);
     return {

package/build/src/git/workspace.d.ts

@@ -1,6 +1,6 @@
 import type { SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type WorkspaceChanges = Readonly<{
     staged: readonly string[];
     unstaged: readonly string[];
@@ -39,6 +39,9 @@ export type ContractWorkspaceObservation = Readonly<{
     location: ContractWorkspaceLocation;
 }> | Readonly<{
     kind: "unappointed";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
 }>;
 export type ContractTargetLag = Readonly<{
     kind: "counted";

package/build/src/git/workspace.js

@@ -2,7 +2,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { gitObjectId, mintSnapshotId } from "./identity.js";
-import { runGit, runGitWithEnvironment } from "./repository.js";
+import { runGit, runGitWithEnvironment } from "./process.js";
 const WORKTREE_DIRECTORY = ["keiyaku", "wt"];
 export function worktreePath(repository, place) {
     return resolve(repository.commonDirectory, ...WORKTREE_DIRECTORY, place);

package/build/src/index.d.ts

@@ -1,6 +1,5 @@
-export { AuthorityCorruptionError, AkumaWorldScopeError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export * from "./library/keiyaku.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";
 export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";
-export type { AttestationVerdict, AbandonInput, ActorId, AkuId, AllowedAction, AllowedActions, AkumaAddressInput, AkumaAlias, AkumaGlob, AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaSetAddressInput, AkumaStatus, AkumaTellInput, CreatedTaskObservation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, AkumaWorldScopeRefusal, AliasBinding, AliasStage, AmendResult, AmendInput, ArcInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, CallInput, CallObservation, CallResult, Catalog, CatalogInput, CatalogQuery, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, Dispatch, DispatchFailure, DispatchStage, DirectAkumaSelector, Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, ForkInput, ForkResult, IntegrationFailure, Lag, MutationResult, PlacementStop, RegionOverlap, ReconcileInput, RepoReconcileReport, Review, ReconcileReport, ReviewInput, RepoAtInput, AuditInput, SnapshotId, SettlementAction, SettlementLag, SettlementReport, SetAkumaSelector, TaskId, TopologyEffect, VerificationReuse, VerificationStop, WorktreeHooks, } from "./library/keiyaku.js";

package/build/src/index.js

@@ -1,3 +1,3 @@
-export { AuthorityCorruptionError, AkumaWorldScopeError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export * from "./library/keiyaku.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";

package/build/src/kanshi/read.js

@@ -1,5 +1,6 @@
 import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
+import { resolveHereContractWorkspace } from "../contract-worktree.js";
 import { observeTaskBoard } from "../task/operations.js";
 import { contractNamespace } from "../settlement/settle.js";
 import { Akuma } from "../akuma/index.js";
@@ -123,7 +124,10 @@ async function readBranch(repo) {
 }
 async function readContracts(observation, selected) {
     try {
-        return { kind: "present", value: await readContractBoard(observation, selected) };
+        return {
+            kind: "present",
+            value: await readContractBoard(observation, selected, async (id) => await resolveHereContractWorkspace(observation.repository, id)),
+        };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };

package/build/src/library/address.js

@@ -116,7 +116,13 @@ function addSelectorIds(selector, sources, selected, contractMembers) {
     selected.add(selector.value);
 }
 async function contractMemberInWorld(path, id) {
-    return await probeBornAkuma(path, id);
+    try {
+        return await probeBornAkuma(path, id);
+    }
+    catch {
+        // A dispatched physical member remains selected when its Heart cannot be read.
+        return true;
+    }
 }
 async function refuseForeignContractMembers(path, ids, contractMembers) {
     const foreign = [];

package/build/src/library/akuma-creation.d.ts

@@ -40,6 +40,7 @@ export type CallInput = Readonly<{
     archetype: string;
     body: string;
     cwd?: string;
+    readonly?: true;
     mode?: "wait" | "detach";
     timeoutMs?: number;
     home?: string;

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

@@ -59,6 +59,11 @@ function callMode(value) {
         return "detach";
     throw new TypeError("mode must be wait or detach");
 }
+function callReadonly(value) {
+    if (value === undefined || value === true)
+        return value;
+    throw new TypeError("readonly must be true");
+}
 function callTimeout(value, mode) {
     if (mode === "detach" && value !== undefined) {
         throw new TypeError("timeoutMs is not valid in detach mode");
@@ -162,10 +167,11 @@ async function resolveCallExecution(input) {
 }
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "home", "settings", "contract", "alias", "allowed"], "Keiyaku.call input");
+    onlyKeys(values, ["path", "archetype", "body", "cwd", "readonly", "mode", "timeoutMs", "home", "settings", "contract", "alias", "allowed"], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
+    const readonlyRequested = callReadonly(values.readonly);
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
     const timeoutMs = callTimeout(values.timeoutMs, mode);
@@ -184,6 +190,7 @@ export async function callKeiyaku(input) {
     const call = {
         archetype,
         body,
+        ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
     };

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

@@ -1,5 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
-import { type AuditReport, type RepositoryScope } from "../protocol/operations.js";
+import { type AuditReport } from "../protocol/audit.js";
+import type { RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{
@@ -15,4 +16,5 @@ export declare function auditContract(input: Readonly<{
     scope: RepositoryScope;
     contractId: ContractId;
     input?: AuditInput;
+    resolveHereWorkspace?: (contractId: ContractId) => Promise<string | undefined>;
 }>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

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

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

@@ -1,6 +1,7 @@
 import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { bindOperation, type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
+import type { IntentOutcome, RepositoryScope } from "../protocol/operations.js";
 import type { TaskId } from "../task/identity.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
 import type { KeiyakuRefusal } from "./refusal.js";

package/build/src/library/bind.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { releaseContractWorktree, reserveContractWorktree, withContractWorktreeAppointment, } from "../contract-worktree.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
-import { bindOperation } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
 import { claimTaskHolder } from "../settlement/holder.js";
 function candidateId(title, collision) {
     const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });

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

@@ -4,7 +4,7 @@ export type { HookCommand, WorktreeHooks } from "../git/hooks.js";
 export type Gate = string;
 export type GatesFromInput = Readonly<{
     settings: Settings;
-    name?: string;
+    names?: readonly string[];
 }>;
 export type RequireBranchesToBeUpToDateFromInput = Readonly<{
     settings: Settings;