@astrosheep/keiyaku 4.0.3 → 4.0.5

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[];
@@ -10,6 +10,7 @@ export type WorkspaceChanges = Readonly<{
 export type WorkspaceTree = Readonly<{
     tree: GitObjectId;
     head: SnapshotId;
+    at: string;
     dirty: boolean;
     changes: WorkspaceChanges;
 }>;

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);
@@ -114,24 +114,32 @@ export async function observeTargetLag(repository, workspace, head) {
 }
 /** Capture tracked and untracked workspace bytes without changing its real index. */
 export async function captureWorkspaceTree(repository, workspace) {
-    const identities = (await runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T", "HEAD"]))
+    const identities = (await runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
         .toString("utf8")
         .split("\n");
-    if (identities.length !== 3 || identities[0] === undefined || identities[1] === undefined || identities[2] !== "") {
-        throw new Error("workspace HEAD/tree resolution did not return exactly two object IDs");
+    if (identities.length !== 4
+        || identities[0] === undefined
+        || identities[1] === undefined
+        || identities[2] === undefined
+        || identities[3] !== "") {
+        throw new Error("workspace HEAD/tree/time resolution returned an unexpected shape");
     }
     const head = mintSnapshotId(identities[0]);
     const tree = gitObjectId(identities[1], "workspace tree");
+    const at = identities[2];
+    if (Number.isNaN(Date.parse(at)))
+        throw new Error("workspace HEAD has an invalid committer timestamp");
     const changes = await workspaceChanges(repository, workspace);
     const dirty = changes.staged.length > 0 || changes.unstaged.length > 0 || changes.untracked.length > 0;
     if (!dirty)
-        return { tree, head, dirty, changes };
+        return { tree, head, at, dirty, changes };
     return await withPrivateGitIndex(async (environment) => {
         await runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
         await runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
         return {
             tree: gitObjectId((await runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment)).toString("utf8").trim(), "workspace tree"),
             head,
+            at,
             dirty,
             changes,
         };

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, AkumaAddressInput, AkumaAlias, AkumaGlob, AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaSetAddressInput, AkumaStatus, AkumaStatusView, AkumaTellInput, 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, 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/index.d.ts

@@ -1,4 +1,4 @@
-export { kanshi } from "./read.js";
+export { kanshi, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";
 export type { KanshiInput } from "./read.js";
 export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionIntersection, RegionPathMatch, RegionRead, } from "./report.js";

package/build/src/kanshi/index.js

@@ -1,2 +1,2 @@
-export { kanshi } from "./read.js";
+export { kanshi, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";

package/build/src/kanshi/read.d.ts

@@ -1,9 +1,17 @@
 import { Repo } from "../library/repo.js";
-import type { KanshiReport, KanshiRegionSelection } from "./report.js";
+import type { ContractBoard } from "../library/contract.js";
+import { type AliasBinding } from "../alias/index.js";
+import type { KanshiReport, Section, KanshiRegionSelection } from "./report.js";
 import type { WorldRoot } from "../world.js";
 export type KanshiInput = Readonly<{
     world: WorldRoot | null;
     repo?: Repo;
     region?: KanshiRegionSelection;
+    contract?: ContractBoard["rows"][number]["id"];
 }>;
+export type KanshiObservation = Readonly<{
+    report: KanshiReport;
+    aliases: Section<readonly AliasBinding[]>;
+}>;
+export declare function observeKanshi(input: KanshiInput): Promise<KanshiObservation>;
 export declare function kanshi(input: KanshiInput): Promise<KanshiReport>;

package/build/src/kanshi/read.js

@@ -1,6 +1,7 @@
 import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
-import { observeTaskStatusRows } from "../task/operations.js";
+import { observeTaskBoard } from "../task/operations.js";
+import { contractNamespace } from "../settlement/settle.js";
 import { Akuma } from "../akuma/index.js";
 import { readAliases } from "../alias/index.js";
 import { readDispatchesAt } from "../dispatch/index.js";
@@ -10,7 +11,7 @@ import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observ
 import { readDocuments } from "../protocol/read/documents.js";
 import { readRegionDeclarations, validateRegionPath } from "../library/region.js";
 import { contractId } from "../core/facts/types.js";
-import { selectRegion } from "./select.js";
+import { selectKanshi, selectRegion } from "./select.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -85,15 +86,21 @@ function regionSelection(value) {
 function coordinate(input) {
     if (typeof input !== "object" || input === null || Array.isArray(input))
         throw new TypeError("kanshi input must be an object");
-    for (const key of Object.keys(input))
-        if (key !== "world" && key !== "repo" && key !== "region")
+    for (const key of Object.keys(input)) {
+        if (!["world", "repo", "region", "contract"].includes(key)) {
             throw new TypeError(`kanshi input has unknown field: ${key}`);
+        }
+    }
     if (input.world !== null && (typeof input.world !== "string" || input.world.trim().length === 0)) {
         throw new TypeError("kanshi world must be a WorldRoot or null");
     }
     if (input.repo !== undefined && !(input.repo instanceof Repo))
         throw new TypeError("kanshi repo must be a Repo");
-    return input.region === undefined ? input : { ...input, region: regionSelection(input.region) };
+    return {
+        ...input,
+        ...(input.region === undefined ? {} : { region: regionSelection(input.region) }),
+        ...(input.contract === undefined ? {} : { contract: contractId(input.contract) }),
+    };
 }
 async function readRegion(observation, selection) {
     try {
@@ -114,9 +121,9 @@ async function readBranch(repo) {
         return null;
     }
 }
-async function readContracts(observation) {
+async function readContracts(observation, selected) {
     try {
-        return { kind: "present", value: await readContractBoard(observation) };
+        return { kind: "present", value: await readContractBoard(observation, selected) };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
@@ -151,7 +158,7 @@ function attachFleet(contracts, akuma) {
         },
     };
 }
-function decorateContracts(contracts, holders) {
+function decorateContracts(contracts, holders, namespaceTasks) {
     if (contracts.kind !== "present")
         return contracts;
     return {
@@ -159,12 +166,15 @@ function decorateContracts(contracts, holders) {
         value: {
             ...contracts.value,
             rows: contracts.value.rows.map((row) => {
-                if (holders.kind === "failed")
-                    return { ...row, holder: { kind: "unavailable" }, fleet: [] };
+                const selected = namespaceTasks(row.id);
+                if (holders.kind === "failed") {
+                    return { ...row, holder: { kind: "unavailable" }, fleet: [], namespaceTasks: selected };
+                }
                 const holder = holders.kind === "present" ? holders.value.get(row.id) : undefined;
                 return {
                     ...row,
                     fleet: [],
+                    namespaceTasks: selected,
                     holder: holder?.disposition === "held"
                         ? { kind: "held", taskId: holder.taskId }
                         : { kind: "none" },
@@ -192,25 +202,42 @@ function joinTasks(rows, holders, observeContract) {
         return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
     });
 }
-async function readTasks(path, holders, observeContract) {
-    if (holders.kind === "failed")
-        return { kind: "failed", failure: holders.failure };
+async function readTaskWorld(path) {
+    if (path === null)
+        return { kind: "absent" };
     try {
-        return {
-            kind: "present",
-            value: { root: path, rows: joinTasks(await observeTaskStatusRows(path), holders, observeContract) },
-        };
+        return { kind: "present", observation: await observeTaskBoard(path) };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-async function joinAkuma(path, observeContract, dispatches) {
+function namespaceTaskSection(board, id) {
+    if (board.kind === "absent")
+        return { kind: "absent" };
+    if (board.kind === "failed")
+        return { kind: "failed", failure: board.failure };
+    return { kind: "present", value: board.observation.selectNamespace(contractNamespace(id)) };
+}
+function readTasks(path, board, holders, observeContract) {
+    if (holders.kind === "failed")
+        return { kind: "failed", failure: holders.failure };
+    if (board.kind === "failed")
+        return { kind: "failed", failure: board.failure };
+    if (board.kind === "absent")
+        return { kind: "absent" };
+    return {
+        kind: "present",
+        value: { root: path, rows: joinTasks(board.observation.statusRows, holders, observeContract) },
+    };
+}
+async function joinAkuma(path, observeContract, dispatches, aliases) {
+    if (aliases.kind !== "present")
+        return aliases;
     try {
         const source = await Akuma.of(path).list();
-        const aliases = await readAliases(path);
         const aliasById = new Map();
-        for (const binding of aliases)
+        for (const binding of aliases.value)
             aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
         const dispatchById = new Map(dispatches.map((dispatch) => [dispatch.akuId, dispatch]));
         return {
@@ -237,6 +264,14 @@ async function joinAkuma(path, observeContract, dispatches) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
+async function readAliasBindings(path) {
+    try {
+        return { kind: "present", value: await readAliases(path) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
 async function readDispatches(observation) {
     try {
         return { kind: "present", value: await readDispatchesAt(observation) };
@@ -245,7 +280,7 @@ async function readDispatches(observation) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-export async function kanshi(input) {
+export async function observeKanshi(input) {
     const observedAt = new Date().toISOString();
     const { world, repo } = coordinate(input);
     const branch = await readBranch(repo);
@@ -253,28 +288,35 @@ export async function kanshi(input) {
         const contracts = { kind: "absent" };
         const holders = { kind: "absent" };
         const observeContract = contractEndpointObserver(contracts);
-        const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
-        const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, []);
-        return { root: world, observedAt, branch, contracts, tasks, akuma, ...(input.region === undefined ? {} : { region: { kind: "absent" } }) };
+        const board = await readTaskWorld(world);
+        const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
+        const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
+        const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
+        return {
+            report: { root: world, observedAt, branch, contracts, tasks, akuma, ...(input.region === undefined ? {} : { region: { kind: "absent" } }) },
+            aliases,
+        };
     }
     try {
         const repository = scopeForRepo(repo);
         return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, async (observation) => {
-            const [contractSection, holders, dispatches, region] = await Promise.all([
-                readContracts(observation),
+            const [contractSection, holders, dispatches, region, board] = await Promise.all([
+                readContracts(observation, input.contract),
                 readHolders(observation),
                 readDispatches(observation),
                 input.region === undefined ? Promise.resolve(undefined) : readRegion(observation, input.region),
+                readTaskWorld(world),
             ]);
-            const contracts = decorateContracts(contractSection, holders);
+            const contracts = decorateContracts(contractSection, holders, (id) => namespaceTaskSection(board, id));
             const observeContract = contractEndpointObserver(contracts);
-            const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
+            const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
+            const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
             const akuma = world === null
                 ? { kind: "absent" }
                 : dispatches.kind === "failed"
                     ? dispatches
-                    : await joinAkuma(world, observeContract, dispatches.value);
-            return {
+                    : await joinAkuma(world, observeContract, dispatches.value, aliases);
+            const report = {
                 root: world,
                 observedAt,
                 branch,
@@ -283,18 +325,30 @@ export async function kanshi(input) {
                 akuma,
                 ...(region === undefined ? {} : { region }),
             };
+            return {
+                report: input.contract === undefined
+                    ? report
+                    : selectKanshi({ report, contract: input.contract }),
+                aliases,
+            };
         }));
     }
     catch (error) {
         const failure = { kind: "failed", failure: { message: diagnostic(error) } };
         return {
-            root: world,
-            observedAt,
-            branch,
-            contracts: failure,
-            tasks: world === null ? { kind: "absent" } : failure,
-            akuma: world === null ? { kind: "absent" } : failure,
-            ...(input.region === undefined ? {} : { region: failure }),
+            report: {
+                root: world,
+                observedAt,
+                branch,
+                contracts: failure,
+                tasks: world === null ? { kind: "absent" } : failure,
+                akuma: world === null ? { kind: "absent" } : failure,
+                ...(input.region === undefined ? {} : { region: failure }),
+            },
+            aliases: world === null ? { kind: "absent" } : failure,
         };
     }
 }
+export async function kanshi(input) {
+    return (await observeKanshi(input)).report;
+}

package/build/src/kanshi/report.d.ts

@@ -31,6 +31,7 @@ export type ContractFleetAttachment = Readonly<{
 export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
     holder: ContractHolderObservation;
     fleet: readonly ContractFleetAttachment[];
+    namespaceTasks: Section<readonly TaskRow[]>;
 }>;
 export type ContractKanshiBoard = Omit<ContractBoard, "rows"> & Readonly<{
     rows: readonly ContractKanshiRow[];

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

@@ -1,20 +1,19 @@
+import { type AliasBinding } from "../alias/index.js";
 import { type AkuId } from "../akuma/identity.js";
 import { type AkumaAlias, type AkumaGlob } from "../identity/selector.js";
-import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
+import type { KanshiReport, Section } from "../kanshi/index.js";
 import { type Repo } from "./repo.js";
 export type DirectAkumaSelector = AkuId | AkumaAlias;
 export type SetAkumaSelector = DirectAkumaSelector | AkumaGlob | `kei/${string}`;
 export type AkumaAddressInput = Readonly<{
     path: WorldRoot;
     akuma: string;
-    settings?: Settings;
     repo?: Repo;
 }>;
 export type AkumaSetAddressInput = Readonly<{
     path: WorldRoot;
     akuma: readonly string[];
-    settings?: Settings;
     repo?: Repo;
 }>;
 export type AkumaWorldScopeRefusal = Readonly<{
@@ -26,12 +25,6 @@ export declare class AkumaWorldScopeError extends TypeError {
     readonly refusal: AkumaWorldScopeRefusal;
     constructor(refusal: AkumaWorldScopeRefusal);
 }
-export type NamedAddressContract = Readonly<{
-    id: string;
-    disposition: "active" | "terminal";
-    workspace: "worktree" | "here";
-    worktreePath: string | null;
-}>;
 export type NamedAddress = Readonly<{
     kind: "contract";
     id: string;
@@ -40,18 +33,16 @@ export type NamedAddress = Readonly<{
     id: AkuId;
 }>;
 export type NamedAddressInput = Readonly<{
-    path: WorldRoot | null;
     selector: string;
-    contracts: readonly NamedAddressContract[];
+    report: KanshiReport;
+    aliases: Section<readonly AliasBinding[]>;
 }>;
-export declare function resolveNamedAddress(input: NamedAddressInput): Promise<NamedAddress>;
+export declare function resolveNamedAddress(input: NamedAddressInput): NamedAddress;
 export declare function addressAkuma(input: AkumaAddressInput): Promise<Readonly<{
     path: WorldRoot;
     id: AkuId;
-    settings?: Settings;
 }>>;
 export declare function addressAkumaSet(input: AkumaSetAddressInput): Promise<Readonly<{
     path: WorldRoot;
     ids: readonly AkuId[];
-    settings?: Settings;
 }>>;

package/build/src/library/address.js

@@ -20,16 +20,8 @@ function nonblank(value, label) {
         throw new TypeError(`${label} must be a nonblank string`);
     return value;
 }
-function settingsOption(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "object" || value === null || typeof value.namespace !== "function") {
-        throw new TypeError("settings must be a Settings");
-    }
-    return value;
-}
-function world(path, settings) {
-    return Akuma.of(path, settings);
+function world(path) {
+    return Akuma.of(path);
 }
 async function directId(path, selector) {
     if (selector.startsWith("@")) {
@@ -41,19 +33,25 @@ async function directId(path, selector) {
     }
     return parseAkuId(selector).id;
 }
-export async function resolveNamedAddress(input) {
+export function resolveNamedAddress(input) {
     const selector = nonblank(input.selector, "selector");
     if (selector.startsWith("kei/"))
         return { kind: "contract", id: contractId(selector) };
     if (selector.startsWith("aku/"))
         return { kind: "akuma", id: parseAkuId(selector).id };
     const alias = parseAkumaAlias(selector);
-    const contractMatches = input.contracts.filter((row) => row.disposition === "active"
+    if (input.report.contracts.kind === "failed") {
+        throw new TypeError("cannot resolve a named selector while the Contract world is failed");
+    }
+    if (input.aliases.kind === "failed") {
+        throw new TypeError("cannot resolve a named selector while Alias authority is failed");
+    }
+    const contractMatches = (input.report.contracts.kind === "present" ? input.report.contracts.value.rows : []).filter((row) => row.disposition === "active"
         && row.workspace === "worktree" && row.worktreePath !== null
         && `@${row.id.slice("kei/".length)}` === alias);
-    const aliasId = input.path === null
-        ? null
-        : (await readAliases(input.path)).find((binding) => binding.alias === alias)?.akuId ?? null;
+    const aliasId = input.aliases.kind === "present"
+        ? input.aliases.value.find((binding) => binding.alias === alias)?.akuId ?? null
+        : null;
     if (contractMatches.length > 0 && aliasId !== null)
         throw new TypeError(`ambiguous selector matches Contract and Akuma: ${selector}`);
     if (contractMatches.length === 1)
@@ -67,14 +65,14 @@ export async function resolveNamedAddress(input) {
 export async function addressAkuma(input) {
     const values = requireInput(input, "Akuma address input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "repo"].includes(key))
+        if (!["path", "akuma", "repo"].includes(key)) {
             throw new TypeError(`Akuma address input has unknown field: ${key}`);
+        }
     }
     if (values.repo !== undefined)
         scopeForRepo(values.repo);
     const path = nonblank(values.path, "path");
-    const settings = settingsOption(values.settings);
-    return { path, id: await directId(path, nonblank(values.akuma, "akuma")), ...(settings === undefined ? {} : { settings }) };
+    return { path, id: await directId(path, nonblank(values.akuma, "akuma")) };
 }
 function idsFromFleet(fleet) {
     return fleet.rows.map((row) => row.id);
@@ -118,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 = [];
@@ -132,19 +136,19 @@ async function refuseForeignContractMembers(path, ids, contractMembers) {
 export async function addressAkumaSet(input) {
     const values = requireInput(input, "Akuma set address input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "repo"].includes(key))
+        if (!["path", "akuma", "repo"].includes(key)) {
             throw new TypeError(`Akuma set address input has unknown field: ${key}`);
+        }
     }
     if (!Array.isArray(values.akuma) || values.akuma.length === 0)
         throw new TypeError("akuma must be a nonempty selector array");
     const path = nonblank(values.path, "path");
-    const settings = settingsOption(values.settings);
     const selectors = values.akuma.map(parseSetSelector);
     if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");
     }
     const fleetIds = hasSelectorKind(selectors, "glob")
-        ? idsFromFleet(await world(path, settings).list())
+        ? idsFromFleet(await world(path).list())
         : [];
     const aliases = hasSelectorKind(selectors, "alias")
         ? new Map((await readAliases(path)).map((binding) => [binding.alias, binding.akuId]))
@@ -161,5 +165,5 @@ export async function addressAkumaSet(input) {
     if (ids.length === 0)
         throw new TypeError("Akuma selector snapshot is empty");
     await refuseForeignContractMembers(path, ids, contractMembers);
-    return { path, ids, ...(settings === undefined ? {} : { settings }) };
+    return { path, ids };
 }

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

@@ -5,6 +5,7 @@ import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
+import type { AllowedAction } from "../akuma/allowed.js";
 import { type Keiyaku } from "./contract.js";
 import { type Repo } from "./repo.js";
 export type { AkumaStatus } from "../akuma/akuma.js";
@@ -41,9 +42,11 @@ export type CallInput = Readonly<{
     cwd?: string;
     mode?: "wait" | "detach";
     timeoutMs?: number;
+    home?: string;
     settings?: Settings;
     contract?: Keiyaku;
     alias?: AkumaAlias;
+    allowed?: readonly AllowedAction[];
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";
@@ -60,7 +63,7 @@ export type CallResult = Readonly<{
     readonly?: ReadonlyRestraint;
     execution: Readonly<{
         cwd: string;
-        source: "input" | "world" | "contract-worktree";
+        source: "input" | "contract-worktree" | "caller" | "process" | "world";
     }>;
     dispatch: DispatchStage;
     alias: AliasStage;
@@ -70,7 +73,6 @@ export type ForkInput = Readonly<{
     path: WorldRoot;
     akuma: string;
     at: string;
-    settings?: Settings;
     repo?: Repo;
 }>;
 export type ForkResult = Readonly<{