@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -0,0 +1,385 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+/** Internal composition root for one immutable execution channel. */
+export declare function composeLibrary(context?: ExecutionContext, composition?: Parameters<typeof bindKeiyaku>[2]): Readonly<{
+    prototype: KeiyakuHandle;
+    [Symbol.hasInstance]: (value: unknown) => boolean;
+    bind: (input: Parameters<typeof bindKeiyaku>[0]) => Promise<import("./contract-types.js").BindResult>;
+    call: (input: Parameters<typeof callKeiyaku>[0]) => Promise<Readonly<{
+        kind: "called";
+        akuma: import("./keiyaku.js").AkuId;
+        readonly?: import("../akuma/provider-recipe.js").ReadonlyRestraint;
+        execution: Readonly<{
+            cwd: string;
+            source: "input" | "contract-worktree" | "caller" | "process" | "world";
+        }>;
+        dispatch: import("./akuma-creation.js").DispatchStage;
+        alias: import("./akuma-creation.js").AliasStage;
+        observation: import("./akuma-creation.js").CallObservation;
+    }>>;
+    fork: typeof forkKeiyaku;
+    history: typeof historyAkuma;
+    interrupt: typeof interruptAkuma;
+    kill: (input: Parameters<typeof killAkuma>[0]) => Promise<{
+        results: {
+            id: import("./keiyaku.js").AkuId;
+            evidence: "unavailable" | "killed" | "already-killed" | "already-stopped" | "hung" | "untidy";
+        }[];
+    }>;
+    ls: typeof listCatalog;
+    nuke: typeof nukeKeiyaku;
+    list: typeof listKeiyaku;
+    observe: typeof observeKeiyaku;
+    of: (input: Parameters<typeof keiyakuOf>[0]) => KeiyakuHandle;
+    status: typeof statusAkuma;
+    tell: (input: Parameters<typeof tellAkuma>[0]) => Promise<{
+        akuma: import("./keiyaku.js").AkuId;
+        tell: {
+            admission: {
+                fact: "recorded";
+                tellId: string;
+            };
+            row: {
+                kind: "tell";
+                sequence: number;
+                at: string;
+                tellId: string;
+                text: string;
+                state: "pending" | "told";
+                deliveries: readonly Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>[];
+            };
+            wake: {
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                child: {
+                    code: number | null;
+                    signal: string | null;
+                    log: {
+                        path: string;
+                        from: number;
+                        to: number;
+                    };
+                };
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                kind: "told";
+            } | {
+                kind: "held";
+            } | {
+                kind: "pursuing";
+                bodySequence: number;
+            };
+        };
+    }>;
+    wait: (input: Parameters<typeof waitAkuma>[0]) => Promise<{
+        completion: "any" | "all";
+        observations: {
+            status: {
+                id: import("./keiyaku.js").AkuId;
+                life: "killed" | "hung" | "untidy" | "running" | "asleep" | "stranded";
+                timeline: {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "unborn";
+                    entries: readonly never[];
+                    omitted: 0;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "open";
+                    turn: {
+                        kind: "turn";
+                        sequence: number;
+                        turnSequence: number;
+                        bodySequence: number;
+                        at: string;
+                    };
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
+                        } | {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: "active";
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "idle";
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
+                        } | {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                    outcome?: {
+                        kind: "outcome";
+                        sequence: number;
+                        turnSequence: number;
+                        at: string;
+                        outcome: {
+                            kind: "answered";
+                            historyId: string;
+                            answer: string;
+                        } | {
+                            kind: "failed";
+                            historyId: string;
+                            diagnostic: string;
+                        };
+                    } | undefined;
+                };
+                readonly?: {
+                    enforcement: "native";
+                } | {
+                    enforcement: "none";
+                    diagnostic: string;
+                } | undefined;
+                strandedReason?: "resume-unsupported" | undefined;
+            };
+            contract: {
+                kind: "none";
+            } | {
+                kind: "associated";
+                contractId: import("./contract.js").ContractId;
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+            createdTasks: {
+                kind: "present";
+                rows: readonly {
+                    id: `task/${string}`;
+                    title: string;
+                    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
+                    priority: 0 | 1 | 2 | 3;
+                    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
+                    updatedAt: string;
+                    bodyPresent: boolean;
+                    children?: {
+                        live: number;
+                        total: number;
+                    } | undefined;
+                }[];
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+        }[];
+        unobserved: {
+            id: import("./keiyaku.js").AkuId;
+            diagnostic: string;
+        }[];
+    }>;
+}>;

package/build/src/library/composition.js

@@ -0,0 +1,28 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
+import { executionChannel, localExecutionContext } from "../akuma/requests.js";
+/** Internal composition root for one immutable execution channel. */
+export function composeLibrary(context = localExecutionContext(), composition) {
+    const captured = Object.freeze({ channel: executionChannel(context) });
+    return Object.freeze({
+        prototype: KeiyakuHandle.prototype,
+        [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
+        bind: (input) => bindKeiyaku(input, captured, composition),
+        call: (input) => callKeiyaku(input, captured),
+        fork: forkKeiyaku,
+        history: historyAkuma,
+        interrupt: interruptAkuma,
+        kill: (input) => killAkuma(input, captured),
+        ls: listCatalog,
+        nuke: nukeKeiyaku,
+        list: listKeiyaku,
+        observe: observeKeiyaku,
+        of: (input) => keiyakuOf(input, captured, composition),
+        status: statusAkuma,
+        tell: (input) => tellAkuma(input, captured),
+        wait: (input) => waitAkuma(input, captured),
+    });
+}

package/build/src/library/configuration.js

@@ -73,9 +73,11 @@ function command(value, coordinate, ErrorType) {
     if (!record(value))
         throw new ErrorType(`${coordinate} must be an object`);
     for (const key of Object.keys(value)) {
-        if (key !== "argv" && key !== "timeoutMs")
+        if (key !== "name" && key !== "argv" && key !== "timeoutMs")
             throw new ErrorType(`${coordinate} has unknown field: ${key}`);
     }
+    if (typeof value.name !== "string" || value.name.trim().length === 0)
+        throw new ErrorType(`${coordinate}.name must be nonblank`);
     if (!Array.isArray(value.argv) || value.argv.length === 0 || !value.argv.every((item) => typeof item === "string")) {
         throw new ErrorType(`${coordinate}.argv must be a nonempty string array`);
     }
@@ -86,7 +88,11 @@ function command(value, coordinate, ErrorType) {
         value.timeoutMs > 2_147_483_647) {
         throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
     }
-    return Object.freeze({ argv: Object.freeze([...value.argv]), timeoutMs: value.timeoutMs });
+    return Object.freeze({
+        name: value.name.trim(),
+        argv: Object.freeze([...value.argv]),
+        timeoutMs: value.timeoutMs,
+    });
 }
 function commands(value, coordinate, ErrorType) {
     if (!Array.isArray(value))

package/build/src/library/continuation.js

@@ -1,6 +1,9 @@
 import { observeActiveContractWorld } from "../git/observe.js";
 import { withGitReadObservation } from "../git/read-observation.js";
+import { reconcileDependentWorktree } from "../git/reconcile.js";
+import { worktreePath } from "../git/workspace.js";
 import { continueDeliveryOperation } from "../protocol/deliver.js";
+import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 function reverseDependents(world) {
     const index = new Map();
     for (const record of world.contracts.values()) {
@@ -27,48 +30,81 @@ function appendAccepted(primary, child) {
         ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
     };
 }
+function appendPhysical(primary, physical) {
+    const effects = [...(primary.physical?.effects ?? []), ...physical.effects];
+    const lag = [...(primary.physical?.lag ?? []), ...physical.lag];
+    return {
+        ...primary,
+        ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+    };
+}
+// The bounded dependency walk keeps selection, physical follow, and child admission together.
+// eslint-disable-next-line max-lines-per-function
 export async function continueDeliveredDependents(input) {
     const world = await withGitReadObservation(input.scope, input.channel, async (observation) => await observeActiveContractWorld(observation));
     const dependents = reverseDependents(world);
-    const pending = [input.contractId];
+    const places = await readPlaceRegister(input.scope);
+    const initialTarget = typeof input.accepted.value === "object" && input.accepted.value !== null && "completion" in input.accepted.value
+        ? (input.accepted.value
+            .completion?.integration ?? undefined)
+        : undefined;
+    const pending = [{ contractId: input.contractId, target: initialTarget }];
     const attempted = new Set();
-    const newlyClaimed = new Set(pending);
+    const newlyClaimed = new Set([input.contractId]);
     const claimed = [];
     const stopped = [];
     let accepted = input.accepted;
+    const process = async (candidate, predecessorTarget) => {
+        const contractId = candidate.state.id;
+        if (!candidate.state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed")) {
+            return { accepted, outcome: "skip" };
+        }
+        attempted.add(contractId);
+        if (predecessorTarget !== undefined && candidate.state.coordinates.workspace === "worktree") {
+            const appointment = appointmentFor(places, contractId);
+            if (appointment !== undefined) {
+                const reconciled = await reconcileDependentWorktree(input.scope, contractId, worktreePath(input.scope, appointment.place), predecessorTarget);
+                accepted = appendPhysical(accepted, reconciled);
+                if (reconciled.lag.length > 0)
+                    return { accepted, outcome: "stopped" };
+            }
+        }
+        const child = await continueDeliveryOperation({
+            scope: input.scope,
+            channel: input.channel,
+            state: candidate.state,
+            journal: candidate.journal,
+            deriveDocument: input.deriveDocument,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        accepted = appendAccepted(accepted, child.admission);
+        if (child.evidence.completion !== undefined) {
+            newlyClaimed.add(contractId);
+            pending.push({ contractId, target: child.evidence.completion.integration });
+            return { accepted, outcome: "claimed" };
+        }
+        const stop = child.evidence.placement;
+        if (stop === undefined)
+            throw new Error("incomplete continuation is missing its placement stop");
+        return {
+            accepted,
+            outcome: "stopped",
+            stop: "refusal" in stop && stop.refusal.kind === "terminal" ? { kind: "already-terminal" } : stop,
+        };
+    };
     while (pending.length > 0) {
         const parent = pending.shift();
-        for (const candidate of dependents.get(parent) ?? []) {
+        for (const candidate of dependents.get(parent.contractId) ?? []) {
             const contractId = candidate.state.id;
-            if (attempted.has(contractId) ||
-                !candidate.state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed"))
+            if (attempted.has(contractId))
                 continue;
-            attempted.add(contractId);
-            const child = await continueDeliveryOperation({
-                scope: input.scope,
-                channel: input.channel,
-                state: candidate.state,
-                journal: candidate.journal,
-                deriveDocument: input.deriveDocument,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-            accepted = appendAccepted(accepted, child.admission);
-            if (child.evidence.completion !== undefined) {
+            const result = await process(candidate, parent.target);
+            accepted = result.accepted;
+            if (result.outcome === "claimed")
                 claimed.push(contractId);
-                newlyClaimed.add(contractId);
-                pending.push(contractId);
-                continue;
-            }
-            const stop = child.evidence.placement;
-            if (stop === undefined)
-                throw new Error("incomplete continuation is missing its placement stop");
-            if ("refusal" in stop && stop.refusal.kind === "terminal") {
-                stopped.push({ contractId, stop: { kind: "already-terminal" } });
-            }
-            else {
-                stopped.push({ contractId, stop });
-            }
+            if (result.outcome === "stopped" && result.stop !== undefined)
+                stopped.push({ contractId, stop: result.stop });
         }
     }
     return {

package/build/src/library/contract-bind.js

@@ -9,8 +9,16 @@ import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
 import { worktreeHooksOption } from "./configuration.js";
 function acceptedBindResult(result, region) {
-    const { facts, head, effects, lags, settlement } = result;
-    return { facts, head, keiyaku: result.value, effects, lags, settlement, ...region };
+    const { facts, head, lags, settlementLags, recoverySnapshot } = result;
+    return {
+        facts,
+        head,
+        keiyaku: result.value,
+        lags,
+        settlementLags,
+        ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
+        ...region,
+    };
 }
 export async function bindKeiyaku(input, createHandle) {
     const values = requireInput(input, "Keiyaku.bind input");