@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/task/store.js

@@ -3,8 +3,9 @@ import { closeSync, fsyncSync, openSync, renameSync, writeFileSync } from "node:
 import { lstat, mkdir, readFile, readdir, rmdir, unlink } from "node:fs/promises";
 import { dirname, relative, resolve, sep } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError, } from "../coordination/sqlite-transaction-lock.js";
+import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { parseTaskDocument } from "./document.js";
-import { formatTaskId, parseTaskId, taskAuthorityPath } from "./identity.js";
+import { formatTaskId, parseTaskId, physicalTaskSegment, TASK_LOCAL_ID_BYTES, sameNamespace, taskAuthorityPath, } from "./identity.js";
 export const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3_000;
 function syncTaskDirectory(path) {
     if (process.platform === "win32")
@@ -23,22 +24,73 @@ function tasksDirectory(world) {
 function allocationLockPath(world) {
     return resolve(world, ".keiyaku", "locks", "task-allocation.sqlite");
 }
-async function authorityFiles(directory) {
-    const files = [];
-    let entries;
+function custodyError(path) {
+    return new Error(`Task authority custody violation: symlink or non-authority component: ${path}`);
+}
+async function requireDirectory(path, mode) {
     try {
-        entries = await readdir(directory, { withFileTypes: true });
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw custodyError(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (mode === "read")
+            return false;
+        try {
+            await mkdir(path);
+            syncTaskDirectory(dirname(path));
+        }
+        catch (mkdirError) {
+            if (mkdirError.code !== "EEXIST")
+                throw mkdirError;
+        }
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw custodyError(path);
+        return true;
+    }
+}
+async function resolveAuthority(world, id, mode) {
+    const coordinate = parseTaskId(id);
+    const root = tasksDirectory(world);
+    const safePath = taskAuthorityPath(root, coordinate);
+    if (!(await requireDirectory(root, mode)))
+        return { path: safePath, exists: false };
+    let parent = root;
+    for (const segment of coordinate.namespace) {
+        parent = resolve(parent, physicalTaskSegment(segment));
+        if (!(await requireDirectory(parent, mode)))
+            return { path: safePath, exists: false };
+    }
+    const path = safePath;
+    try {
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            throw custodyError(path);
+        return { path, exists: true };
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return [];
+            return { path, exists: false };
         throw error;
     }
+}
+async function authorityFiles(directory) {
+    if (!(await requireDirectory(directory, "read")))
+        return [];
+    const files = [];
+    const entries = await readdir(directory);
     for (const entry of entries) {
-        const path = resolve(directory, entry.name);
-        if (entry.isDirectory())
+        const path = resolve(directory, entry);
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink())
+            throw custodyError(path);
+        if (stat.isDirectory())
             files.push(...(await authorityFiles(path)));
-        else if (entry.isFile() && entry.name.endsWith(".md"))
+        else if (stat.isFile() && entry.endsWith(".md"))
             files.push(path);
     }
     return files.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
@@ -47,38 +99,33 @@ function coordinateFromPath(tasksDirectory, path) {
     const local = relative(tasksDirectory, path);
     if (local.startsWith("..") || resolve(tasksDirectory, local) !== path || !local.endsWith(".md"))
         throw new Error(`invalid Task authority path: ${path}`);
-    return parseTaskId(`task/${local.slice(0, -3).split(sep).join("/")}`);
-}
-function ownedTaskId(tasksDirectory, path) {
-    try {
-        return formatTaskId(coordinateFromPath(tasksDirectory, path));
-    }
-    catch {
-        return null;
-    }
+    const segments = local.slice(0, -3).split(sep);
+    segments.forEach((segment) => physicalTaskSegment(segment));
+    return parseTaskId(`task/${segments.join("/")}`);
 }
 async function ownedAuthorityCandidates(directory) {
     const candidates = [];
     for (const path of await authorityFiles(directory)) {
-        const id = ownedTaskId(directory, path);
-        if (id !== null)
-            candidates.push({ id, path });
+        try {
+            candidates.push({ id: formatTaskId(coordinateFromPath(directory, path)), path });
+        }
+        catch {
+            // Files outside the Task identity grammar are not owned candidates.
+        }
     }
     return candidates;
 }
 async function removeEmptyTaskDirectories(directory, removeSelf) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
+    if (!(await requireDirectory(directory, "read")))
+        return;
+    const entries = await readdir(directory);
     for (const entry of entries) {
-        if (entry.isDirectory())
-            await removeEmptyTaskDirectories(resolve(directory, entry.name), true);
+        const path = resolve(directory, entry);
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink())
+            throw custodyError(path);
+        if (stat.isDirectory())
+            await removeEmptyTaskDirectories(path, true);
     }
     if (!removeSelf)
         return;
@@ -108,22 +155,42 @@ export async function readBoard(world) {
     }
     return { board: { tasks }, bytes };
 }
+function compareRecentTasks(left, right) {
+    const updated = right.updatedAt.localeCompare(left.updatedAt);
+    return updated === 0 ? Buffer.compare(Buffer.from(left.id), Buffer.from(right.id)) : updated;
+}
+export async function readRecentTaskDocuments(world, input) {
+    const limit = boundedListLimit(input.limit);
+    const directory = tasksDirectory(world);
+    const tasks = [];
+    for (const path of await authorityFiles(directory)) {
+        const metadata = await lstat(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink())
+            throw new Error(`Task authority is not a regular file: ${path}`);
+        const coordinate = coordinateFromPath(directory, path);
+        if (input.namespace !== undefined && !sameNamespace(coordinate.namespace, input.namespace))
+            continue;
+        const task = parseTaskDocument(await readFile(path), coordinate);
+        if (input.selection === "active" && (task.state === "done" || task.state === "drop"))
+            continue;
+        tasks.push(task);
+    }
+    return projectBoundedList(tasks.sort(compareRecentTasks), limit);
+}
+export async function readTaskDocument(world, id) {
+    const resolved = await resolveAuthority(world, id, "read");
+    return resolved.exists ? parseTaskDocument(await readFile(resolved.path), parseTaskId(id)) : undefined;
+}
 function equal(left, right) {
     return left === null || right === null ? left === right : Buffer.from(left).equals(Buffer.from(right));
 }
-async function currentBytes(path) {
-    try {
-        return await readFile(path);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
+async function currentBytes(world, id) {
+    const resolved = await resolveAuthority(world, id, "read");
+    return resolved.exists ? readFile(resolved.path) : null;
 }
 export async function replaceAuthority(input) {
-    const parent = dirname(input.path);
-    await mkdir(parent, { recursive: true });
+    const resolved = await resolveAuthority(input.world, input.id, "write");
+    const parent = dirname(resolved.path);
     const temporary = resolve(parent, `.tmp-${randomBytes(8).toString("hex")}`);
     let descriptor;
     try {
@@ -132,9 +199,9 @@ export async function replaceAuthority(input) {
         fsyncSync(descriptor);
         closeSync(descriptor);
         descriptor = undefined;
-        if (!equal(await currentBytes(input.path), input.expected))
+        if (!equal(await currentBytes(input.world, input.id), input.expected))
             return "concurrent-modification";
-        renameSync(temporary, input.path);
+        renameSync(temporary, resolved.path);
         syncTaskDirectory(parent);
         return "replaced";
     }
@@ -149,9 +216,31 @@ export async function replaceAuthority(input) {
         }
     }
 }
+export async function authorityBytesMatch(world, id, expected) {
+    return equal(await currentBytes(world, id), expected);
+}
 function lockPath(world, id) {
     const coordinate = parseTaskId(id);
-    return resolve(world, ".keiyaku", "locks", "task", ...coordinate.namespace, `${coordinate.localId}.sqlite`);
+    return resolve(world, ".keiyaku", "locks", "task", ...coordinate.namespace.map((segment) => physicalTaskSegment(segment)), `${physicalTaskSegment(coordinate.localId, TASK_LOCAL_ID_BYTES)}.sqlite`);
+}
+function errorDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function preserveCommittedResult(result, errors) {
+    if (typeof result === "object" && result !== null && "kind" in result) {
+        const kind = result.kind;
+        if (kind === "accepted" || kind === "changed" || kind === "incomplete") {
+            const previous = result.cleanup;
+            return {
+                ...result,
+                cleanup: {
+                    kind: "lock-release-failed",
+                    diagnostics: [...(previous?.diagnostics ?? []), ...errors.map(errorDetail)],
+                },
+            };
+        }
+    }
+    throw new AggregateError(errors, "Task lock cleanup failed");
 }
 export async function nukeTaskAuthority(world, options) {
     const directory = tasksDirectory(world);
@@ -162,9 +251,9 @@ export async function nukeTaskAuthority(world, options) {
         return await withTaskLocks({ world, allocation: false, ids, ...lockOptions }, async () => {
             for (const candidate of candidates) {
                 try {
-                    const stat = await lstat(candidate.path);
-                    if (stat.isFile() && !stat.isSymbolicLink())
-                        await unlink(candidate.path);
+                    const resolved = await resolveAuthority(world, candidate.id, "read");
+                    if (resolved.exists)
+                        await unlink(resolved.path);
                 }
                 catch (error) {
                     if (error.code !== "ENOENT")
@@ -185,6 +274,8 @@ export async function withTaskLocks(input, action) {
             .map((id) => lockPath(input.world, id)),
     ];
     const held = [];
+    let result;
+    let failure;
     try {
         for (const path of paths)
             held.push(await acquireSqliteTransactionLock({
@@ -193,17 +284,40 @@ export async function withTaskLocks(input, action) {
                 timeoutMs: input.timeoutMs ?? DEFAULT_TASK_LOCK_TIMEOUT_MS,
                 ...(input.signal === undefined ? {} : { signal: input.signal }),
             }));
-        return await action();
+        result = await action();
     }
     catch (error) {
-        if (error instanceof SqliteTransactionLockError && error.reason === "timeout")
-            return "busy";
-        throw error;
+        failure = error;
     }
     finally {
-        for (const lock of held.reverse())
-            lock.close();
+        const cleanupErrors = [];
+        for (const lock of held.reverse()) {
+            try {
+                lock.close();
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+        if (cleanupErrors.length > 0) {
+            if (failure === undefined && result !== undefined)
+                result = preserveCommittedResult(result, cleanupErrors);
+            else if (failure === undefined)
+                failure = new AggregateError(cleanupErrors, "Task lock cleanup failed");
+            else {
+                const originalFailure = failure;
+                failure = new AggregateError([originalFailure, ...cleanupErrors], errorDetail(originalFailure), {
+                    cause: originalFailure,
+                });
+            }
+        }
+    }
+    if (failure !== undefined) {
+        if (failure instanceof SqliteTransactionLockError && failure.reason === "timeout")
+            return "busy";
+        throw failure;
     }
+    return result;
 }
 export function authorityPath(world, id) {
     return taskAuthorityPath(tasksDirectory(world), parseTaskId(id));

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

@@ -0,0 +1,4 @@
+import type { TaskDocument } from "./document.js";
+import type { TaskView } from "./operation-types.js";
+export declare function taskView(document: TaskDocument): TaskView;
+export declare function advanceTaskTimestamp(previous: string, candidate: string): string;

package/build/src/task/view.js

@@ -0,0 +1,7 @@
+import { parseTaskId } from "./identity.js";
+export function taskView(document) {
+    return { ...document, namespace: parseTaskId(document.id).namespace };
+}
+export function advanceTaskTimestamp(previous, candidate) {
+    return candidate > previous ? candidate : new Date(Date.parse(previous) + 1).toISOString();
+}

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

@@ -14,6 +14,7 @@ export type VerificationDeclarationRefusal = Readonly<{
     kind: "verification-declaration-invalid";
     contractId?: ContractId;
 }>;
+export declare function decodeVerificationDeclarationRefusal(value: unknown): VerificationDeclarationRefusal;
 export type VerificationDeclarationPreparation = Preparation<VerificationDefinition | null, VerificationDeclarationRefusal>;
 export declare const VERIFIED: Gate;
 export declare function prepareVerificationDeclaration(input: Readonly<{

package/build/src/verification/declaration.js

@@ -1,4 +1,21 @@
-import { gate } from "../core/facts/types.js";
+import { contractId, gate } from "../core/facts/types.js";
+export function decodeVerificationDeclarationRefusal(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed verification declaration refusal");
+    const object = value;
+    if (object.kind !== "verification-declaration-invalid")
+        throw new Error("malformed verification declaration refusal");
+    if (Object.keys(object).some((key) => key !== "kind" && key !== "contractId"))
+        throw new Error("malformed verification declaration refusal");
+    if (object.contractId === undefined)
+        return { kind: "verification-declaration-invalid" };
+    try {
+        return { kind: "verification-declaration-invalid", contractId: contractId(String(object.contractId)) };
+    }
+    catch {
+        throw new Error("malformed verification declaration refusal");
+    }
+}
 export const VERIFIED = gate("verified");
 export function prepareVerificationDeclaration(input) {
     if (input.definition !== null || !input.gates.includes(VERIFIED)) {

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

@@ -41,7 +41,6 @@ export type ExecuteVerificationInput = Readonly<{
     repository: GitRepository;
     candidate: SnapshotId;
     declarations: readonly VerificationDeclaration[];
-    environment: NodeJS.ProcessEnv;
     materializeScratchCandidate: (repository: GitRepository, candidate: SnapshotId) => Promise<MaterializedScratchCandidate>;
     projectSettings: (root: string) => Promise<Settings>;
     signal?: AbortSignal;

package/build/src/verification/execution.js

@@ -1,5 +1,4 @@
-import { runHookCommands } from "../git/hooks.js";
-import { worktreeHooksFrom } from "../library/configuration.js";
+import { runHookCommands, worktreeHooksFrom } from "../git/hooks.js";
 import { runProcess } from "../runtime/proc/run.js";
 const SUMMARY_BYTES = 32 * 1024;
 function argvFor(declaration) {
@@ -58,6 +57,7 @@ async function executeDeclarations(input) {
 }
 /** Execute one disposable Verification attempt over the exact integration snapshot. */
 export async function executeVerification(input) {
+    const environment = process.env;
     let scratch;
     try {
         scratch = await input.materializeScratchCandidate(input.repository, input.candidate);
@@ -75,7 +75,7 @@ export async function executeVerification(input) {
         try {
             const hooks = worktreeHooksFrom({ settings: await input.projectSettings(scratch.cwd) });
             destroy = hooks.destroy;
-            const readiness = await runHookCommands(scratch.cwd, hooks.create, input.signal);
+            const readiness = await runHookCommands(scratch.cwd, hooks.create, input.signal, environment);
             outcome =
                 readiness.kind === "cancelled"
                     ? { kind: "cancelled" }
@@ -84,7 +84,7 @@ export async function executeVerification(input) {
                         : await executeDeclarations({
                             declarations: input.declarations,
                             cwd: scratch.cwd,
-                            environment: input.environment,
+                            environment,
                             ...(input.signal === undefined ? {} : { signal: input.signal }),
                         });
         }
@@ -94,7 +94,7 @@ export async function executeVerification(input) {
     }
     finally {
         if (destroy !== undefined) {
-            const result = await runHookCommands(scratch.cwd, destroy);
+            const result = await runHookCommands(scratch.cwd, destroy, undefined, environment);
             if (result.kind === "cancelled")
                 throw new Error("scratch destroy cancelled without a signal");
             if (result.kind === "failed")

package/build/src/world.d.ts

@@ -11,8 +11,6 @@ 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

@@ -1,11 +1,7 @@
-import { mkdir, realpath, stat } from "node:fs/promises";
+import { lstat, 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) {
@@ -60,7 +56,7 @@ async function rejectReservedRoot(root) {
 async function ensureMarker(root) {
     const path = marker(root);
     try {
-        if (!(await stat(path)).isDirectory())
+        if (!(await lstat(path)).isDirectory())
             throw new Error("not a directory");
         return;
     }
@@ -88,7 +84,7 @@ async function locateMarker(input) {
         const filesystemRoot = parse(candidate).root;
         if (candidate !== home && candidate !== filesystemRoot) {
             try {
-                if (!(await stat(marker(candidate))).isDirectory()) {
+                if (!(await lstat(marker(candidate))).isDirectory()) {
                     throw new WorldError("invalid-world", `world marker is not a directory: ${marker(candidate)}`);
                 }
                 return brand(candidate);

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.11",
+  "version": "4.5.13",
+  "workspaces": [
+    "plugins/*"
+  ],
   "files": [
     "build"
   ],
@@ -22,6 +25,10 @@
     "./akuma": {
       "types": "./build/src/akuma/index.d.ts",
       "import": "./build/src/akuma/index.js"
+    },
+    "./plugin": {
+      "types": "./build/src/plugin/public.d.ts",
+      "import": "./build/src/plugin/public.js"
     }
   },
   "bin": {
@@ -32,15 +39,18 @@
     "node": ">=22.19.0"
   },
   "scripts": {
-    "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)\"",
+    "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",
     "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\"",
+    "lint": "eslint src scripts tests",
     "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:all": "node scripts/test-entry.mjs --release",
+    "test:release": "node scripts/test-entry.mjs --release",
+    "test:dev": "node scripts/test-entry.mjs --dev",
     "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",
@@ -50,7 +60,9 @@
     "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"
+    "test:typecheck": "tsc -p tsconfig.json --noEmit && npm run test:typecheck:scoped-tests && npm run test:typecheck:scripts",
+    "test:typecheck:scoped-tests": "tsc -p tsconfig.tests.json",
+    "test:typecheck:scripts": "tsc -p tsconfig.scripts.json"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
@@ -65,7 +77,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/square": "0.3.32",
+    "@astrosheep/keiyaku-plugin-square": "0.1.1",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",

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

@@ -1,7 +0,0 @@
-import type { AllocatedAkuma } from "../akuma/identity.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>;