@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/index.d.ts

@@ -2,4 +2,5 @@ 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 { KeiyakuPlugin, PluginContext, PluginHooks, PluginInstance, PluginManifest, PluginOutcome, PluginSignal, PluginSignalMap, } from "./plugin/public.js";
 export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";

package/build/src/kanshi/fleet.js

@@ -16,7 +16,7 @@ export function visibleFleetRows(rows) {
         const leftAt = fleetUpdatedAt(left);
         const rightAt = fleetUpdatedAt(right);
         if (leftAt === rightAt)
-            return 0;
+            return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
         if (leftAt === null)
             return 1;
         if (rightAt === null)

package/build/src/kanshi/read.js

@@ -1,19 +1,21 @@
 import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
 import { observeTaskBoard } from "../task/operations.js";
-import { contractNamespace } from "../settlement/settle.js";
+import { contractNamespace } from "../task/identity.js";
 import { Akuma } from "../akuma/index.js";
 import { readAliases } from "../alias/index.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { readTaskHolderProjectionAt } from "../settlement/holder.js";
 import { observeCurrentPhysicalIssue } from "../protocol/read/observation.js";
-import { readContractBoard } from "../protocol/read/status.js";
+import { readContractBoard, readContractCatalogue } from "../protocol/read/status.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
+import { decodeContractDocument } from "../body/decode.js";
+import { assertRegionPattern } from "../body/region.js";
 import { readDocuments } from "../protocol/read/documents.js";
-import { readRegionDeclarations, validateRegionPatterns } from "../library/region.js";
 import { contractId } from "../core/facts/types.js";
 import { selectKanshi, selectRegion } from "./select.js";
-import { FLEET_SNAPSHOT_ROWS, visibleFleetRows } from "./fleet.js";
+import { FLEET_SNAPSHOT_ROWS, FLEET_VISIBLE_ROWS } from "./fleet.js";
+import { observeRecentTaskStatus } from "../task/index.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -41,6 +43,21 @@ function exactKeys(value, allowed, label) {
         if (!allowed.includes(key))
             throw new TypeError(`kanshi ${label} has unknown field: ${key}`);
 }
+function validateRegionPatterns(patterns) {
+    if (!Array.isArray(patterns) || patterns.length === 0)
+        throw new Error("Region query requires one or more path patterns");
+    return patterns.map((pattern) => {
+        if (typeof pattern !== "string")
+            throw new Error("Region path patterns must be strings");
+        return assertRegionPattern(pattern);
+    });
+}
+function readRegionDeclarations(documents) {
+    return documents.map((document) => ({
+        contract: document.contract,
+        patterns: decodeContractDocument(document.documentBytes).region,
+    }));
+}
 function regionSelection(value) {
     const selection = record(value, "region selection");
     if (typeof selection.kind !== "string")
@@ -115,7 +132,9 @@ async function readContracts(observation, include) {
     try {
         return {
             kind: "present",
-            value: await readContractBoard(observation, include),
+            value: include === undefined
+                ? await readContractCatalogue(observation, 10)
+                : await readContractBoard(observation, include),
         };
     }
     catch (error) {
@@ -159,15 +178,20 @@ function decorateContracts(contracts, holders, namespaceTasks) {
         value: {
             ...contracts.value,
             rows: contracts.value.rows.map((row) => {
-                const selected = namespaceTasks(row.id);
+                const selected = namespaceTasks?.(row.id);
                 if (holders.kind === "failed") {
-                    return { ...row, holder: { kind: "unavailable" }, fleet: [], namespaceTasks: selected };
+                    return {
+                        ...row,
+                        holder: { kind: "unavailable" },
+                        fleet: [],
+                        ...(selected === undefined ? {} : { namespaceTasks: selected }),
+                    };
                 }
                 const holder = holders.kind === "present" ? holders.value.get(row.id) : undefined;
                 return {
                     ...row,
                     fleet: [],
-                    namespaceTasks: selected,
+                    ...(selected === undefined ? {} : { namespaceTasks: selected }),
                     holder: holder?.disposition === "held"
                         ? { kind: "held", taskId: holder.taskId }
                         : { kind: "none" },
@@ -177,10 +201,15 @@ function decorateContracts(contracts, holders, namespaceTasks) {
     };
 }
 function contractEndpointObserver(contracts) {
-    const dispositions = contracts.kind === "present"
-        ? new Map(contracts.value.rows.map((row) => [row.id, row.disposition]))
-        : null;
-    return (id) => (dispositions === null ? "unavailable" : (dispositions.get(id) ?? "missing"));
+    if (contracts.kind !== "present")
+        return () => "unavailable";
+    const dispositions = new Map(contracts.value.rows.map((row) => [row.id, row.disposition]));
+    return (id) => {
+        const disposition = dispositions.get(id);
+        if (disposition !== undefined)
+            return disposition;
+        return "hasMore" in contracts.value ? "unavailable" : "missing";
+    };
 }
 function joinTasks(rows, holders, observeContract) {
     const associations = new Map(holders.kind === "present"
@@ -212,23 +241,19 @@ function namespaceTaskSection(board, id) {
         return { kind: "failed", failure: board.failure };
     return { kind: "present", value: board.observation.selectNamespace(contractNamespace(id)) };
 }
-function readTasks(path, board, holders, observeContract) {
+async function readTasks(path, 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 {
+    return observeRecentTaskStatus(path, { limit: 10 }).then((recent) => ({
         kind: "present",
-        value: { root: path, rows: joinTasks(board.observation.statusRows, holders, observeContract) },
-    };
+        value: { root: path, hasMore: recent.hasMore, rows: joinTasks(recent.rows, holders, observeContract) },
+    }), (error) => ({ kind: "failed", failure: { message: diagnostic(error) } }));
 }
 async function joinAkuma(path, observeContract, dispatches, aliases) {
     if (aliases.kind !== "present")
         return aliases;
     try {
-        const source = await Akuma.of(path).list();
+        const source = await Akuma.of(path).list({ limit: FLEET_VISIBLE_ROWS });
         const aliasById = new Map();
         for (const binding of aliases.value)
             aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
@@ -248,7 +273,7 @@ async function joinAkuma(path, observeContract, dispatches, aliases) {
                     }),
             };
         });
-        const snapshotRows = visibleFleetRows(rows).slice(0, FLEET_SNAPSHOT_ROWS);
+        const snapshotRows = rows.slice(0, FLEET_SNAPSHOT_ROWS);
         const snapshots = new Map(await Promise.all(snapshotRows.map(async (row) => {
             try {
                 return [row.id, (await Akuma.of(path).of({ id: row.id }).status()).timeline];
@@ -292,8 +317,7 @@ async function observeWithoutRepo(world, region, observedAt, branch) {
     const contracts = { kind: "absent" };
     const holders = { kind: "absent" };
     const observeContract = contractEndpointObserver(contracts);
-    const board = await readTaskWorld(world);
-    const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
+    const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
     const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
     const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
     return {
@@ -313,17 +337,20 @@ async function observeRepo(input) {
     const { world, repo, region, contract, observedAt, branch } = input;
     try {
         return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
-            const [contractSection, holders, dispatches, regionSection, board] = await Promise.all([
+            const [contractSection, holders, dispatches, regionSection] = await Promise.all([
                 readContracts(observation, contract),
                 readHolders(observation),
                 readDispatches(observation),
                 region === undefined ? Promise.resolve(undefined) : readRegion(observation, region),
-                readTaskWorld(world),
             ]);
-            const contracts = decorateContracts(contractSection, holders, (id) => namespaceTaskSection(board, id));
+            const selectedContract = contract !== undefined &&
+                contractSection.kind === "present" &&
+                contractSection.value.rows.some((row) => row.id === contract);
+            const board = selectedContract ? await readTaskWorld(world) : undefined;
+            const contracts = decorateContracts(contractSection, holders, selectedContract ? (id) => (id === contract ? namespaceTaskSection(board, id) : undefined) : undefined);
             const observeContract = contractEndpointObserver(contracts);
             const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-            const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
+            const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
             const akuma = world === null
                 ? { kind: "absent" }
                 : dispatches.kind === "failed"

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

@@ -6,6 +6,7 @@ import type { WorldRoot } from "../world.js";
 import type { ContractId } from "../library/contract.js";
 import type { RegionOverlap } from "../library/region.js";
 import type { CurrentPhysicalIssue } from "../protocol/read/observation.js";
+import type { BoundedList } from "../bounded-list.js";
 export type { RegionOverlap };
 export type Section<Value> = Readonly<{
     kind: "present";
@@ -35,11 +36,12 @@ export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
     phase: ContractPhase;
     holder: ContractHolderObservation;
     fleet: readonly ContractFleetAttachment[];
-    namespaceTasks: Section<readonly TaskRow[]>;
+    namespaceTasks?: Section<readonly TaskRow[]>;
     issue?: CurrentPhysicalIssue;
 }>;
 export type ContractKanshiBoard = Omit<ContractBoard, "rows"> & Readonly<{
     rows: readonly ContractKanshiRow[];
+    hasMore?: boolean;
 }>;
 export type TaskKanshiRow = TaskRow & Readonly<{
     contract?: Readonly<{
@@ -48,9 +50,8 @@ export type TaskKanshiRow = TaskRow & Readonly<{
     }>;
     blockers?: readonly TaskRef[];
 }>;
-export type TaskKanshiWorld = Readonly<{
+export type TaskKanshiWorld = BoundedList<TaskKanshiRow> & Readonly<{
     root: WorldRoot;
-    rows: readonly TaskKanshiRow[];
 }>;
 export type AkumaKanshiRow = (AkumaListRow | UnbornAkumaListRow) & Readonly<{
     aliases: readonly AkumaAlias[];

package/build/src/kanshi/select.js

@@ -1,4 +1,17 @@
-import { regionOverlaps } from "../library/region.js";
+import { regionsOverlap } from "../body/region.js";
+function regionOverlaps(mine, declarations) {
+    const overlaps = [];
+    for (const declaration of declarations) {
+        const pairs = regionsOverlap(mine, declaration.patterns);
+        if (pairs.length === 0)
+            continue;
+        overlaps.push({
+            contract: declaration.contract,
+            patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
+        });
+    }
+    return overlaps;
+}
 export function selectKanshi(input) {
     const { report, contract } = input;
     return {

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

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import { type AliasBinding } from "../alias/index.js";
 import { type AkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";

package/build/src/library/address.js

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import { readAliases } from "../alias/index.js";
 import { Akuma } from "../akuma/akuma.js";
 import { probeBornAkuma } from "../akuma/index.js";
@@ -21,9 +22,6 @@ function nonblank(value, label) {
         throw new TypeError(`${label} must be a nonblank string`);
     return value;
 }
-function world(path) {
-    return Akuma.of(path);
-}
 async function directId(path, selector) {
     if (selector.startsWith("@")) {
         const alias = parseAkumaAlias(selector);
@@ -76,9 +74,6 @@ export async function addressAkuma(input) {
     const path = await World.prove(nonblank(values.path, "path"));
     return { path, id: await directId(path, nonblank(values.akuma, "akuma")) };
 }
-function idsFromFleet(fleet) {
-    return fleet.rows.map((row) => row.id);
-}
 function parseSetSelector(raw) {
     const selector = nonblank(raw, "akuma selector");
     if (selector.startsWith("kei/"))
@@ -149,7 +144,9 @@ export async function addressAkumaSet(input) {
     if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");
     }
-    const fleetIds = hasSelectorKind(selectors, "glob") ? idsFromFleet(await world(path).list()) : [];
+    const fleetIds = hasSelectorKind(selectors, "glob")
+        ? (await Akuma.of(path).listComplete()).rows.map((row) => row.id)
+        : [];
     const aliases = hasSelectorKind(selectors, "alias")
         ? new Map((await readAliases(path)).map((binding) => [binding.alias, binding.akuId]))
         : new Map();

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

@@ -1,8 +1,9 @@
 import { type AliasBinding } from "../alias/index.js";
 import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
-import { type AkumaBornCall } from "../akuma/akuma-product.js";
-import type { AkuId } from "../akuma/identity.js";
+import type { AkumaBornCall } from "../akuma/akuma-product.js";
+import { type AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
+import type { PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
 import { type WorldRoot } from "../world.js";
@@ -20,6 +21,7 @@ export type DispatchStage = Readonly<{
 }> | Readonly<{
     kind: "dispatched";
     dispatch: Dispatch;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }> | Readonly<{
     kind: "failed";
     failure: DispatchFailure | IntegrationFailure;
@@ -100,6 +102,6 @@ export type ForkResult = Readonly<{
     parent: AkuId;
 }>);
 export declare function beginCall(input: CallInput, context: ExecutionContext): Promise<BornCall>;
-export declare function finishCall(born: BornCall, participantName?: string): Promise<CallResult>;
+export declare function finishCall(born: BornCall): Promise<CallResult>;
 export declare function callKeiyaku(input: CallInput, execution?: ExecutionContext): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -1,13 +1,17 @@
-import { realpath, stat } from "node:fs/promises";
+/** @architectureCompositionRoot */
+import { appendFile } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
 import { Akuma } from "../akuma/akuma.js";
-import { beginAkumaCall, finishAkumaCall } from "../akuma/akuma-product.js";
+import { pathsForAkuId } from "../akuma/identity.js";
+import { readSoul } from "../akuma/heart/index.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
+import { emitCalledPluginSignal } from "../plugin/akuma-signals.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { World } from "../world.js";
 import { localExecutionContext } from "../akuma/requests.js";
+import { callReadonly, canonicalBirthCwd } from "../akuma/call-input.js";
 import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
 import { KeiyakuRefused } from "./contract.js";
@@ -66,11 +70,6 @@ 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");
@@ -82,6 +81,14 @@ function callTimeout(value, mode) {
     }
     return value;
 }
+function callSeat(contract) {
+    if (contract === undefined)
+        return undefined;
+    const seat = seatForKeiyaku(contract);
+    if (seat === null)
+        throw new TypeError("contract must be a Keiyaku");
+    return seat;
+}
 async function observeCall(handle, mode, timeoutMs) {
     if (mode === "detach") {
         return { kind: "detached" };
@@ -93,11 +100,72 @@ async function observeCall(handle, mode, timeoutMs) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
+async function callerAkuId(path, born) {
+    if (born.kind !== "requested")
+        return undefined;
+    const soul = await readSoul(pathsForAkuId(path, born.id));
+    return soul?.origin.kind === "request" ? soul.origin.parent : undefined;
+}
+function pluginDiagnostic(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.length <= 500 ? message : `${message.slice(0, 500)}...`;
+}
+async function recordPluginDiagnostic(paths, error) {
+    try {
+        await appendFile(paths.log, `plugin call admission failed: ${pluginDiagnostic(error)}\n`);
+    }
+    catch {
+        // Plugin diagnostic loss must not change an already admitted call.
+    }
+}
+async function emitCalledSignal(input) {
+    try {
+        const callerAkumaId = await callerAkuId(input.path, input.born);
+        const paths = input.born.kind === "requested" ? pathsForAkuId(input.path, input.akumaId) : input.born.allocated.paths;
+        const reportDiagnostic = (message) => {
+            void recordPluginDiagnostic(paths, message);
+        };
+        try {
+            await emitCalledPluginSignal({
+                world: input.path,
+                ...(input.settings === undefined ? {} : { settings: input.settings }),
+                reportDiagnostic,
+                akumaId: input.akumaId,
+                ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
+                ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
+            });
+        }
+        catch (error) {
+            await recordPluginDiagnostic(paths, error);
+        }
+    }
+    catch {
+        // Plugin delivery must not change an already admitted call.
+    }
+}
+async function admitCall(input) {
+    const born = await input.world.beginCall(input.call, input.context);
+    const akuma = born.kind === "requested" ? born.id : born.allocated.id;
+    void emitCalledSignal({
+        path: input.path,
+        ...(input.settings === undefined ? {} : { settings: input.settings }),
+        born,
+        akumaId: akuma,
+        ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
+    });
+    return { born, akuma };
+}
 async function dispatchStage(input) {
     try {
         const published = await publishDispatch(input);
         return published.kind === "dispatched"
-            ? { kind: "dispatched", dispatch: published.dispatch }
+            ? {
+                kind: "dispatched",
+                dispatch: published.dispatch,
+                ...(published.seatClose === undefined || published.seatClose.length === 0
+                    ? {}
+                    : { seatClose: published.seatClose }),
+            }
             : { kind: "failed", failure: published.failure };
     }
     catch (error) {
@@ -115,19 +183,6 @@ async function forkDispatchStage(input) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-async function canonicalizeExistingDirectory(path, diagnostic) {
-    try {
-        const real = await realpath(path);
-        if (!(await stat(real)).isDirectory())
-            throw new Error(diagnostic);
-        return real;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === diagnostic)
-            throw error;
-        throw new Error(diagnostic);
-    }
-}
 function unavailableWorkspace(contractId, detail) {
     return new Error(`Contract workspace is unavailable: ${contractId} ${detail}`);
 }
@@ -149,7 +204,7 @@ async function currentManagedContract(contract, contractId) {
 async function resolveCallExecution(input) {
     if (input.cwd !== undefined) {
         return {
-            cwd: await canonicalizeExistingDirectory(input.cwd, `cwd is not an existing directory: ${input.cwd}`),
+            cwd: await canonicalBirthCwd(input.cwd),
             source: "input",
         };
     }
@@ -166,7 +221,7 @@ async function resolveCallExecution(input) {
             throw new Error(`${appointment.diagnostic}; use reconcile`);
         }
         return {
-            cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
+            cwd: await canonicalBirthCwd(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
             source: "contract-worktree",
         };
     }
@@ -191,17 +246,14 @@ export async function beginCall(input, context) {
     const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
-    const readonlyRequested = callReadonly(values.readonly);
+    const readonlyRequested = callReadonly(values.readonly, "readonly must be true").readonly;
     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 : parseAkumaAlias(nonblank(values.alias, "alias"));
-    const selectedSeat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
-    if (values.contract !== undefined && selectedSeat === null)
-        throw new TypeError("contract must be a Keiyaku");
-    const seat = selectedSeat ?? undefined;
+    const seat = callSeat(values.contract);
     const execution = await resolveCallExecution({
         path,
         ...(cwd === undefined ? {} : { cwd }),
@@ -215,8 +267,14 @@ export async function beginCall(input, context) {
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
     };
-    const born = await beginAkumaCall(world, call, execution === undefined ? {} : { cwdCanonical: true });
-    const akuma = born.kind === "requested" ? born.id : born.allocated.id;
+    const { born, akuma } = await admitCall({
+        path,
+        world,
+        call: call,
+        context: execution === undefined ? {} : { cwdCanonical: true },
+        ...(settings === undefined ? {} : { settings }),
+        ...(seat === undefined ? {} : { contractId: seat.id }),
+    });
     const completedExecution = execution ?? born.execution;
     const dispatch = seat === undefined
         ? { kind: "none" }
@@ -245,11 +303,10 @@ export async function beginCall(input, context) {
         alias: aliasStage,
     };
 }
-export async function finishCall(born, participantName) {
+export async function finishCall(born) {
     const world = akumaWorld(born.path);
     const contractId = born.dispatch.kind === "dispatched" ? born.dispatch.dispatch.contractId : undefined;
-    const handle = await finishAkumaCall(world, born.born, {
-        ...(participantName === undefined ? {} : { participantName }),
+    const handle = await world.finishCall(born.born, {
         ...(contractId === undefined ? {} : { contractId }),
     });
     const readonly = (await handle.status()).readonly;

package/build/src/library/audit.js

@@ -4,7 +4,7 @@ import { auditOperation } from "../protocol/audit.js";
 import { withScopeAbortSignal } from "../protocol/operations.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { documentDerivation } from "./input.js";
-import { completeMutation } from "./mutation.js";
+import { auditPending, completeMutation } from "./mutation.js";
 import { requireAccepted } from "./refusal.js";
 /** Normalize public audit input and project the protocol audit operation. */
 export async function auditContract(input) {
@@ -28,6 +28,7 @@ export async function auditContract(input) {
             contractId: input.contractId,
             accepted,
             value: (report) => report,
+            valuePending: auditPending,
             hooks: composition?.hooks ?? worktreeHooksOption(undefined),
         });
     });

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

@@ -1,19 +1,23 @@
+/** @architectureCompositionRoot */
 import { type AkumaList } from "../akuma/akuma.js";
 import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
 import type { TaskRow } from "../task/index.js";
-import { type ContractBoard } from "./contract.js";
+import { type ContractCatalogue } from "./contract.js";
 import { Repo } from "./repo.js";
 import { type WorldRoot } from "../world.js";
 export type CatalogQuery = Readonly<{
     kind: "tasks";
     namespace?: readonly string[];
+    limit?: number;
 }> | Readonly<{
     kind: "contracts";
+    limit?: number;
 }> | Readonly<{
     kind: "archetypes";
 }> | Readonly<{
     kind: "akuma";
     archetype?: string;
+    limit?: number;
 }>;
 export type CatalogInput = Readonly<{
     query: Extract<CatalogQuery, {
@@ -29,6 +33,7 @@ export type CatalogInput = Readonly<{
     query: Extract<CatalogQuery, {
         kind: "archetypes";
     }>;
+    path?: WorldRoot;
     home?: string;
 }> | Readonly<{
     query: Extract<CatalogQuery, {
@@ -40,12 +45,14 @@ export type Catalog = Readonly<{
     kind: "tasks";
     root: WorldRoot;
     rows: readonly TaskRow[];
+    hasMore: boolean;
 }> | Readonly<{
     kind: "contracts";
     root: string;
     state: string | null;
     observedAt: string;
-    rows: ContractBoard["rows"];
+    rows: ContractCatalogue["rows"];
+    hasMore: boolean;
 }> | Readonly<{
     kind: "archetypes";
     rows: readonly ArchetypeCatalogRow[];
@@ -56,5 +63,6 @@ export type Catalog = Readonly<{
     observedAt: string;
     rows: AkumaList["rows"];
     searched: readonly string[];
+    hasMore: boolean;
 }>;
 export declare function listCatalog(input: CatalogInput): Promise<Catalog>;