@astrosheep/keiyaku 4.5.8 → 4.5.9

package/build/src/akuma/providers/pi/index.js

@@ -68,25 +68,14 @@ async function piCreateOptions(sdk, input) {
         ...(customTools === undefined ? {} : { customTools }),
     };
 }
-async function createPiSession(sdk, execution, input, signal) {
+async function createPiSession(sdk, execution, input) {
     const setup = piCreateOptions(sdk, input).then(async (options) => {
         if (execution.config !== undefined) {
             throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
         }
         return await sdk.createAgentSession(options);
     });
-    const created = await setup;
-    if (signal.aborted) {
-        await created.session.dispose();
-        signal.throwIfAborted();
-    }
-    return created;
-}
-function forceDisposePi(dispose, settle, setAborting) {
-    setAborting();
-    dispose();
-    settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
-    return Promise.resolve();
+    return await setup;
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
@@ -115,81 +104,80 @@ async function runPiPrompt(native, input, events, state, settle) {
     }
 }
 async function drivePi(sdk, execution, input, signal, custody) {
-    const created = await createPiSession(sdk, execution, input, signal);
+    const created = await createPiSession(sdk, execution, input);
     const native = created.session;
-    let retired = false;
     let settleRetired;
-    const closed = new Promise((resolve) => {
+    let failRetired;
+    const closed = new Promise((resolve, reject) => {
         settleRetired = resolve;
+        failRetired = reject;
     });
-    custody?.own({
-        closed,
-        abort: async () => {
-            native.dispose();
-            retired = true;
-            settleRetired();
-        },
-        forceDispose: async () => {
-            native.dispose();
-            retired = true;
-            settleRetired();
-        },
-    });
-    if (signal.aborted) {
-        native.dispose();
-        signal.throwIfAborted();
-    }
-    if (native.sessionFile === undefined || native.sessionFile.trim().length === 0) {
-        native.dispose();
-        throw new Error("Pi session admitted without sessionFile");
-    }
     const events = new AgentEventChannel();
     const eventState = { answer: "", assistantSeen: false, tools: new Map() };
     const state = {
         terminalFailure: null,
-        disposed: false,
         aborting: false,
         settled: false,
     };
-    const dispose = () => {
-        if (state.disposed)
-            return;
-        state.disposed = true;
+    let settleCompletion;
+    const completion = new Promise((resolve) => {
+        settleCompletion = resolve;
+    });
+    const unsubscribe = native.subscribe((event) => {
+        if (event.type === "agent_end" && !event.willRetry)
+            state.terminalFailure = piTerminalFailure(event.messages);
+        for (const translated of translatePiEvent(event, eventState))
+            events.emit(translated);
+    });
+    const settle = (result) => {
+        if (state.settled)
+            return closed;
+        state.settled = true;
+        let failure;
         try {
             unsubscribe();
         }
+        catch (error) {
+            failure = error;
+        }
         finally {
             try {
-                native.dispose();
-                if (!retired) {
-                    retired = true;
-                    settleRetired();
-                }
+                events.end();
             }
             finally {
-                events.end();
+                settleCompletion(result);
+                try {
+                    native.dispose();
+                }
+                catch (error) {
+                    failure ??= error;
+                }
             }
         }
+        if (failure === undefined)
+            settleRetired();
+        else
+            failRetired(failure);
+        return closed;
     };
-    const unsubscribe = native.subscribe((event) => {
-        if (event.type === "agent_end" && !event.willRetry)
-            state.terminalFailure = piTerminalFailure(event.messages);
-        for (const translated of translatePiEvent(event, eventState))
-            events.emit(translated);
-    });
+    const forceDispose = async () => {
+        if (!state.settled)
+            state.aborting = true;
+        await settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
+    };
+    custody?.own({ closed, abort: forceDispose, forceDispose });
+    if (signal.aborted) {
+        await settle({ kind: "failed", diagnostic: "Pi session aborted" });
+        signal.throwIfAborted();
+    }
+    if (native.sessionFile === undefined || native.sessionFile.trim().length === 0) {
+        await settle({ kind: "failed", diagnostic: "Pi session admitted without sessionFile" });
+        throw new Error("Pi session admitted without sessionFile");
+    }
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
-    let settleCompletion;
-    const completion = new Promise((resolve) => {
-        settleCompletion = resolve;
+    void runPiPrompt(native, input, eventState, state, (result) => {
+        void settle(result);
     });
-    const settle = (result) => {
-        if (state.settled)
-            return;
-        state.settled = true;
-        dispose();
-        settleCompletion(result);
-    };
-    void runPiPrompt(native, input, eventState, state, settle);
     return {
         admission: { fence: native.sessionId },
         events,
@@ -205,13 +193,11 @@ async function drivePi(sdk, execution, input, signal, custody) {
                 catch {
                     /* prompt settlement still proves local cleanup */
                 }
-                settle({ kind: "failed", diagnostic: "Pi session aborted" });
+                await settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
             return state.abortRequest;
         },
-        forceDispose: () => forceDisposePi(dispose, settle, () => {
-            state.aborting = true;
-        }),
+        forceDispose,
     };
 }
 function piSessionFile(coordinate) {

package/build/src/akuma/request-lifecycle.d.ts

@@ -16,7 +16,7 @@ type ServeClaim = (input: PumpInput & Readonly<{
     claim: RequestEnvelope;
     signal: AbortSignal;
     admissionOpen(): boolean;
-}>) => Promise<void>;
+}>) => Promise<boolean>;
 export declare class BodyRequestPump {
     private readonly input;
     private readonly serveClaim;

package/build/src/akuma/request-lifecycle.js

@@ -52,7 +52,7 @@ export class BodyRequestPump {
                     continue;
                 }
                 if (!this.admissionClosed) {
-                    await this.serveClaim({
+                    const served = await this.serveClaim({
                         directory: this.directory,
                         transportId,
                         claim,
@@ -60,6 +60,8 @@ export class BodyRequestPump {
                         signal: this.executionSignal.signal,
                         admissionOpen: () => !this.admissionClosed,
                     });
+                    if (!served)
+                        await rm(path, { force: true });
                 }
                 this.handled.add(transportId);
             }

package/build/src/akuma/request-serve.d.ts

@@ -11,7 +11,7 @@ export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     claim: RequestEnvelope;
     admissionOpen(): boolean;
 }>;
-export declare function serveRequest(input: ServeInput): Promise<void>;
+export declare function serveRequest(input: ServeInput): Promise<boolean>;
 export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;
 }

package/build/src/akuma/request-serve.js

@@ -112,14 +112,13 @@ export async function serveRequest(input) {
             state: "refused",
             diagnostic: `request action ${input.claim.action} is not registered`,
         });
-        return;
+        return true;
     }
-    if (await serveCommand(input, command))
-        return;
+    return await serveCommand(input, command);
 }
 async function serveTransportClaim(input) {
     try {
-        await serveRequest(input);
+        return await serveRequest(input);
     }
     catch (error) {
         if (!isRequestInputConflict(error))
@@ -130,6 +129,7 @@ async function serveTransportClaim(input) {
             state: "refused",
             diagnostic: error.message,
         });
+        return true;
     }
 }
 export class BodyRequestPump extends LifecycleBodyRequestPump {

package/build/src/akuma/turn-drive.js

@@ -106,8 +106,9 @@ async function startTurnDrive(input) {
     const attempt = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
         : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+    const custodyFailure = observeFailure(attempt.closed);
     try {
-        const selected = await Promise.race([attempt.result, requests.failure]);
+        const selected = await Promise.race([attempt.result, requests.failure, custodyFailure]);
         if (input.supervisor.signal.aborted) {
             try {
                 const retirement = await retireProviderCustody(input, turn.sequence, attempt);
@@ -132,6 +133,7 @@ async function startTurnDrive(input) {
         return {
             turnSequence: turn.sequence,
             attempt,
+            custodyFailure,
             drive: selected,
             requests,
             cwd,
@@ -212,8 +214,11 @@ function pumpReceipts(writers) {
         }
     })();
 }
+function observeFailure(settlement) {
+    return settlement.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+}
 function observeReceiptFailure(receiptPump) {
-    return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+    return observeFailure(receiptPump);
 }
 function observeCompletionFailure(drive) {
     return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
@@ -306,6 +311,7 @@ async function consumeTurnDrive(input, active) {
                 receiptFailure,
                 requests.failure,
                 completionFailure,
+                active.custodyFailure,
             ]);
             if (next.kind === "completion-failed") {
                 requests.stopAdmission();

package/build/src/body/amend.js

@@ -22,10 +22,11 @@ function operationSections(document) {
         refusal("amend operations contain bytes outside H2 sections");
     }
     return sections(document).map((section) => {
-        const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(section.title.trim());
-        if (!match)
-            refusal(`invalid amend operation heading: ${section.title}`);
-        return { kind: match[1], target: match[2].trim(), section };
+        const title = section.title.trim();
+        const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(title);
+        return match
+            ? { kind: match[1], target: match[2].trim(), section }
+            : { kind: "Set", target: title, section };
     });
 }
 function prose(document, section, label) {
@@ -112,7 +113,7 @@ function completeBody(body) {
         objective: body.objective,
         design: body.design,
         region: body.region,
-        criteria: body.criteria.filter((criterion) => criterion !== undefined),
+        criteria: body.criteria,
         verification: body.verification,
         extensions: body.extensions.filter((extension) => extension !== undefined),
     };
@@ -137,15 +138,6 @@ function alteredText(body, target, value) {
 }
 function applyRemove(body, operation, document) {
     requireEmpty(document, operation.section);
-    if (operation.target.startsWith("Criterion ")) {
-        const title = operation.target.slice("Criterion ".length);
-        const index = criterionIndex(body, title);
-        if (index < 0)
-            refusal(`unknown criterion '${title}'`);
-        body.criteria[index] = undefined;
-        body.criterionIndexes.delete(normalizeTitle(title));
-        return;
-    }
     const index = extensionIndex(body, operation.target);
     if (index < 0)
         refusal(`unknown extension '${operation.target}'`);
@@ -236,6 +228,13 @@ function applyReplace(body, operation, document) {
     const extension = body.extensions[index];
     body.extensions[index] = { ...extension, content: prose(document, operation.section, "extension") };
 }
+function applySet(body, operation, document) {
+    if (contractSectionName(operation.target) !== null || extensionIndex(body, operation.target) >= 0) {
+        applyReplace(body, operation, document);
+        return;
+    }
+    applyAdd(body, operation, document);
+}
 function applyOperation(body, operation, document) {
     switch (operation.kind) {
         case "Add":
@@ -253,13 +252,13 @@ function applyOperation(body, operation, document) {
         case "Remove":
             applyRemove(body, operation, document);
             return;
+        case "Set":
+            applySet(body, operation, document);
+            return;
     }
 }
 function operationKey(operation) {
-    const target = operation.target.startsWith("Criterion ")
-        ? `Criterion ${normalizeTitle(operation.target.slice("Criterion ".length))}`
-        : operation.target;
-    return `${operation.kind}:${target}`;
+    return `${operation.kind}:${operation.target}`;
 }
 function apply(source, current) {
     const document = parseToAST(source);
@@ -274,7 +273,7 @@ function apply(source, current) {
         if (seen.has(key))
             refusal(`duplicate amend operation '${key}'`);
         seen.add(key);
-        changed.add(normalizeTitle(operation.target.startsWith("Criterion ") ? "Criteria" : operation.target));
+        changed.add(normalizeTitle(operation.target));
         applyOperation(body, operation, document);
     }
     return { body: completeBody(body), changed };

package/build/src/cli/commands/akuma.js

@@ -25,7 +25,7 @@ const AKUMA_COMMAND_SPECS = {
             "--contract dispatches the born Akuma to that Contract.",
             "--alias assigns the world-local @name selector to the born Akuma.",
             "--readonly adds the one-way read-only birth restriction.",
-            "Repeated --allowed adds actions to the Archetype defaults.",
+            "Repeated --allowed adds actions to the selected Akuma's defaults.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
     },
@@ -76,7 +76,7 @@ export function isParsedAkumaCommand(command) {
     return isAkumaAction(command.command) && !("contract" in command && command.command === "history");
 }
 export function renderAkumaRootRows() {
-    return Object.entries(AKUMA_COMMAND_SPECS).map(([action, spec]) => `  keiyaku ${action}  ${spec.purpose}`);
+    return Object.entries(AKUMA_COMMAND_SPECS).map(([action, spec]) => `  ${action.padEnd(10)} ${spec.purpose}`);
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];

package/build/src/cli/commands/contract-invoke.js

@@ -26,13 +26,12 @@ async function selectedGitPolicy(value) {
     const { requireBranchesToBeUpToDateFrom, SettingsError } = await import("../../library/configuration.js");
     return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }), SettingsError);
 }
-async function selectContract(repo, selector, scope, execution) {
+async function selectContract(repo, selector, scope, library) {
     const { contractFromInput, resolveContextualContract } = await import("../selectors.js");
-    if (selector !== undefined && !selector.startsWith("@"))
-        return contractFromInput(repo, selector, execution);
-    const { Keiyaku } = await import("../../library/keiyaku.js");
-    const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
-    return contractFromInput(repo, id, execution);
+    const id = selector !== undefined && !selector.startsWith("@")
+        ? contractFromInput(repo, selector).id
+        : resolveContextualContract(await library.list({ repo }), selector, scope);
+    return { id, contract: library.of({ repo, id }) };
 }
 async function bindDraftReceipt(establishWorld, markdown) {
     const { preserveBindDraft } = await import("../draft.js");
@@ -99,22 +98,19 @@ function deliverRefusal(refusal) {
     const submodules = "submodules" in refusal && Array.isArray(refusal.submodules) ? refusal.submodules : [];
     return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
 }
-async function existingSeat(input, parsed) {
-    const { repo, edge, scope, hooks, execution } = input;
-    const { id, contract } = await selectContract(repo, parsed.contract, scope, execution);
-    const actor = actorFromEdge(parsed.actor, edge.environment);
+async function existingSeat(input, parsed, library) {
+    const { repo, edge, scope, hooks } = input;
+    const { id, contract } = await selectContract(repo, parsed.contract, scope, library);
+    const actor = "actor" in parsed ? actorFromEdge(parsed.actor, edge.environment) : undefined;
     return { contract, id, ...(actor === undefined ? {} : { actor }), ...(hooks === undefined ? {} : { hooks }) };
 }
-async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
+async function invokeDeliver(parsed, seat) {
     const { acceptedDeliver } = await import("../accepted.js");
     try {
         const delivered = await seat.contract.deliver({
-            ...(seat.actor === undefined ? {} : { actor: seat.actor }),
             ...(parsed.message === undefined ? {} : { message: parsed.message }),
-            requireBranchesToBeUpToDate,
             includeDirty: parsed.includeDirty,
             materializeConflict: parsed.materializeConflict,
-            ...(seat.hooks === undefined ? {} : { hooks: seat.hooks }),
         });
         if (!("facts" in delivered))
             return delivered;
@@ -135,16 +131,29 @@ async function invokeReview(parsed, seat, readStdin) {
     const { acceptedReview, resultFromMutationCall } = await import("../accepted.js");
     return resultFromMutationCall("review", () => seat.contract.review({
         verdict: parsed.verdict,
-        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
         ...(summary === undefined ? {} : { summary }),
-        ...(seat.hooks === undefined ? {} : { hooks: seat.hooks }),
     }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
 }
+async function contractLibrary(input, parsed) {
+    const { configuration, edge, hooks } = input;
+    if (input.execution.channel.kind !== "local" || !["audit", "deliver", "review"].includes(parsed.command)) {
+        const { Keiyaku } = await import("../../library/keiyaku.js");
+        return Keiyaku.withExecution({ execution: input.execution });
+    }
+    const requireBranchesToBeUpToDate = parsed.command !== "review" && configuration !== undefined ? await selectedGitPolicy(configuration) : false;
+    const actor = actorFromEdge(undefined, edge.environment);
+    const { Keiyaku } = await import("../../library/keiyaku.js");
+    return Keiyaku.withLocal({
+        ...(actor === undefined ? {} : { actor }),
+        ...(hooks === undefined ? {} : { hooks }),
+        requireBranchesToBeUpToDate,
+    });
+}
 export async function invokeContractMutation(input) {
     const { parsed, repo, edge, configuration, hooks } = input;
     if (parsed.command === "bind")
         return invokeBind(input);
-    const seat = await existingSeat(input, parsed);
+    const seat = await existingSeat(input, parsed, await contractLibrary(input, parsed));
     const { id, contract, actor } = seat;
     switch (parsed.command) {
         case "amend": {
@@ -165,7 +174,7 @@ export async function invokeContractMutation(input) {
             }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
-            return invokeDeliver(parsed, seat, configuration === undefined ? false : await selectedGitPolicy(configuration));
+            return invokeDeliver(parsed, seat);
         case "review":
             return invokeReview(parsed, seat, edge.readStdin);
         case "arc": {
@@ -186,14 +195,10 @@ export async function invokeContractMutation(input) {
             }), (result) => acceptedAbandon(result, id), { coordinate: id });
         }
         case "audit": {
-            const requireBranchesToBeUpToDate = configuration === undefined ? false : await selectedGitPolicy(configuration);
             const { acceptedAudit, resultFromMutationCall } = await import("../accepted.js");
             return resultFromMutationCall("audit", () => contract.audit({
-                ...(actor === undefined ? {} : { actor }),
                 includeDirty: parsed.includeDirty,
                 showDiff: parsed.showDiff,
-                requireBranchesToBeUpToDate,
-                ...(hooks === undefined ? {} : { hooks }),
             }), (result) => acceptedAudit(result, id), { coordinate: id });
         }
     }

package/build/src/cli/commands/contract.d.ts

@@ -30,14 +30,14 @@ export type ParsedAmend = Output & Actor & Readonly<{
     gates?: readonly string[];
     stdin?: true;
 }>;
-export type ParsedDeliver = Output & Actor & Readonly<{
+export type ParsedDeliver = Output & Readonly<{
     command: "deliver";
     contract?: string;
     message?: string;
     includeDirty: boolean;
     materializeConflict: boolean;
 }>;
-export type ParsedReview = Output & Actor & Readonly<{
+export type ParsedReview = Output & Readonly<{
     command: "review";
     contract?: string;
     verdict: "satisfied" | "unsatisfied";
@@ -72,7 +72,6 @@ export type ParsedAudit = Output & Readonly<{
     contract?: string;
     includeDirty: boolean;
     showDiff: boolean;
-    actor?: string;
 }>;
 export type ParsedReconcile = Output & Readonly<{
     command: "reconcile";
@@ -129,13 +128,12 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
-            readonly actor: "value";
             readonly message: "value";
             readonly "include-dirty": "boolean";
             readonly "materialize-conflict": "boolean";
             readonly json: "boolean";
         };
-        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--actor <actor>] [--json]";
+        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]";
         readonly purpose: "Deliver one Contract candidate from the appointed worktree.";
         readonly details: string;
     };
@@ -143,13 +141,12 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "optional";
         readonly flags: {
-            readonly actor: "value";
             readonly satisfied: "boolean";
             readonly unsatisfied: "boolean";
             readonly summary: "value";
             readonly json: "boolean";
         };
-        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]";
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]";
         readonly purpose: "Record one review verdict.";
     };
     readonly arc: {
@@ -206,10 +203,9 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly flags: {
             readonly "include-dirty": "boolean";
             readonly diff: "boolean";
-            readonly actor: "value";
             readonly json: "boolean";
         };
-        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]";
+        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--json]";
         readonly purpose: "Ask what candidate preparation, Verification, and target placement would do.";
     };
     readonly reconcile: {
@@ -239,7 +235,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "settings [--json]";
-        readonly purpose: "Read user and project Settings resources.";
+        readonly purpose: "Show effective Settings (user + project, read-only)";
     };
     readonly region: {
         readonly positional: "optional";