@astrosheep/keiyaku 4.4.0 → 4.5.1

package/build/src/runtime/proc/run.js

@@ -40,13 +40,6 @@ export async function spawnDetachedProcess(input) {
         return spawnWindowsRetainedProcess(input);
     const log = await open(input.log, "a");
     let launched = false;
-    let logClosed = false;
-    const closeLog = async () => {
-        if (logClosed)
-            return;
-        logClosed = true;
-        await log.close();
-    };
     try {
         const from = (await log.stat()).size;
         const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor(input, ["ignore", log.fd, log.fd]));
@@ -62,14 +55,16 @@ export async function spawnDetachedProcess(input) {
                     const status = detachedExitStatus(code, signal);
                     let failure;
                     let result;
+                    let exitLog;
                     try {
-                        result = await retainDetachedExitEvidence(log, input.log, from, code, signal);
+                        exitLog = await open(input.log, "r+");
+                        result = await retainDetachedExitEvidence(exitLog, input.log, from, code, signal);
                     }
                     catch (error) {
                         failure = error;
                     }
                     try {
-                        await closeLog();
+                        await exitLog?.close();
                     }
                     catch (error) {
                         failure ??= error;
@@ -89,6 +84,7 @@ export async function spawnDetachedProcess(input) {
         if (child.pid === undefined)
             throw new Error("detached process spawned without a pid");
         const pid = child.pid;
+        await log.close();
         launched = true;
         return {
             pid,
@@ -99,7 +95,7 @@ export async function spawnDetachedProcess(input) {
     }
     finally {
         if (!launched)
-            await closeLog();
+            await log.close();
     }
 }
 function terminalOutcome(code, stdout, stderr, consuming) {

package/build/src/runtime/proc/termination.d.ts

@@ -1,3 +1,4 @@
 import { type ChildProcess } from "node:child_process";
 export declare function terminateWindowsTree(pid: number): Promise<void>;
+export declare function settleWindowsTermination(exit: Promise<void>): Promise<void>;
 export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;

package/build/src/runtime/proc/termination.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
 const TERMINATION_GRACE_MS = 250;
+const WINDOWS_TERMINATION_SETTLE_MS = 250;
 const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
 const execFileAsync = promisify(execFile);
 function ignoreMissingProcess(error) {
@@ -23,6 +24,20 @@ export async function terminateWindowsTree(pid) {
         throw error;
     }
 }
+export async function settleWindowsTermination(exit) {
+    const settled = await Promise.race([
+        exit.then(() => true),
+        delay(WINDOWS_TERMINATION_TIMEOUT_MS, false, { ref: false }).then(() => false),
+    ]);
+    if (!settled)
+        throw new Error("Windows process did not exit after taskkill");
+    await delay(WINDOWS_TERMINATION_SETTLE_MS);
+}
+function closeWindowsStreams(child) {
+    child.stdin?.destroy();
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
 export async function terminateOwnedProcess(child, force = false) {
     const pid = child.pid;
     if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
@@ -39,8 +54,13 @@ export async function terminateOwnedProcess(child, force = false) {
         });
     });
     if (process.platform === "win32") {
-        await terminateWindowsTree(pid);
-        await exit;
+        try {
+            await terminateWindowsTree(pid);
+            await settleWindowsTermination(exit);
+        }
+        finally {
+            closeWindowsStreams(child);
+        }
         return;
     }
     if (force) {

package/build/src/runtime/proc/windows-run.js

@@ -3,8 +3,8 @@ import { createInterface } from "node:readline";
 import { launchFailure, spawnWindowsLauncher } from "./launch.js";
 import { detachedExitStatus, retainDetachedExitEvidence } from "./process-exit.js";
 import { createProcessLifecycle } from "./lifecycle.js";
-import { terminateWindowsTree } from "./termination.js";
-function createWindowsContext(input, log, from, closeLog) {
+import { settleWindowsTermination, terminateWindowsTree } from "./termination.js";
+function createWindowsContext(input, from, closeLog) {
     const child = spawnWindowsLauncher(input);
     const reader = createInterface({ input: child.stdout });
     let startedResolve;
@@ -23,7 +23,6 @@ function createWindowsContext(input, log, from, closeLog) {
     child.stderr?.setEncoding("utf8");
     const context = {
         input,
-        log,
         from,
         closeLog,
         child,
@@ -79,14 +78,16 @@ function recordWindowsExit(context, code) {
     void (async () => {
         let failure;
         let result;
+        let exitLog;
         try {
-            result = await retainDetachedExitEvidence(context.log, context.input.log, context.from, code, null);
+            exitLog = await open(context.input.log, "r+");
+            result = await retainDetachedExitEvidence(exitLog, context.input.log, context.from, code, null);
         }
         catch (error) {
             failure = error;
         }
         try {
-            await context.closeLog();
+            await exitLog?.close();
         }
         catch (error) {
             failure ??= error;
@@ -98,6 +99,7 @@ function recordWindowsExit(context, code) {
             const status = detachedExitStatus(code, null);
             throw new Error(`pre-admission ${status}: run-log evidence unavailable: ${failure instanceof Error ? failure.message : String(failure)}`);
         }
+        await settleWindowsTermination(Promise.resolve());
         context.exitResolve(result);
     })().catch(context.exitReject);
 }
@@ -143,7 +145,7 @@ function installWindowsProtocol(context) {
 function ownedWindowsProcess(context, pid) {
     const lifecycle = createProcessLifecycle(async () => {
         await terminateWindowsTree(pid);
-        await context.exited;
+        await settleWindowsTermination(context.exited.then(() => undefined));
     }, () => {
         context.released = true;
         context.reader.close();
@@ -170,10 +172,11 @@ export async function spawnWindowsRetainedProcess(input) {
         logClosed = true;
         await log.close();
     };
-    const context = createWindowsContext(input, log, (await log.stat()).size, closeLog);
+    const context = createWindowsContext(input, (await log.stat()).size, closeLog);
     installWindowsProtocol(context);
     try {
         const pid = await context.startedPromise;
+        await closeLog();
         return ownedWindowsProcess(context, pid);
     }
     catch (error) {

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.4.0",
+  "version": "4.5.1",
   "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.13",
+    "@astrosheep/square": "0.3.23",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",

package/build/src/akuma/result-route.d.ts

@@ -1,2 +0,0 @@
-/** Opaque, serializable caller result address carried across the Body process. */
-export type ResultRoute = Readonly<unknown>;

package/build/src/akuma/result-route.js

@@ -1 +0,0 @@
-export {};