@astrosheep/keiyaku 4.5.6 → 4.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.6",
+  "version": "4.5.8",
   "files": [
     "build"
   ],
@@ -12,8 +12,8 @@
       "import": "./build/src/index.js"
     },
     "./task": {
-      "types": "./build/src/task/index.d.ts",
-      "import": "./build/src/task/index.js"
+      "types": "./build/src/task/public.d.ts",
+      "import": "./build/src/task/public.js"
     },
     "./kanshi": {
       "types": "./build/src/kanshi/index.d.ts",
@@ -39,7 +39,8 @@
     "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 && npm run test:parallel",
+    "test": "node scripts/test-entry.mjs",
+    "test:all": "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",
@@ -64,12 +65,13 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/square": "0.3.28",
+    "@astrosheep/square": "0.3.32",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "zod": "^4.5.2"
   },
   "description": "Keiyaku is an agent-facing contract workflow.",
   "directories": {

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

@@ -1,8 +0,0 @@
-import type { UpstreamRequestService } from "./heart/index.js";
-import type { ServeInput, UpstreamFact } from "./request-serve.js";
-type ExecutionResult = Readonly<{
-    result: unknown;
-    service?: UpstreamRequestService;
-}>;
-export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<ExecutionResult>;
-export {};

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

@@ -1,98 +0,0 @@
-async function executeWait(input, request) {
-    return {
-        result: await input.upstream.wait({
-            targets: request.targets,
-            completion: request.completion,
-            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
-            signal: input.signal,
-        }),
-        service: { action: request.action },
-    };
-}
-async function executeTell(input, request) {
-    return {
-        result: await input.upstream.tell({
-            target: request.target,
-            body: request.body,
-            tellId: request.id,
-            recordedAt: request.admittedAt,
-            signal: input.signal,
-        }),
-        service: { action: request.action, target: request.target, tellId: request.id },
-    };
-}
-async function executeKill(input, request) {
-    const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
-    return { result: served.result, service: { action: request.action, results: served.service } };
-}
-async function executeDeliver(input, request) {
-    const served = await input.upstream.deliver({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        ...(request.message === undefined ? {} : { message: request.message }),
-        includeDirty: request.includeDirty,
-        materializeConflict: request.materializeConflict,
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.deliveryFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    deliveryFactId: served.deliveryFactId,
-                },
-            }),
-    };
-}
-async function executeReview(input, request) {
-    const served = await input.upstream.review({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        verdict: request.verdict,
-        ...(request.summary === undefined ? {} : { summary: request.summary }),
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.reviewFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    reviewFactId: served.reviewFactId,
-                },
-            }),
-    };
-}
-export async function executeRequest(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    if (request.action === "akuma.wait")
-        return executeWait(input, request);
-    if (request.action === "akuma.tell")
-        return executeTell(input, request);
-    if (request.action === "akuma.kill")
-        return executeKill(input, request);
-    if (request.action === "contract.deliver")
-        return executeDeliver(input, request);
-    if (request.action === "contract.review")
-        return executeReview(input, request);
-    const task = request;
-    return {
-        result: await input.upstream.task({
-            world: task.world,
-            request: task.request,
-            requester: task.requester,
-            signal: input.signal,
-        }),
-        service: { action: task.action },
-    };
-}