@astrosheep/keiyaku 4.0.2 → 4.0.4

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);
@@ -132,19 +130,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 +159,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<{

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

@@ -1,6 +1,6 @@
 import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma, } from "../akuma/akuma.js";
+import { Akuma, akumaCallExecution, callAkumaWithContext, } from "../akuma/akuma.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch, } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
@@ -28,6 +28,17 @@ function settingsOption(value) {
     }
     return value;
 }
+function homeOption(value) {
+    if (value === undefined)
+        return undefined;
+    return nonblank(value, "home");
+}
+function akumaWorld(path, home, settings) {
+    return Akuma.of(path, {
+        ...(home === undefined ? {} : { home }),
+        ...(settings === undefined ? {} : { settings }),
+    });
+}
 function onlyKeys(values, allowed, label) {
     const accepted = new Set(allowed);
     for (const key of Object.keys(values)) {
@@ -132,31 +143,33 @@ async function resolveCallExecution(input) {
             source: "input",
         };
     }
-    if (input.contract === undefined)
-        return { cwd: input.path, source: "world" };
-    const seat = seatForKeiyaku(input.contract);
-    const state = await currentManagedContract(input.contract, seat.id);
-    const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
-    if (appointment.kind === "unappointed") {
-        throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
-    }
-    if (appointment.kind === "failed") {
-        throw new Error(`${appointment.diagnostic}; use reconcile`);
+    if (input.contract !== undefined) {
+        const seat = seatForKeiyaku(input.contract);
+        const state = await currentManagedContract(input.contract, seat.id);
+        const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
+        if (appointment.kind === "unappointed") {
+            throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
+        }
+        if (appointment.kind === "failed") {
+            throw new Error(`${appointment.diagnostic}; use reconcile`);
+        }
+        return {
+            cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
+            source: "contract-worktree",
+        };
     }
-    return {
-        cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
-        source: "contract-worktree",
-    };
+    return undefined;
 }
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "settings", "contract", "alias"], "Keiyaku.call input");
+    onlyKeys(values, ["path", "archetype", "body", "cwd", "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 cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
     const timeoutMs = callTimeout(values.timeoutMs, mode);
+    const home = homeOption(values.home);
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined
         ? undefined
@@ -167,11 +180,19 @@ export async function callKeiyaku(input) {
         ...(cwd === undefined ? {} : { cwd }),
         ...(seat === undefined ? {} : { contract: values.contract }),
     });
-    const handle = await Akuma.of(path, settings).call({
+    const world = akumaWorld(path, home, settings);
+    const call = {
         archetype,
         body,
-        cwd: execution.cwd,
-    });
+        ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
+        ...(execution === undefined ? {} : { cwd: execution.cwd }),
+    };
+    const handle = execution === undefined
+        ? await world.call(call)
+        : await callAkumaWithContext(world, call, { cwdCanonical: true });
+    const completedExecution = execution ?? akumaCallExecution(handle);
+    if (completedExecution === undefined)
+        throw new Error("Akuma call is missing its birth execution");
     const readonly = (await handle.status()).readonly;
     const dispatch = seat === undefined
         ? { kind: "none" }
@@ -195,7 +216,7 @@ export async function callKeiyaku(input) {
         kind: "called",
         akuma: handle.id,
         ...(readonly === undefined ? {} : { readonly }),
-        execution,
+        execution: completedExecution,
         dispatch,
         alias: aliasStage,
         observation,
@@ -203,19 +224,15 @@ export async function callKeiyaku(input) {
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
-    onlyKeys(values, ["path", "akuma", "at", "settings", "repo"], "Keiyaku.fork input");
+    onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");
     const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
-    const settings = settingsOption(values.settings);
     const akuma = (await addressAkuma({
         path,
         akuma: nonblank(values.akuma, "akuma"),
-        ...(settings === undefined ? {} : { settings }),
     })).id;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
-    const receipt = await Akuma.of(path, settings)
-        .of({ id: akuma })
-        .fork({ at });
+    const receipt = await Akuma.of(path).of({ id: akuma }).fork({ at });
     if (receipt.kind !== "forked")
         return { ...receipt, parent: akuma };
     const dispatch = repository === undefined

package/build/src/library/bind.js

@@ -13,7 +13,6 @@ async function attempt(input, id) {
     return bindOperation({
         scope: input.scope,
         channel: input.channel,
-        title: input.title,
         terms: input.terms,
         verification: input.verification,
         workspace: input.workspace,
@@ -26,6 +25,7 @@ async function attempt(input, id) {
     });
 }
 async function attemptCandidates(input) {
+    let result;
     for (let collision = 0; collision <= 3; collision += 1) {
         const id = candidateId(input.title, collision);
         let reserved = false;
@@ -40,7 +40,7 @@ async function attemptCandidates(input) {
             }
             reserved = true;
         }
-        const result = await attempt(input, id);
+        result = await attempt(input, id);
         if (result.kind === "accepted")
             return result;
         if (reserved)
@@ -48,7 +48,7 @@ async function attemptCandidates(input) {
         if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
             return result;
     }
-    throw new Error("contract identity collision attempts exhausted");
+    return result;
 }
 export async function admitBindWithAppointment(input) {
     const action = () => attemptCandidates(input);

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

@@ -1,6 +1,5 @@
 import { type AkumaList } from "../akuma/akuma.js";
 import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
-import type { Settings } from "../settings.js";
 import type { TaskRow } from "../task/index.js";
 import { type ContractBoard } from "./contract.js";
 import { Repo } from "./repo.js";
@@ -29,7 +28,7 @@ export type CatalogInput = Readonly<{
     query: Extract<CatalogQuery, {
         kind: "archetypes";
     }>;
-    settings: Settings;
+    home?: string;
 }> | Readonly<{
     query: Extract<CatalogQuery, {
         kind: "akuma";

package/build/src/library/catalog.js

@@ -4,10 +4,11 @@ import { observeTaskCatalogRows } from "../task/operations.js";
 import { listKeiyaku } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
-function settingsValue(value) {
-    if (typeof value !== "object" || value === null
-        || typeof value.namespace !== "function") {
-        throw new TypeError("settings must be a Settings");
+function optionalHome(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("home must be a nonblank string");
     }
     return value;
 }
@@ -40,7 +41,7 @@ export async function listCatalog(input) {
     const values = requireInput(input, "Keiyaku.ls input");
     const query = queryValue(values.query);
     const allowed = query.kind === "contracts" ? ["query", "repo"]
-        : query.kind === "archetypes" ? ["query", "settings"] : ["query", "path"];
+        : query.kind === "archetypes" ? ["query", "home"] : ["query", "path"];
     for (const key of Object.keys(values)) {
         if (!allowed.includes(key))
             throw new TypeError(`Keiyaku.ls input has unknown field: ${key}`);
@@ -52,7 +53,11 @@ export async function listCatalog(input) {
         return { kind: "contracts", root: board.root, state: board.state, rows: board.rows };
     }
     if (query.kind === "archetypes") {
-        return { kind: "archetypes", rows: await listArchetypeDefinitions({ settings: settingsValue(values.settings) }) };
+        const home = optionalHome(values.home);
+        return {
+            kind: "archetypes",
+            rows: await listArchetypeDefinitions(home === undefined ? {} : { home }),
+        };
     }
     const path = worldRoot(values.path);
     if (query.kind === "tasks") {