@astrosheep/keiyaku 4.5.0 → 4.5.2

package/build/src/cli/render/status-set.js

@@ -0,0 +1,14 @@
+import { renderAkumaText } from "./akuma.js";
+import { renderKanshiText } from "./kanshi.js";
+export function renderStatusSetText(result, context) {
+    return result.entries
+        .map((entry) => entry.kind === "contract"
+        ? renderKanshiText(entry.report, context, "contract")
+        : renderAkumaText({ command: "status", contract: entry.selector, akuma: true, output: "text" }, {
+            kind: "akuma",
+            action: "status",
+            status: entry.status,
+            ...(entry.alias === undefined ? {} : { alias: entry.alias }),
+        }, context))
+        .join("\n\n");
+}

package/build/src/cli/render/text.js

@@ -5,11 +5,14 @@ import { renderConflictMaterialized, renderRefusal } from "./refusal.js";
 import { renderCatalogText } from "./catalog.js";
 import { renderNukeText } from "./nuke.js";
 import { renderRegionText } from "./region.js";
+import { renderStatusSetText } from "./status-set.js";
 export function renderText(result, context) {
     if (result.kind === "guidance")
         return result.guidance;
     if (result.kind === "status")
         return renderKanshiText(result.report, context, result.selection);
+    if (result.kind === "status-set")
+        return renderStatusSetText(result, context);
     if (result.kind === "catalog")
         return renderCatalogText(result.catalog);
     if (result.kind === "contract-history")

package/build/src/cli/result.d.ts

@@ -1,5 +1,6 @@
 import type { AuditReport, ContractHistory, ContractId, ContinuationReport, Delivery, Fact, IntegrationConflictMaterialized, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
+import type { AkumaObservation } from "../index.js";
 import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
 import type { AmendRegionObservation, RegionObservation } from "../library/region.js";
@@ -211,6 +212,19 @@ export type StatusResult = Readonly<{
     report: KanshiReport;
     selection: "world" | "contract";
 }>;
+export type StatusSetResult = Readonly<{
+    kind: "status-set";
+    entries: readonly (Readonly<{
+        selector: string;
+        kind: "contract";
+        report: KanshiReport;
+    }> | Readonly<{
+        selector: string;
+        kind: "akuma";
+        status: AkumaObservation;
+        alias?: string;
+    }>)[];
+}>;
 export type RegionResult = Readonly<{
     kind: "region";
     region: Section<RegionRead>;
@@ -227,5 +241,5 @@ export type NukeInvocationResult = Readonly<{
     kind: "nuke";
     result: NukeResult;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult | NukeInvocationResult | IntegrationConflictMaterialized;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | StatusSetResult | RegionResult | CatalogResult | ContractHistoryResult | NukeInvocationResult | IntegrationConflictMaterialized;
 export {};

package/build/src/cli/runtime.js

@@ -79,6 +79,8 @@ function invocationJson(result) {
             return result.history;
         case "status":
             return result.report;
+        case "status-set":
+            return result.entries;
         default:
             return result;
     }

package/build/src/cli/square-edge.d.ts

@@ -1,6 +1,7 @@
 import type { AllocatedAkuma } from "../akuma/identity.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 export declare function recognizeAndListen(worldRoot: WorldRoot, environment: NodeJS.ProcessEnv, allocated: AllocatedAkuma): Promise<{
     committed: boolean;
+    participantName: string;
     rollback(): Promise<void>;
 } | void>;

package/build/src/cli/square-edge.js

@@ -1,47 +1,74 @@
-import { Square } from "@astrosheep/square";
-import { join } from "node:path";
-export async function recognizeAndListen(worldRoot, environment, allocated) {
-    const path = join(worldRoot, ".square", "PUBLIC.square");
-    let square;
+import { bindCurrentParticipant, Square, squareAssignedParticipantName, unbindCurrentParticipant, } from "@astrosheep/square";
+import { keiyakuSquarePath } from "../world.js";
+async function openKeiyakuSquare(path) {
     try {
-        square = await Square.at({ path });
+        return await Square.at({ path });
     }
     catch (error) {
-        if (error.code === "ENOENT" || error.code === "unavailable")
-            return;
-        throw error;
+        if (error.code !== "ENOENT" && error.code !== "unavailable")
+            throw error;
+        try {
+            return await Square.build({ path, markdown: "" });
+        }
+        catch (buildError) {
+            try {
+                return await Square.at({ path });
+            }
+            catch {
+                throw buildError;
+            }
+        }
     }
+}
+export async function recognizeAndListen(worldRoot, environment, allocated) {
+    const name = squareAssignedParticipantName(environment);
+    if (name === undefined)
+        return;
+    const path = keiyakuSquarePath(worldRoot);
+    const square = await openKeiyakuSquare(path);
+    let joined = false;
+    let bound = false;
+    let listening = false;
+    const rollback = async () => {
+        if (listening || joined) {
+            const rollbackSquare = await Square.at({ path });
+            try {
+                const rollbackParticipant = await rollbackSquare.join(name);
+                if (listening)
+                    await rollbackParticipant.ignore(allocated.id);
+                if (joined)
+                    await rollbackParticipant.done();
+            }
+            finally {
+                await rollbackSquare.close();
+            }
+        }
+        if (bound)
+            unbindCurrentParticipant(path, name, environment);
+    };
     try {
-        const recognize = square.recognize;
-        if (recognize === undefined)
-            return;
-        const participant = await recognize.call(square, environment);
-        if (participant === null)
-            return;
+        const joinedResult = await square.joinWithActivity(name);
+        joined = joinedResult.activity !== null;
+        const participant = joinedResult.participant;
+        bound = bindCurrentParticipant(path, name, environment).created;
         const listener = participant;
         const change = await listener.listen(allocated.id);
-        if (change.activity === null)
-            return;
+        listening = change.activity !== null;
         return {
             committed: true,
-            rollback: async () => {
-                const rollbackSquare = await Square.at({ path });
-                try {
-                    const current = rollbackSquare
-                        .recognize;
-                    if (current === undefined)
-                        return;
-                    const rollbackParticipant = await current.call(rollbackSquare, environment);
-                    if (rollbackParticipant === null)
-                        return;
-                    await rollbackParticipant.ignore(allocated.id);
-                }
-                finally {
-                    await rollbackSquare.close();
-                }
-            },
+            participantName: name,
+            rollback,
         };
     }
+    catch (error) {
+        try {
+            await rollback();
+        }
+        catch {
+            /* preserve the original Square edge failure */
+        }
+        throw error;
+    }
     finally {
         await square.close();
     }

package/build/src/contract-worktree.js

@@ -50,11 +50,16 @@ const FULFILLMENT = [
     "",
     "### Deliverer",
     "",
+    "Re-read this file on each wake-up; it may have been updated between sessions.",
     "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
+    "Region is a rough intent, not a hard boundary — natural ripple outside it is fine and not a blocker.",
     "When an Arc is active, stay within that current chapter.",
-    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` " + "to organize and manage Tasks.",
+    "If you discover a contradiction with this Contract or an unclosed point in its terms,",
+    "stop and report it before continuing.",
+    "",
+    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` to organize and manage Tasks.",
     "Promptly update progress for Tasks already present in the current worktree.",
-    "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.",
+    "",
     "Deliver from this worktree. A clean worktree delivers HEAD; uncommitted work",
     "needs `deliver --include-dirty`, which captures the final non-ignored tree and",
     "stages or commits nothing. If deliver reports a conflict, run",
@@ -64,9 +69,17 @@ const FULFILLMENT = [
     "",
     "### Reviewer",
     "",
-    "Review this Contract worktree against the complete Contract.",
-    "Review the complete current worktree snapshot, not a named candidate commit.",
-    "Do not modify it; report covered Criteria, findings, and missing evidence.",
+    "Re-read this file on each wake-up; it may have been updated between sessions.",
+    "Review the complete current worktree snapshot against this Contract. Do not modify it.",
+    "Understand the original intent behind the Objective, not just its literal text.",
+    "Region is a rough intent, not a hard boundary — natural ripple outside it is not a blocker.",
+    "Compare each Criterion individually against the delivered work.",
+    "Consolidate findings by root cause — group symptoms that share an underlying issue",
+    "rather than listing each occurrence separately.",
+    "Dig to the architectural or structural root; flag it directly rather than routing around it.",
+    "If you discover a contradiction within the Contract or an unclosed point in its terms,",
+    "report it as a finding.",
+    "Report covered Criteria, findings, and missing evidence.",
 ].join("\n");
 export function renderContractGuidance(state) {
     return [

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

@@ -99,6 +99,6 @@ export type ForkResult = Readonly<{
     parent: AkuId;
 }>);
 export declare function beginCall(input: CallInput): Promise<BornCall>;
-export declare function finishCall(born: BornCall): Promise<CallResult>;
+export declare function finishCall(born: BornCall, participantName?: string): Promise<CallResult>;
 export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -236,9 +236,13 @@ export async function beginCall(input) {
         alias: aliasStage,
     };
 }
-export async function finishCall(born) {
+export async function finishCall(born, participantName) {
     const world = akumaWorld(born.path);
-    const handle = await finishAkumaCall(world, born.born);
+    const contractId = born.dispatch.kind === "dispatched" ? born.dispatch.dispatch.contractId : undefined;
+    const handle = await finishAkumaCall(world, born.born, {
+        ...(participantName === undefined ? {} : { participantName }),
+        ...(contractId === undefined ? {} : { contractId }),
+    });
     const readonly = (await handle.status()).readonly;
     const observation = await observeCall(handle, born.mode, born.timeoutMs);
     return {

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

@@ -1,4 +1,4 @@
-import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
+import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
 import type { ContractId } from "../core/facts/types.js";
 import type { TaskRow } from "../task/index.js";
 import type { WorldRoot } from "../world.js";
@@ -69,6 +69,7 @@ export type AkumaInterruptResult = Readonly<{
     observation: AkumaObservationStage;
 }>;
 export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
+    id?: string;
     before?: number;
     since?: number;
     limit?: number;
@@ -79,6 +80,16 @@ export type AkumaHistoryResult = Readonly<{
     id: AkumaStatus["id"];
     history: ActivityHistory;
     contract: DispatchAssociation;
+}> | Readonly<{
+    kind: "exact";
+    id: AkumaStatus["id"];
+    outcome: OutcomeRow;
+    contract: DispatchAssociation;
+}> | Readonly<{
+    kind: "unknown-history";
+    id: AkumaStatus["id"];
+    historyId: string;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "last";
     id: AkumaStatus["id"];

package/build/src/library/fleet.js

@@ -6,6 +6,7 @@ import { observeTaskBoard } from "../task/operations.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
+import { parsePublicHistoryId } from "../akuma/identity.js";
 function source(path) {
     return Akuma.of(path);
 }
@@ -315,15 +316,24 @@ export async function interruptAkuma(input) {
     const observation = await observeAkumaStage(addressed.path, addressed.id, values.repo);
     return { id: addressed.id, receipt, observation };
 }
-export async function historyAkuma(input) {
-    const values = requireInput(input, "Keiyaku.history input");
+function validateHistoryInput(values) {
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "before", "since", "limit", "last", "repo"].includes(key)) {
+        if (!["path", "akuma", "id", "before", "since", "limit", "last", "repo"].includes(key))
             throw new TypeError(`Keiyaku.history input has unknown field: ${key}`);
-        }
     }
     if (values.last !== undefined && typeof values.last !== "boolean")
         throw new TypeError("last must be a boolean");
+    if (values.id !== undefined && (typeof values.id !== "string" || values.id.trim() === ""))
+        throw new TypeError("id must be a nonblank string");
+    if (values.id !== undefined && parsePublicHistoryId(values.id) === null)
+        throw new TypeError("id must match turn/<positive safe integer>");
+    if (values.id !== undefined &&
+        (values.last === true || values.before !== undefined || values.since !== undefined || values.limit !== undefined))
+        throw new TypeError("id cannot be combined with last, before, since, or limit");
+}
+export async function historyAkuma(input) {
+    const values = requireInput(input, "Keiyaku.history input");
+    validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
     const handle = source(addressed.path).of({ id: addressed.id });
     const contract = await dispatchAssociation(values.repo, addressed.id);
@@ -334,9 +344,15 @@ export async function historyAkuma(input) {
             : { kind: "no-answer", id: addressed.id, contract };
     }
     const history = await handle.history({
+        ...(values.id === undefined ? {} : { id: values.id }),
         ...(values.before === undefined ? {} : { before: values.before }),
         ...(values.since === undefined ? {} : { since: values.since }),
         ...(values.limit === undefined ? {} : { limit: values.limit }),
     });
-    return { kind: "history", id: addressed.id, history, contract };
+    if (values.id !== undefined) {
+        if ("kind" in history && history.kind === "exact")
+            return { kind: "exact", id: addressed.id, outcome: history.outcome, contract };
+        return { kind: "unknown-history", id: addressed.id, historyId: values.id, contract };
+    }
+    return { kind: "history", id: addressed.id, history: history, contract };
 }

package/build/src/library/repo.js

@@ -1,3 +1,5 @@
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
 import { currentBranchOperation, scopeOperation } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
@@ -8,7 +10,7 @@ export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
 async function resolvePinnedScope(path, gitPath) {
     return await scopeOperation({
-        coordinate: path === undefined ? process.cwd() : path,
+        coordinate: await realpath(resolve(path === undefined ? process.cwd() : path)),
         ...(gitPath === undefined ? {} : { gitPath }),
     });
 }

package/build/src/world.d.ts

@@ -11,6 +11,8 @@ export type WorldResolution = Readonly<{
     candidate: WorldRoot | null;
     establish: () => Promise<WorldRoot>;
 }>;
+export declare const KEIYAKU_SQUARE_FILE = "KEIYAKU.square";
+export declare function keiyakuSquarePath(worldRoot: string): string;
 export declare class WorldError extends Error {
     readonly kind: "invalid-world" | "home-world" | "root-world";
     constructor(kind: "invalid-world" | "home-world" | "root-world", message: string);

package/build/src/world.js

@@ -2,6 +2,10 @@ import { mkdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, parse, resolve } from "node:path";
 const WORLD_BRAND = Symbol("keiyaku.world");
+export const KEIYAKU_SQUARE_FILE = "KEIYAKU.square";
+export function keiyakuSquarePath(worldRoot) {
+    return join(worldRoot, ".square", KEIYAKU_SQUARE_FILE);
+}
 export class WorldError extends Error {
     kind;
     constructor(kind, message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "files": [
     "build"
   ],
@@ -35,14 +35,19 @@
     "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('build', { recursive: true, force: true })\" && tsc -p tsconfig.json && 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",
+    "harness:version": "node scripts/update-harness-version.js",
     "review:model-impact": "node --import tsx scripts/model-change-impact.ts",
     "format": "prettier --write --print-width 120 \"src/**/*.ts\" \"scripts/**/*.ts\"",
     "format:check": "prettier --check --print-width 120 \"src/**/*.ts\" \"scripts/**/*.ts\"",
-    "test": "npm run format:check && npm run build && npm run test:architecture && npm run test:maintainability && npm run test:reachability && node --import tsx scripts/run-tests.mjs",
+    "test": "npm run format:check && npm run build && npm run test:architecture && npm run test:maintainability && npm run test:reachability && npm run test:parallel",
     "test:architecture": "node --import tsx scripts/check-architecture.ts",
     "test:e2e": "npm run build && node scripts/run-tests.mjs tests/packaged-cli.e2e.ts",
+    "test:local": "node scripts/run-tests.mjs --suite local",
+    "test:integration": "node scripts/run-tests.mjs --suite integration",
+    "test:parallel": "node scripts/run-tests.mjs --suite local --test-concurrency=8 && node scripts/run-tests.mjs --suite integration --test-concurrency=8",
     "test:maintainability": "node scripts/check-maintainability.js",
     "test:focused": "node scripts/run-tests.mjs",
+    "test:focused:serial": "node scripts/run-tests.mjs --test-concurrency=1",
     "test:reachability": "knip --include files,dependencies,unlisted,unresolved,duplicates",
     "test:typecheck": "tsc -p tsconfig.json --noEmit"
   },
@@ -59,7 +64,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/square": "0.3.17",
+    "@astrosheep/square": "0.3.24",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",