@astrosheep/keiyaku 4.6.6 → 4.6.8

package/build/src/protocol/bind.js

@@ -67,7 +67,7 @@ async function assembleBindInput(input, selection, seed, prepared) {
     };
 }
 export async function bindOperation(input) {
-    let selection = input.targetSelection ?? { kind: "targetless" };
+    let selection = input.targetSelection;
     if (selection.kind === "explicit") {
         const normalized = await normalizeTargetBranch(input.scope, selection.target);
         if (normalized === null)

package/build/src/protocol/deliver.js

@@ -6,13 +6,13 @@ import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegrat
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { checkoutDetachedSnapshot, recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, conflictRecovery, } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, protocolSeatClose, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { currentVerifiedAttestation } from "./intent.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, recordedIntegrationSnapshots, timestamp } from "./operations.js";
+import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
 export const deliverLeadingSchema = z
     .object({
     kind: z.enum(["admitted-now", "already-admitted"]),
@@ -418,7 +418,7 @@ async function deliverAttempt(input, attempt) {
         if (assembled.kind === "stale")
             return STALE_PRIVATE_STATE_PREPARATION;
         return await decideAndAdmitDelivery(input, attempt, seat, observation, assembled);
-    }, attemptDecisionWithSeatClose);
+    }, protocolSeatClose);
 }
 function isIntegrationConflict(refusal) {
     return refusal.kind === "integration-failed" && refusal.reason === "conflict";

package/build/src/protocol/operations.d.ts

@@ -2,7 +2,6 @@ import { z } from "zod";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
 import type { ActorId, ContractId, ContractState, DeliverData, DocumentKey, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { IntegrationPreparationRefusal } from "../git/integration.js";
-import { type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
@@ -389,8 +388,8 @@ export declare const intentRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodEnum<{
-        "unborn-head": "unborn-head";
         "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
         "invalid-target": "invalid-target";
     }>;
 }, z.core.$strict>, z.ZodObject<{
@@ -630,7 +629,6 @@ export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission
     kind: "publication-failed";
 }>;
 export declare function timestamp(): string;
-export declare function attemptDecisionWithSeatClose<Value, Refusal = IntentRefusal>(outcome: PrivateStateSeatOutcome<AttemptDecision<Value, Refusal>>): AttemptDecision<Value, Refusal>;
 export declare function unpackVerificationOutcome(verification: VerificationResult): Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;

package/build/src/protocol/operations.js

@@ -4,7 +4,6 @@ import { gate } from "../core/facts/types.js";
 import { changeIdSchema, contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 import { integrationPreparationRefusalSchema, readDeliveryDiff } from "../git/integration.js";
 import { currentBranch, observeContractAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { repositoryAt } from "../git/repository.js";
 import { checkoutNotFollowableRefusalSchema } from "../git/target-placement.js";
@@ -216,13 +215,6 @@ export const placementStopSchema = z.union([
 export function timestamp() {
     return new Date().toISOString();
 }
-export function attemptDecisionWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;

package/build/src/protocol/outcome.d.ts

@@ -1,7 +1,7 @@
 import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
 import type { WorktreeLeak } from "../git/scratch.js";
 import type { ReconcileResult } from "../git/reconcile.js";
-import { type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
+import type { PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { AcceptedAdmission } from "./attempt.js";
 import type { VerificationCleanupFailure } from "./intent.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
@@ -38,5 +38,4 @@ export type IntentOutcome<Value, Refusal = never> = Readonly<{
 export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult, obligations?: AcceptedObligations): IntentOutcome<Value, Refusal>;
 export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
 export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;
-export declare function intentOutcomeWithSeatClose<Value, Refusal>(outcome: PrivateStateSeatOutcome<IntentOutcome<Value, Refusal>>): IntentOutcome<Value, Refusal>;
 export {};

package/build/src/protocol/outcome.js

@@ -1,4 +1,3 @@
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 export function accepted(state, facts, value, physical, obligations) {
     if (state.head === null)
         throw new Error("accepted contract is missing its journal head");
@@ -16,12 +15,8 @@ export function accepted(state, facts, value, physical, obligations) {
 function seatCloseObligations(seatClose) {
     return seatClose === undefined || seatClose.length === 0 ? {} : { seatClose };
 }
-function admissionObligations(admission) {
-    const seatClose = admission.seatClose;
-    return seatClose === undefined || seatClose.length === 0 ? undefined : { seatClose };
-}
 export function admitted(admission, value) {
-    return accepted(admission.state, admission.facts, value, admission.physical, admissionObligations(admission));
+    return accepted(admission.state, admission.facts, value, admission.physical, admission.seatClose === undefined ? undefined : { seatClose: admission.seatClose });
 }
 export function complete(result, value) {
     if (result.kind === "refused")
@@ -30,10 +25,3 @@ export function complete(result, value) {
         return { kind: "retry", reason: result };
     return admitted(result, value);
 }
-export function intentOutcomeWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}

package/build/src/protocol/placement.js

@@ -3,12 +3,12 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeContractsForAdmissionAt, observeGitForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
 import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, prepareTargetPlacementChanges, observeTargetHead, observedTreeEqualsCandidate, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { prepareProtocolAttempt, runProtocol } from "./run.js";
+import { prepareProtocolAttempt, protocolSeatClose, runProtocol, } from "./run.js";
 export { observeTargetPlacement } from "../git/target-placement.js";
 export async function observeIntegrationTargetMovement(repository, state) {
     const target = state.coordinates.target;
@@ -39,13 +39,6 @@ function expectedOperationalDiagnostic(error) {
 function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
-function placementResultWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 async function placementChangesHint(repository, channel, contractId) {
     const observation = await observeContractsForAdmissionAt(repository, channel, [contractId]);
     const state = contractState(observation.decision, contractId);
@@ -63,7 +56,7 @@ async function runFencedPlacement(repository, input, protocol) {
             (changes?.predecessor !== movement.expectedOid || changes.candidate !== movement.newOid))
             changes = await prepareTargetPlacementChanges(repository, movement);
         let preparedPhysical;
-        const result = placementResultWithSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
             // The hint carries no acceptance authority. Form a fresh semantic offer under the seat.
             const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
             if (prepared.kind !== "offered")

package/build/src/protocol/read/status.js

@@ -57,9 +57,6 @@ function appointedWorkspace(repository, register, state) {
         ? undefined
         : { contractId: state.id, place: appointed.place, workspace: worktreePath(repository, appointed.place) };
 }
-async function readSelectedHandoffs(observation, workspaces) {
-    return await readConflictHandoffs(observation.repository, observation.readBlobs, workspaces.flatMap((workspace) => (workspace === undefined ? [] : [workspace])));
-}
 async function managedWorkspaceFacts(repository, state, appointed, targetObservation, handoff) {
     if (appointed === undefined) {
         return {
@@ -101,10 +98,10 @@ function afterEdges(state, endpoints) {
         endpoint: afterEndpoint(endpoints.get(contractId)),
     }));
 }
-function reverseDependents(id, rows) {
-    return rows
-        .filter((row) => row.disposition === "active" && row.after.some((edge) => edge.contractId === id))
-        .map((row) => ({ contractId: row.id, phase: row.phase }))
+function reverseDependents(id, states) {
+    return states
+        .filter(({ state }) => state.terminal === null && state.terms.after.includes(id))
+        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
         .sort((left, right) => left.contractId.localeCompare(right.contractId));
 }
 async function rowFor(input) {
@@ -148,6 +145,25 @@ async function afterEndpointMap(observation, known, ids) {
     const extra = await observeContractsForAdmissionInObservationAt(observation, missing);
     return new Map([...known, ...[...extra.journals].map(([id, record]) => [id, record.state])]);
 }
+async function hydrateRows(observation, states, endpoints, dependentStates = []) {
+    const register = await readPlaceRegister(observation.repository);
+    const selected = states.map((value) => ({
+        ...value,
+        workspace: appointedWorkspace(observation.repository, register, value.state),
+    }));
+    const handoffs = await readConflictHandoffs(observation.repository, observation.readBlobs, selected.flatMap(({ workspace }) => (workspace === undefined ? [] : [workspace])));
+    return await Promise.all(selected.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
+        repository: observation.repository,
+        state,
+        bindAt,
+        lastJournalAt,
+        targetObservation: await observeDeliveryTargetAt(observation, state),
+        workspace,
+        handoff: handoffs.get(state.id),
+        after: afterEdges(state, endpoints),
+        dependents: reverseDependents(state.id, dependentStates),
+    })));
+}
 /** Build the Contract board from one immutable git observation. */
 export async function readContractBoard(observation, include) {
     const observedAt = new Date().toISOString();
@@ -165,29 +181,8 @@ export async function readContractBoard(observation, include) {
             endpoints = new Map(await afterEndpointMap(observation, endpoints, record.state.terms.after));
         }
     }
-    const register = await readPlaceRegister(observation.repository);
-    const selected = [...contracts.values()].flatMap((value) => value.state === null
-        ? []
-        : [
-            {
-                ...value,
-                state: value.state,
-                workspace: appointedWorkspace(observation.repository, register, value.state),
-            },
-        ]);
-    const handoffs = await readSelectedHandoffs(observation, selected.map(({ workspace }) => workspace));
-    const projected = await Promise.all(selected.map(async ({ state, entries, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt: entries[0].at,
-        lastJournalAt: lastJournalAtFor(entries),
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: [],
-    })));
-    const rows = projected.map((row) => ({ ...row, dependents: reverseDependents(row.id, projected) }));
+    const selected = selectedContractStates(contracts);
+    const rows = await hydrateRows(observation, selected, endpoints, selected);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -199,8 +194,8 @@ function compareRecentContracts(left, right) {
     return (right.lastJournalAt.localeCompare(left.lastJournalAt) ||
         Buffer.compare(Buffer.from(left.state.id), Buffer.from(right.state.id)));
 }
-function activeContractStates(contracts) {
-    return [...contracts.values()].flatMap((record) => record.state === null || record.state.terminal !== null
+function selectedContractStates(contracts) {
+    return [...contracts.values()].flatMap((record) => record.state === null
         ? []
         : [
             {
@@ -210,37 +205,15 @@ function activeContractStates(contracts) {
             },
         ]);
 }
-function reverseDependentsFromStates(id, states) {
-    return states
-        .filter(({ state }) => state.terms.after.includes(id))
-        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
-        .sort((left, right) => left.contractId.localeCompare(right.contractId));
-}
 /** Observe a bounded recent active Contract catalogue from one immutable git observation. */
 export async function readContractCatalogue(observation, limit) {
     const observedAt = new Date().toISOString();
     const observed = await observeActiveContractWorld(observation);
-    const active = activeContractStates(observed.contracts);
+    const active = selectedContractStates(observed.contracts).filter(({ state }) => state.terminal === null);
     const selected = projectBoundedList([...active].sort(compareRecentContracts), limit);
     const afterIds = selected.rows.flatMap(({ state }) => state.terms.after);
     const endpoints = await afterEndpointMap(observation, new Map(observed.eligibility), afterIds);
-    const register = await readPlaceRegister(observation.repository);
-    const selectedWorkspaces = selected.rows.map((value) => ({
-        ...value,
-        workspace: appointedWorkspace(observation.repository, register, value.state),
-    }));
-    const handoffs = await readSelectedHandoffs(observation, selectedWorkspaces.map(({ workspace }) => workspace));
-    const rows = await Promise.all(selectedWorkspaces.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt,
-        lastJournalAt,
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: reverseDependentsFromStates(state.id, active),
-    })));
+    const rows = await hydrateRows(observation, selected.rows, endpoints, active);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -270,22 +243,10 @@ export async function readContractObservation(observation, id) {
     if (state === null)
         return { kind: "missing", id };
     const endpoints = await afterEndpointMap(observation, new Map([[id, state]]), state.terms.after);
-    const register = await readPlaceRegister(observation.repository);
-    const workspace = appointedWorkspace(observation.repository, register, state);
-    const handoffs = await readSelectedHandoffs(observation, [workspace]);
+    const rows = await hydrateRows(observation, selectedContractStates(observed.journals), endpoints);
     return {
         kind: "present",
-        row: await rowFor({
-            repository: observation.repository,
-            state,
-            bindAt: record.entries[0].at,
-            lastJournalAt: lastJournalAtFor(record.entries),
-            targetObservation: await observeDeliveryTargetAt(observation, state),
-            workspace,
-            handoff: handoffs.get(state.id),
-            after: afterEdges(state, endpoints),
-            dependents: [],
-        }),
+        row: rows[0],
     };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */

package/build/src/protocol/reintegrate.js

@@ -2,18 +2,11 @@ import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, reusableIntegrationSnapshot, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
-import { externalPreparation, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, protocolSeatClose, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
-function reintegrationResultWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 /** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
 async function prepareExternalReintegration(input) {
     return await externalPreparation({ ...input, scope: input.repository }, (observation, state) => planReintegrationArtifacts(input, state, recordedIntegrationSnapshots(observation.journals.get(state.id)?.entries ?? [])));
@@ -54,7 +47,7 @@ async function runReintegration(input) {
     for (let index = 0; index < attempts.length; index += 1) {
         const attempt = attempts[index];
         const external = await prepareExternalReintegration(input);
-        const result = reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
             const assembled = assembleReintegrationAttempt(input, observation, external);
             if (assembled.kind === "stale")

package/build/src/protocol/review.js

@@ -4,14 +4,14 @@ import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { unmergedWorkspacePaths, worktreePath } from "../git/workspace.js";
-import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, protocolSeatClose, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+import { timestamp } from "./operations.js";
 const REVIEWED = gate("reviewed");
 const reviewWorkspaceEvidenceSchema = workspaceDirtyDeltaSchema
     .extend({ unmergedPaths: z.array(z.string().refine((value) => value.trim() !== "")).readonly() })
@@ -153,7 +153,7 @@ async function reviewAttempt(input, attempt) {
         if (assembled.kind === "stale")
             return STALE_PRIVATE_STATE_PREPARATION;
         return await decideAndAdmitReview(input, attempt, seat, observation, assembled);
-    }, attemptDecisionWithSeatClose);
+    }, protocolSeatClose);
 }
 export async function admitReviewOperation(input) {
     const result = await runBoundedAttempts(mintAttempts({ entryCount: 1 }), (attempt) => reviewAttempt(input, attempt));

package/build/src/protocol/run.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { ProtocolProgress } from "./progress.js";
 import { type GitDecisionObservation } from "../git/observe.js";
-import { type PrivateStatePublicationSeat, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
+import { type PrivateStatePublicationSeat, type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitRefAssertion } from "../git/repository.js";
@@ -177,6 +177,10 @@ export declare function externalPreparation<Artifacts>(input: Readonly<{
     artifacts: Artifacts;
 }>>;
 export declare function privateStateSeatAttempt<T>(repository: GitRepository, action: (seat: PrivateStatePublicationSeat) => Promise<T>, wrap: (outcome: PrivateStateSeatOutcome<T>) => T): Promise<T | AttemptTerminal>;
+export declare function protocolSeatClose<T extends Readonly<{
+    kind: string;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>(outcome: PrivateStateSeatOutcome<T>): T;
 /** Form one decided offer without admitting or reinterpreting it. */
 export declare function prepareProtocolAttempt<Input extends Readonly<{
     contractId: ContractId;

package/build/src/protocol/run.js

@@ -122,7 +122,7 @@ async function admitDecidedProtocolOffer(admission, primaryContract, seat, decis
         assertions: decided.assertions,
     });
 }
-function protocolAttemptWithSeatClose(outcome) {
+export function protocolSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
         if (value.kind !== "accepted")
             throw new Error(closeLag.diagnostic);
@@ -137,7 +137,7 @@ async function runDirectProtocolAttempt(input, attempt) {
             input: input.input,
             assertions: [],
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /**
  * One full attempt: repeatable preparation outside custody, then a single in-custody cycle of
@@ -160,7 +160,7 @@ async function runSplitProtocolAttempt(input, attempt) {
             input: assembled.input,
             assertions,
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /** Form one decided offer without admitting or reinterpreting it. */
 export async function prepareProtocolAttempt(input, baseAttempt) {

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.6.6",
+  "version": "4.6.8",
   "workspaces": [
-    "plugins/*"
+    "plugins/square"
   ],
   "files": [
-    "build"
+    "build",
+    "plugins/pi",
+    "skills"
   ],
   "main": "./build/src/index.js",
   "types": "./build/src/index.d.ts",
@@ -29,7 +31,7 @@
   },
   "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)\"",
+    "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-plugins.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",
     "harness:version": "node scripts/update-harness-version.js",
@@ -73,8 +75,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/keiyaku-plugin-square": "0.1.7",
-    "@astrosheep/square": "^0.3.63",
+    "@astrosheep/keiyaku-plugin-square": "0.1.8",
+    "@astrosheep/square": "^0.3.70",
+    "@getpaseo/client": "0.11.2",
+    "@getpaseo/protocol": "0.11.2",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
@@ -91,10 +95,10 @@
   ],
   "pi": {
     "extensions": [
-      "./build/integrations/pi/keiyaku.ts"
+      "./plugins/pi/keiyaku.ts"
     ],
     "skills": [
-      "./build/integrations/marketplace/plugins/keiyaku/skills"
+      "./skills"
     ]
   },
   "author": "",

package/plugins/pi/keiyaku.ts

@@ -0,0 +1,57 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+type ExecResult = Readonly<{ stdout: string; stderr: string; code: number }>;
+
+async function runStatus(pi: ExtensionAPI): Promise<ExecResult> {
+  return await pi.exec("keiyaku", ["status"]);
+}
+
+function lineForWidth(value: string, width: number): string {
+  const clean = value.replaceAll(/[\u0000-\u001f\u007f]/gu, " ");
+  return clean.length <= width ? clean : `${clean.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function overlay(lines: readonly string[], theme: Theme, done: () => void) {
+  return {
+    invalidate(): void {},
+    handleInput(data: string): void {
+      if (data === "\u001b" || data === "q" || data === "Q" || data === "\r") done();
+    },
+    render(width: number): string[] {
+      const inner = Math.max(1, Math.min(100, width - 2));
+      const border = theme.fg("border", "+");
+      const rule = theme.fg("border", "-".repeat(inner));
+      return [
+        `${border}${rule}${border}`,
+        `${theme.fg("border", "|")}${lineForWidth("Keiyaku", inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        `${theme.fg("border", "|")}${" ".repeat(inner)}${theme.fg("border", "|")}`,
+        ...lines.map(
+          (line) => `${theme.fg("border", "|")}${lineForWidth(line, inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        ),
+        `${theme.fg("border", "|")}${" ".repeat(inner)}${theme.fg("border", "|")}`,
+        `${theme.fg("border", "|")}${lineForWidth("esc/q/enter close", inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        `${border}${rule}${border}`,
+      ];
+    },
+  };
+}
+
+export default function keiyakuExtension(pi: ExtensionAPI): void {
+  pi.registerCommand("keiyaku", {
+    description: "Open the Kanshi world status",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+      let body: string[];
+      try {
+        const result = await runStatus(pi);
+        body = result.code === 0 ? result.stdout.trimEnd().split("\n") : [result.stderr.trim() || "status unavailable"];
+      } catch {
+        body = ["status unavailable"];
+      }
+      await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => overlay(body, theme, done), {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: 100, maxHeight: 40 },
+      });
+    },
+  });
+}

package/skills/keiyaku/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: keiyaku
+description: >-
+  Keiyaku is a CLI that records plans, writes handoff terms for deliveries,
+  and calls delegates. Use this skill when you need to figure out which
+  Keiyaku skill or command to reach for.
+---
+
+# Keiyaku
+
+## Model
+
+Keiyaku is three independent pillars, not a bundle: **Task** remembers plans
+and dependencies, **Contract** makes acceptance standing and auditable,
+**Akuma** invokes capability. Use any one alone; combine them only when the
+work calls for it. Behind every Contract in flight there is one holder of its
+fulfillment loop — whoever turns intent into commissions and returns into
+decisions. The flagship holds it by default, and may hand a whole Contract's
+loop to one Aku in a single commission; the harness serves both styles
+equally. See `keiyaku-workflow` for the loop, `keiyaku-bind` for authoring,
+`keiyaku-akuma` for invocation.
+
+## Quick Start
+
+```bash
+keiyaku -C <repo> task add "title"
+keiyaku -C <repo> task start <task-id>
+keiyaku -C <repo> bind [--task <task-id>] -
+keiyaku -C <repo> status
+keiyaku -C <repo> deliver [<contract>|@<contract>]
+keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
+```
+
+`-C` selects the invocation cwd and therefore the World. `--repo <path>` only
+selects the Contract repository; it never retargets that World. `call
+--workdir <path>` selects execution cwd (relative to the effective invocation
+cwd). Without it, the call uses the invocation cwd; `--contract` associates a
+Contract without selecting an execution directory.
+
+`deliver`, `review`, and `audit` may take time after their leading admission.
+Their witnessed progress is ephemeral stderr output; stdout remains one final
+text or JSON result. Ctrl-C asks the owned operation to stop and waits for its
+truthful final receipt, so it is not evidence that an already admitted action
+was rolled back.