@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/protocol/run.js

@@ -3,16 +3,12 @@ import { appendPrivateStateSeatClose, isPrivateStateSeatContention, mergePrivate
 import { GIT_REF, readRefs } from "../git/repository.js";
 import { admitDecidedOffer } from "./attempt.js";
 export const STALE_PRIVATE_STATE_PREPARATION = {
-    kind: "publication-failed",
-    diagnostic: "stale private-state preparation",
+    kind: "stale",
 };
-export function privateRootCommit(observation) {
-    return observation.admission.snapshot.commit;
+export function contractStateWitness(state) {
+    return { head: state.head };
 }
-export function samePrivateRootObservation(prepared, fresh) {
-    return privateRootCommit(prepared) === privateRootCommit(fresh);
-}
-export function sameSpeculativeWorktreeInput(prepared, fresh) {
+export function sameWorktreeWitness(prepared, fresh) {
     if (prepared === undefined || fresh === undefined)
         return prepared === fresh;
     return (prepared.tree === fresh.tree &&
@@ -32,14 +28,6 @@ export function publicationFailedFromSeatError(error) {
         return { kind: "publication-failed", diagnostic: error.message };
     throw error;
 }
-export async function matchingPrivateRootObservation(repository, channel, contractId, prepared, revalidate) {
-    const fresh = await observeContractsForAdmissionAt(repository, channel, [contractId]);
-    if (!samePrivateRootObservation(prepared, fresh))
-        return STALE_PRIVATE_STATE_PREPARATION;
-    if (revalidate !== undefined && !(await revalidate(fresh)))
-        return STALE_PRIVATE_STATE_PREPARATION;
-    return fresh;
-}
 export async function privateStateSeatAttempt(repository, action, wrap) {
     try {
         return wrap(await withPrivateStatePublicationSeat(repository, action));
@@ -53,30 +41,23 @@ async function observeProtocolDecision(input) {
         ? await observeContractsForAdmissionAt(input.repository, input.channel, input.contracts, input.observationSelection)
         : await input.observe(input.repository, input.channel, input.contracts);
 }
-async function prepareProtocolSeed(input, observation) {
-    if (!("prepareInput" in input) || input.prepareInput === undefined) {
-        return { kind: "prepared", input: input.input, assertions: [] };
-    }
-    const prepared = await input.prepareInput(observation, input.input);
-    return prepared.kind === "refused" ? prepared : { ...prepared, assertions: prepared.assertions ?? [] };
-}
-async function decideDecoratedProtocolOffer(input, baseAttempt, decisionObservation, preparedInput) {
-    const attempt = input.extendAttempt === undefined
-        ? baseAttempt
-        : input.extendAttempt(baseAttempt, decisionObservation.decision.size);
-    const decision = input.decide({
-        input: preparedInput.input,
+async function decideDecoratedProtocolOffer(admission, primaryContract, decisionObservation, prepared) {
+    const attempt = admission.extendAttempt === undefined
+        ? prepared.attempt
+        : admission.extendAttempt(prepared.attempt, decisionObservation.decision.size);
+    const decision = admission.decide({
+        input: prepared.input,
         attempt,
         observation: decisionObservation.decision,
     });
     if (decision.kind === "refused")
         return decision;
-    const companions = input.decorateOffer === undefined
+    const companions = admission.decorateOffer === undefined
         ? []
-        : await input.decorateOffer({
-            repository: input.repository,
+        : await admission.decorateOffer({
+            repository: admission.repository,
             observation: decisionObservation,
-            contractId: input.input.contractId,
+            contractId: primaryContract,
             offer: decision.offer,
         });
     const offer = companions.length === 0
@@ -84,22 +65,31 @@ async function decideDecoratedProtocolOffer(input, baseAttempt, decisionObservat
         : { ...decision.offer, companions: [...(decision.offer.companions ?? []), ...companions] };
     const admissionObservation = companions.length === 0
         ? decisionObservation
-        : await extendAdmissionPathsAt(input.channel, decisionObservation, companions.map(({ path }) => path));
+        : await extendAdmissionPathsAt(admission.channel, decisionObservation, companions.map(({ path }) => path));
     return {
         kind: "offered",
         observation: admissionObservation,
         attempt,
         offer,
-        assertions: preparedInput.assertions,
+        assertions: prepared.assertions,
     };
 }
-/** Form one decided offer without admitting or reinterpreting it. */
-export async function prepareProtocolAttempt(input, baseAttempt) {
-    const decisionObservation = await observeProtocolDecision(input);
-    const preparedInput = await prepareProtocolSeed(input, decisionObservation);
-    if (preparedInput.kind === "refused")
-        return preparedInput;
-    return await decideDecoratedProtocolOffer(input, baseAttempt, decisionObservation, preparedInput);
+async function admitDecidedProtocolOffer(admission, primaryContract, seat, decisionObservation, prepared) {
+    const decided = await decideDecoratedProtocolOffer(admission, primaryContract, decisionObservation, prepared);
+    if (decided.kind === "refused")
+        return decided;
+    return await admitDecidedOffer({
+        channel: admission.channel,
+        repository: admission.repository,
+        seat,
+        decisionObservation: decided.observation,
+        attempt: decided.attempt,
+        offer: decided.offer,
+        primaryContract,
+        ...(admission.progress === undefined ? {} : { progress: admission.progress }),
+        assertions: decided.assertions,
+        ...(admission.validateAdmission === undefined ? {} : { validateAdmission: admission.validateAdmission }),
+    });
 }
 function protocolAttemptWithSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
@@ -108,47 +98,72 @@ function protocolAttemptWithSeatClose(outcome) {
         return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
     });
 }
-async function speculateProtocolAttempt(input) {
-    const observation = await observeProtocolDecision(input);
-    const prepared = await prepareProtocolSeed(input, observation);
-    return prepared.kind === "refused" ? prepared : { observation, ...prepared };
+async function runDirectProtocolAttempt(input, attempt) {
+    return await privateStateSeatAttempt(input.repository, async (seat) => {
+        const observation = await observeProtocolDecision(input);
+        return await admitDecidedProtocolOffer(input, input.input.contractId, seat, observation, {
+            attempt,
+            input: input.input,
+            assertions: [],
+        });
+    }, protocolAttemptWithSeatClose);
+}
+/**
+ * One full attempt: repeatable preparation outside custody, then a single in-custody cycle of
+ * observation, witness validation, assembly, decision, companions, and atomic publication.
+ */
+async function runSplitProtocolAttempt(input, attempt) {
+    const external = await input.preparation.external(input.input);
+    if (external.kind === "refused")
+        return external;
+    return await privateStateSeatAttempt(input.repository, async (seat) => {
+        const observation = await observeProtocolDecision(input);
+        const assembled = await input.preparation.assemble(observation, input.input, external.prepared);
+        if (assembled.kind !== "prepared")
+            return assembled;
+        const assertions = [...(external.assertions ?? []), ...(assembled.assertions ?? [])];
+        if (!(await privateStateAssertionsMatch(input.repository, assertions)))
+            return STALE_PRIVATE_STATE_PREPARATION;
+        return await admitDecidedProtocolOffer(input, input.input.contractId, seat, observation, {
+            attempt,
+            input: assembled.input,
+            assertions,
+        });
+    }, protocolAttemptWithSeatClose);
 }
-async function admitSpeculativeProtocolAttempt(input, seat, speculated, attempt) {
-    const fresh = await observeProtocolDecision(input);
-    if (!samePrivateRootObservation(speculated.observation, fresh) ||
-        !(await privateStateAssertionsMatch(input.repository, speculated.assertions))) {
-        return STALE_PRIVATE_STATE_PREPARATION;
-    }
-    const decided = await decideDecoratedProtocolOffer(input, attempt, fresh, {
-        kind: "prepared",
-        input: speculated.input,
-        assertions: speculated.assertions,
-    });
-    if (decided.kind === "refused")
-        return decided;
-    return await admitDecidedOffer({
-        channel: input.channel,
-        repository: input.repository,
-        seat,
-        decisionObservation: decided.observation,
-        attempt: decided.attempt,
-        offer: decided.offer,
-        primaryContract: input.input.contractId,
-        ...(input.progress === undefined ? {} : input.progress === undefined ? {} : { progress: input.progress }),
-        assertions: decided.assertions,
-        ...(input.validateAdmission === undefined ? {} : { validateAdmission: input.validateAdmission }),
+/** Form one decided offer without admitting or reinterpreting it. */
+export async function prepareProtocolAttempt(input, baseAttempt) {
+    if (input.preparation === undefined)
+        return await prepareDirectProtocolAttempt(input, baseAttempt);
+    const external = await input.preparation.external(input.input);
+    if (external.kind === "refused")
+        return external;
+    const decisionObservation = await observeProtocolDecision(input);
+    const assembled = await input.preparation.assemble(decisionObservation, input.input, external.prepared);
+    if (assembled.kind !== "prepared")
+        return assembled;
+    return await decideDecoratedProtocolOffer(input, input.input.contractId, decisionObservation, {
+        attempt: baseAttempt,
+        input: assembled.input,
+        assertions: [...(external.assertions ?? []), ...(assembled.assertions ?? [])],
     });
 }
-async function runSpeculativeProtocolAttempt(input, speculated, attempt) {
-    if (speculated.kind === "refused")
-        return speculated;
-    return await privateStateSeatAttempt(input.repository, async (seat) => await admitSpeculativeProtocolAttempt(input, seat, speculated, attempt), protocolAttemptWithSeatClose);
+async function prepareDirectProtocolAttempt(input, baseAttempt) {
+    const decisionObservation = await observeProtocolDecision(input);
+    return await decideDecoratedProtocolOffer(input, input.input.contractId, decisionObservation, {
+        attempt: baseAttempt,
+        input: input.input,
+        assertions: [],
+    });
 }
 /** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
 export async function runProtocol(input) {
     const attempts = input.attempts;
     for (let index = 0; index < attempts.length; index += 1) {
-        const result = await runSpeculativeProtocolAttempt(input, await speculateProtocolAttempt(input), attempts[index]);
+        const attempt = attempts[index];
+        const result = input.preparation === undefined
+            ? await runDirectProtocolAttempt(input, attempt)
+            : await runSplitProtocolAttempt(input, attempt);
         if (result.kind === "refused" || result.kind === "accepted" || result.kind === "publication-failed")
             return result;
         if (result.kind === "collision" && index + 1 === attempts.length)

package/build/src/settings.js

@@ -152,9 +152,6 @@ function bundleGates(name, value) {
         if (!gateWord(gate)) {
             throw new SettingsError(`gate bundle '${name}' contains an invalid gate word`);
         }
-        if (gate !== "reviewed" && gate !== "verified") {
-            throw new SettingsError(`gate bundle '${name}' contains a gate without a producer: ${gate}`);
-        }
         return gate;
     });
 }
@@ -167,8 +164,10 @@ export function gatesFrom(input) {
     const names = input.names ?? ["default"];
     for (const name of names) {
         if (!gateWord(name))
-            throw new SettingsError("gate bundle name must match ^[a-z][a-z0-9-]{0,63}$");
+            throw new SettingsError("gate or bundle name must match ^[a-z][a-z0-9-]{0,63}$");
     }
+    if (names.length === 0)
+        return Object.freeze([]);
     const view = input.settings.namespace("gates");
     if (view.kind === "failed")
         namespaceFailure(view);
@@ -176,16 +175,8 @@ export function gatesFrom(input) {
     const seen = new Set();
     for (const name of names) {
         const selected = view.entries.find((entry) => entry.name === name);
-        if (selected === undefined) {
-            if (input.names === undefined) {
-                if (!seen.has("reviewed"))
-                    expanded.push("reviewed");
-                seen.add("reviewed");
-                continue;
-            }
-            throw new SettingsError(`unknown gate bundle: ${name}`);
-        }
-        for (const gate of bundleGates(name, selected.value)) {
+        const gates = selected === undefined ? [input.names === undefined ? "reviewed" : name] : bundleGates(name, selected.value);
+        for (const gate of gates) {
             if (seen.has(gate))
                 continue;
             seen.add(gate);

package/build/src/task/document.d.ts

@@ -18,7 +18,11 @@ export type TaskDocument = Readonly<{
 }>;
 export type TaskCreationDocument = Omit<TaskDocument, "id" | "createdBy" | "createdAt" | "updatedAt">;
 export declare class TaskAuthorityCorruptionError extends Error {
-    constructor(message: string, options?: ErrorOptions);
+    /** The Task document whose bytes failed decode, when the reader knew its coordinate. */
+    readonly coordinate?: TaskId;
+    constructor(message: string, options?: ErrorOptions & {
+        coordinate?: TaskId;
+    });
 }
 export declare function parseTaskDocument(bytes: Uint8Array, expected: TaskCoordinate): TaskDocument;
 export declare function parseTaskCreationDocument(markdown: string): TaskCreationDocument;

package/build/src/task/document.js

@@ -1,9 +1,13 @@
 import { isMap, parseDocument, stringify } from "yaml";
 import { formatTaskId, parseTaskId } from "./identity.js";
 export class TaskAuthorityCorruptionError extends Error {
+    /** The Task document whose bytes failed decode, when the reader knew its coordinate. */
+    coordinate;
     constructor(message, options) {
         super(message, options);
         this.name = "TaskAuthorityCorruptionError";
+        if (options?.coordinate !== undefined)
+            this.coordinate = options.coordinate;
     }
 }
 const STATES = new Set(["open", "in_progress", "on_hold", "done", "drop"]);
@@ -107,8 +111,9 @@ function fields(value, body, fail) {
     };
 }
 export function parseTaskDocument(bytes, expected) {
+    const coordinate = formatTaskId(expected);
     const fail = (message, cause) => {
-        throw new TaskAuthorityCorruptionError(message, cause === undefined ? {} : { cause });
+        throw new TaskAuthorityCorruptionError(message, { coordinate, ...(cause === undefined ? {} : { cause }) });
     };
     const { value, body } = frontMatter(Buffer.from(bytes).toString("utf8"), fail);
     closed(value, STORED_KEYS, REQUIRED_STORED_KEYS, fail);

package/build/src/verification/execution.d.ts

@@ -50,7 +50,6 @@ export type ExecuteVerificationInput = Readonly<{
     declarations: readonly VerificationDeclaration[];
     materializeScratchCandidate: (repository: GitRepository, candidate: SnapshotId) => Promise<MaterializedScratchCandidate>;
     projectSettings: (root: string) => Promise<Settings>;
-    environmentSource?: string;
     observe?: (event: VerificationObservation) => void;
     signal?: AbortSignal;
 }>;

package/build/src/verification/execution.js

@@ -1,6 +1,5 @@
 import { runHookCommands, worktreeHooksFrom } from "../git/hooks.js";
 import { runProcess } from "../runtime/proc/run.js";
-import { inheritVerificationEnvironment } from "../git/verification-environment.js";
 const SUMMARY_BYTES = 32 * 1024;
 export function capturedOutput(value) {
     return {
@@ -137,32 +136,9 @@ async function materializeScratch(input) {
         };
     }
 }
-async function inheritEnvironment(input, cwd) {
-    const coordinate = {
-        phase: "environment",
-        cwd,
-        ...(input.environmentSource === undefined ? {} : { source: input.environmentSource }),
-    };
-    observe(input, { kind: "phase", ...coordinate, state: "started" });
-    try {
-        if (input.environmentSource !== undefined)
-            await inheritVerificationEnvironment(input.repository, input.environmentSource, cwd, input.signal);
-        observe(input, { kind: "phase", ...coordinate, state: "finished", outcome: "ok" });
-    }
-    catch (error) {
-        observe(input, {
-            kind: "phase",
-            ...coordinate,
-            state: "finished",
-            outcome: input.signal?.aborted ? "cancelled" : "failed",
-        });
-        throw error;
-    }
-}
 async function runScratch(input, scratch) {
     try {
         input.signal?.throwIfAborted();
-        await inheritEnvironment(input, scratch.cwd);
         const hooks = worktreeHooksFrom({ settings: await input.projectSettings(scratch.cwd) });
         const readiness = await observedHooks({
             execution: input,

package/build/src/verification/observation.d.ts

@@ -9,12 +9,10 @@ export declare const verificationObservationSchema: z.ZodDiscriminatedUnion<[z.Z
     phase: z.ZodEnum<{
         cleanup: "cleanup";
         materialize: "materialize";
-        environment: "environment";
         setup: "setup";
         declaration: "declaration";
     }>;
     cwd: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
     command: z.ZodOptional<z.ZodString>;
     index: z.ZodOptional<z.ZodNumber>;
@@ -29,12 +27,10 @@ export declare const verificationObservationSchema: z.ZodDiscriminatedUnion<[z.Z
     phase: z.ZodEnum<{
         cleanup: "cleanup";
         materialize: "materialize";
-        environment: "environment";
         setup: "setup";
         declaration: "declaration";
     }>;
     cwd: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
     command: z.ZodOptional<z.ZodString>;
     index: z.ZodOptional<z.ZodNumber>;

package/build/src/verification/observation.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
-const phase = z.enum(["materialize", "environment", "setup", "declaration", "cleanup"]);
+const phase = z.enum(["materialize", "setup", "declaration", "cleanup"]);
 const coordinate = {
     phase,
     cwd: z.string().optional(),
-    source: z.string().optional(),
     name: z.string().optional(),
     command: z.string().optional(),
     index: z.number().int().positive().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.20",
+  "version": "4.5.21",
   "workspaces": [
     "plugins/*"
   ],
@@ -39,6 +39,7 @@
     "node": ">=22.19.0"
   },
   "scripts": {
+    "release": "npm run test:release && npm version patch && npm publish",
     "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('build', { recursive: true, force: true })\" && tsc -p tsconfig.json && npm run build --workspace @astrosheep/keiyaku-plugin-square && node scripts/copy-integrations.js && node scripts/build-windows-launcher.js && node --input-type=module -e \"import { chmodSync } from 'node:fs'; chmodSync('build/src/cli/index.js', 0o755)\"",
     "prepack": "node scripts/verify-package.js",
     "postpack": "node scripts/verify-package.js",
@@ -80,6 +81,7 @@
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
     "@astrosheep/keiyaku-plugin-square": "0.1.5",
+    "@astrosheep/square": "^0.3.50",
     "@earendil-works/pi-coding-agent": "0.85.1",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",

package/build/src/git/verification-environment.d.ts

@@ -1,10 +0,0 @@
-import { type GitRepository } from "./process.js";
-/** A source or destination filesystem shape that cannot safely be inherited. */
-export declare class VerificationEnvironmentError extends Error {
-    constructor(message: string);
-}
-/**
- * Copy the selected appointment's ignored and untracked execution state into a
- * materialized candidate without changing either Git worktree's authority.
- */
-export declare function inheritVerificationEnvironment(repository: GitRepository, source: string, destination: string, signal?: AbortSignal): Promise<void>;