@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/task/store.js

@@ -3,21 +3,11 @@ 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 { syncDirectory } from "../coordination/durable-file.js";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { parseTaskDocument } from "./document.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")
-        return;
-    const directory = openSync(path, "r");
-    try {
-        fsyncSync(directory);
-    }
-    finally {
-        closeSync(directory);
-    }
-}
 function tasksDirectory(world) {
     return resolve(world, ".keiyaku", "tasks");
 }
@@ -41,7 +31,7 @@ async function requireDirectory(path, mode) {
             return false;
         try {
             await mkdir(path);
-            syncTaskDirectory(dirname(path));
+            syncDirectory(dirname(path));
         }
         catch (mkdirError) {
             if (mkdirError.code !== "EEXIST")
@@ -202,7 +192,7 @@ export async function replaceAuthority(input) {
         if (!equal(await currentBytes(input.world, input.id), input.expected))
             return "concurrent-modification";
         renameSync(temporary, resolved.path);
-        syncTaskDirectory(parent);
+        syncDirectory(parent);
         return "replaced";
     }
     finally {
@@ -249,11 +239,15 @@ export async function nukeTaskAuthority(world, options) {
         const candidates = await ownedAuthorityCandidates(directory);
         const ids = [...new Set(candidates.map((candidate) => candidate.id))].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
         return await withTaskLocks({ world, allocation: false, ids, ...lockOptions }, async () => {
+            let removed = 0;
             for (const candidate of candidates) {
                 try {
                     const resolved = await resolveAuthority(world, candidate.id, "read");
-                    if (resolved.exists)
+                    if (resolved.exists) {
                         await unlink(resolved.path);
+                        removed += 1;
+                        options?.onRemoved?.(1);
+                    }
                 }
                 catch (error) {
                     if (error.code !== "ENOENT")
@@ -261,10 +255,12 @@ export async function nukeTaskAuthority(world, options) {
                 }
             }
             await removeEmptyTaskDirectories(directory, false);
+            return removed;
         });
     });
     if (result === "busy")
         return "busy";
+    return result;
 }
 export async function withTaskLocks(input, action) {
     const paths = [

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

@@ -14,7 +14,6 @@ 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,21 +1,4 @@
-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");
-    }
-}
+import { gate } from "../core/facts/types.js";
 export const VERIFIED = gate("verified");
 export function prepareVerificationDeclaration(input) {
     if (input.definition !== null || !input.gates.includes(VERIFIED)) {

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

@@ -13,7 +13,7 @@ export type VerificationTerminalOutcome = Readonly<{
     total: number;
     summary?: string;
 }>;
-export type CapturedOutput = Readonly<{
+type CapturedOutput = Readonly<{
     stdout?: string;
     stderr?: string;
     truncated?: boolean;
@@ -26,7 +26,11 @@ export type VerificationNonterminalOutcome = CapturedOutput & (Readonly<{
     kind: "spawn-error";
     diagnostic: string;
 }>);
-export declare function capturedOutput(value: CapturedOutput): CapturedOutput;
+export declare function capturedOutput(value: CapturedOutput): Readonly<{
+    stdout?: string;
+    stderr?: string;
+    truncated?: true;
+}>;
 export type VerificationExecutionStop = VerificationNonterminalOutcome | Readonly<{
     kind: "candidate-unavailable" | "environment-failure";
     diagnostic: string;

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
 export declare const verificationObservationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodEnum<{
-        finished: "finished";
         started: "started";
+        finished: "finished";
     }>;
     outcome: z.ZodOptional<z.ZodString>;
     elapsedMs: z.ZodOptional<z.ZodNumber>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.29",
+  "version": "4.6.2",
   "workspaces": [
     "plugins/*"
   ],
@@ -14,22 +14,6 @@
       "types": "./build/src/index.d.ts",
       "import": "./build/src/index.js"
     },
-    "./task": {
-      "types": "./build/src/task/public.d.ts",
-      "import": "./build/src/task/public.js"
-    },
-    "./kanshi": {
-      "types": "./build/src/kanshi/index.d.ts",
-      "import": "./build/src/kanshi/index.js"
-    },
-    "./akuma": {
-      "types": "./build/src/akuma/index.d.ts",
-      "import": "./build/src/akuma/index.js"
-    },
-    "./akumas": {
-      "types": "./build/src/library/akumas.d.ts",
-      "import": "./build/src/library/akumas.js"
-    },
     "./plugin": {
       "types": "./build/src/plugin/public.d.ts",
       "import": "./build/src/plugin/public.js"
@@ -86,7 +70,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
     "@astrosheep/keiyaku-plugin-square": "0.1.6",
     "@astrosheep/square": "^0.3.57",
-    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-coding-agent": "^1.0.0",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",

package/build/src/akuma/akuma-product.d.ts

@@ -1,58 +0,0 @@
-import { AkumaHandle } from "./akuma-handle.js";
-import type { AkumaCallContext, AkumaCallInput, AkumaCompleteList, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
-import type { CallInitialTell } from "./call-initial-tell.js";
-import type { WorldRoot } from "../world.js";
-import type { BodyLaunch } from "./body.js";
-import type { AllocatedAkuma } from "./identity.js";
-type AkumaCallRecipe = Omit<NonNullable<BodyLaunch["seed"]>, "id" | "archetype" | "cwd" | "origin">;
-type BornExecution = Readonly<{
-    cwd: string;
-    source: "input" | "caller" | "process" | "world";
-}>;
-export type InitialCallTell = CallInitialTell;
-export type BornAkumaCall = Readonly<{
-    kind: "born";
-    allocated: AllocatedAkuma;
-    seed: AkumaCallRecipe & Readonly<{
-        id: AllocatedAkuma["id"];
-        archetype: string;
-        cwd: string;
-        origin: {
-            kind: "direct";
-        };
-    }>;
-    execution: BornExecution;
-}>;
-export type RequestedAkumaCall = Readonly<{
-    kind: "requested";
-    id: AllocatedAkuma["id"];
-    cwd: string;
-    execution: BornExecution;
-}>;
-export type AkumaBornCall = BornAkumaCall | RequestedAkumaCall;
-type AkumaCallLaunchInput = Omit<AkumaCallInput, "body" | "schema"> & Readonly<{
-    initialTell: InitialCallTell;
-}>;
-export declare const PAGE_POOL_SIZE = 16;
-export declare function boundedMap<Value, Result>(values: readonly Value[], mapper: (value: Value) => Promise<Result>): Promise<readonly Result[]>;
-declare class AkumaProduct {
-    private readonly path;
-    private readonly configuration;
-    private constructor();
-    static create(root: WorldRoot, input?: AkumaConfiguration): AkumaProduct;
-    selectHandle(input: Readonly<{
-        id: string;
-    }>): AkumaHandle;
-    listArchetypes(): Promise<readonly string[]>;
-    admit(input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
-    publish(born: AkumaBornCall, completion?: Readonly<{
-        contractId?: string;
-    }>, signal?: AbortSignal): Promise<AkumaHandle>;
-    listComplete(input?: Readonly<{
-        archetype?: string;
-    }>): Promise<AkumaCompleteList>;
-    list(input?: AkumaListInput): Promise<AkumaList>;
-}
-/** Internal composition product; the package exposes the smaller Akuma instance instead. */
-export declare function createAkumaProduct(root: WorldRoot, input?: AkumaConfiguration): AkumaProduct;
-export {};

package/build/src/akuma/akuma-product.js

@@ -1,276 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { readdir, stat } from "node:fs/promises";
-import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
-import { AkumaHandle } from "./akuma-handle.js";
-import { canonicalBirthCwd } from "./call-input.js";
-import { fleetListRow, readAkumaBirthCwd } from "./akuma-observe.js";
-import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, archetypeName, parseAkuId } from "./identity.js";
-import { loadArchetype, listArchetypes as readArchetypes } from "./archetype.js";
-import { birthAkuma, launchAkuma } from "./publication.js";
-import { spawnAkumaBody } from "./body.js";
-import { requestForwardedAkumaCall } from "./call-request.js";
-import { executionChannel } from "./requests.js";
-import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
-import { settings as readSettings } from "../settings.js";
-async function admitBodyRequest(input) {
-    const cwd = input.call.cwd === undefined
-        ? undefined
-        : input.context.cwdCanonical === true
-            ? input.call.cwd
-            : await canonicalBirthCwd(input.call.cwd);
-    const child = await requestForwardedAkumaCall({
-        directory: input.execution.directory,
-        id: randomUUID(),
-        world: input.path,
-        archetype: input.name,
-        initialTell: input.call.initialTell,
-        ...(cwd === undefined ? {} : { cwd }),
-        recipe: input.recipe,
-        ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
-    });
-    const bornCwd = await readAkumaBirthCwd(input.path, child);
-    return {
-        kind: "requested",
-        id: child,
-        cwd: bornCwd,
-        execution: { cwd: bornCwd, source: cwd === undefined ? "caller" : "input" },
-    };
-}
-async function admitDirect(input) {
-    const initiatorCwd = input.context.initiatorCwd;
-    const selectedCwd = input.call.cwd ?? initiatorCwd ?? input.path;
-    const cwd = input.call.cwd !== undefined && input.context.cwdCanonical === true
-        ? input.call.cwd
-        : await canonicalBirthCwd(selectedCwd);
-    const allocated = await birthAkuma({
-        worldPath: input.path,
-        archetype: input.archetype.name,
-        ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
-    });
-    return {
-        kind: "born",
-        allocated,
-        seed: {
-            id: allocated.id,
-            archetype: allocated.archetype,
-            ...input.recipe,
-            cwd,
-            origin: { kind: "direct" },
-        },
-        execution: {
-            cwd,
-            source: input.call.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
-        },
-    };
-}
-export const PAGE_POOL_SIZE = 16;
-function activityAt(row) {
-    if (!("lifeAt" in row))
-        return null;
-    if (row.lifeAt === null)
-        return row.lastActivityAt;
-    if (row.lastActivityAt === null)
-        return row.lifeAt;
-    return row.lifeAt > row.lastActivityAt ? row.lifeAt : row.lastActivityAt;
-}
-function compareActivity(left, right) {
-    if (left === right)
-        return 0;
-    if (left === null)
-        return 1;
-    if (right === null)
-        return -1;
-    return left > right ? -1 : 1;
-}
-function compareRows(left, right) {
-    const activity = compareActivity(activityAt(left), activityAt(right));
-    if (activity !== 0)
-        return activity;
-    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-}
-export async function boundedMap(values, mapper) {
-    const results = [];
-    let index = 0;
-    const worker = async () => {
-        for (;;) {
-            const selected = index++;
-            if (selected >= values.length)
-                return;
-            results[selected] = await mapper(values[selected]);
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(PAGE_POOL_SIZE, values.length) }, worker));
-    return results;
-}
-async function mtimeBound(paths) {
-    const read = async (path) => {
-        try {
-            return (await stat(path)).mtimeMs;
-        }
-        catch (error) {
-            return error.code === "ENOENT" ? 0 : Number.POSITIVE_INFINITY;
-        }
-    };
-    return Math.max(await read(paths.heart), await read(`${paths.heart}-wal`));
-}
-async function knownAkuma(path, selected) {
-    const runRoot = akumaRunRoot(path);
-    let names;
-    try {
-        names = (await readdir(runRoot, { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { runRoot, rows: [] };
-        throw error;
-    }
-    const rows = [];
-    for (const name of names) {
-        let physical;
-        try {
-            physical = akuIdFromDirectoryName(name);
-        }
-        catch {
-            continue;
-        }
-        if (selected !== undefined && physical.archetype !== selected)
-            continue;
-        rows.push({
-            id: physical.id,
-            paths: akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix }),
-        });
-    }
-    return { runRoot, rows };
-}
-async function readableRows(rows) {
-    const loaded = await boundedMap(rows, async ({ id, paths }) => {
-        try {
-            return await fleetListRow(paths, id);
-        }
-        catch {
-            return null;
-        }
-    });
-    return [...loaded].filter((row) => row !== null);
-}
-class AkumaProduct {
-    path;
-    configuration;
-    constructor(path, configuration) {
-        this.path = path;
-        this.configuration = configuration;
-    }
-    static create(root, input = {}) {
-        if (typeof root !== "string")
-            throw new TypeError("Akuma product root must be a WorldRoot");
-        return new AkumaProduct(root, input);
-    }
-    selectHandle(input) {
-        return new AkumaHandle(parseAkuId(input.id).id, this.path);
-    }
-    async listArchetypes() {
-        return readArchetypes({
-            project: this.path,
-            ...(this.configuration.home === undefined ? {} : { home: this.configuration.home }),
-        });
-    }
-    async admit(input, context) {
-        const name = archetypeName(input.archetype);
-        const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
-        const settings = this.configuration.settings ?? (await readSettings({ root: this.path, ...home }));
-        const archetype = await loadArchetype({ name, project: this.path, ...home, settings });
-        const allowed = input.allowed === undefined
-            ? archetype.allowed
-            : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
-        const execution = executionChannel(this.configuration.execution);
-        const requestRecipe = Object.freeze({
-            ...(archetype.description === undefined ? {} : { description: archetype.description }),
-            provider: archetype.provider,
-            options: archetype.options,
-            allowed,
-        });
-        if (execution.kind === "body-request")
-            return await admitBodyRequest({ call: input, context, path: this.path, name, recipe: requestRecipe, execution });
-        return await admitDirect({ call: input, context, path: this.path, archetype, recipe: requestRecipe });
-    }
-    async publish(born, completion = {}, signal) {
-        if (born.kind === "requested") {
-            return new AkumaHandle(born.id, this.path, { cwd: born.cwd, source: born.execution.source });
-        }
-        const published = await launchAkuma({
-            allocated: born.allocated,
-            ...(signal === undefined ? {} : { signal }),
-            launch: async (allocated) => await spawnAkumaBody({
-                paths: allocated.paths,
-                seed: born.seed,
-                ...(Object.keys(completion).length === 0 ? {} : { completion }),
-            }),
-        });
-        return new AkumaHandle(published.id, this.path, {
-            cwd: born.execution.cwd,
-            source: born.execution.source,
-        });
-    }
-    async listComplete(input = {}) {
-        if (typeof input !== "object" || input === null || Array.isArray(input))
-            throw new TypeError("Akuma complete list input must be an object");
-        const unknown = Object.keys(input).find((key) => key !== "archetype");
-        if (unknown !== undefined)
-            throw new TypeError(`Akuma complete list input has unknown field: ${unknown}`);
-        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
-        const known = await knownAkuma(this.path, selected);
-        return {
-            observedAt: new Date().toISOString(),
-            rows: [...(await readableRows(known.rows))].sort(compareRows),
-            searched: [known.runRoot],
-        };
-    }
-    async list(input = {}) {
-        if (typeof input !== "object" || input === null || Array.isArray(input))
-            throw new TypeError("Akuma list input must be an object");
-        const unknown = Object.keys(input).find((key) => key !== "archetype" && key !== "limit");
-        if (unknown !== undefined)
-            throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
-        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
-        const limit = boundedListLimit(input.limit);
-        const observedAt = new Date().toISOString();
-        const known = await knownAkuma(this.path, selected);
-        const candidatesWithBounds = await boundedMap(known.rows, async (row) => ({
-            ...row,
-            bound: await mtimeBound(row.paths),
-        }));
-        const candidates = [...candidatesWithBounds].sort((left, right) => right.bound - left.bound);
-        const readable = [];
-        let cursor = 0;
-        while (cursor < candidates.length) {
-            const batch = candidates.slice(cursor, cursor + PAGE_POOL_SIZE);
-            readable.push(...(await readableRows(batch)));
-            cursor += batch.length;
-            const ranked = readable.sort(compareRows);
-            const lookahead = ranked[limit];
-            const activity = lookahead === undefined ? null : activityAt(lookahead);
-            const unreadBound = candidates[cursor]?.bound;
-            if (lookahead !== undefined &&
-                activity !== null &&
-                unreadBound !== undefined &&
-                Number.isFinite(unreadBound) &&
-                Number.isFinite(Date.parse(activity)) &&
-                unreadBound < Date.parse(activity)) {
-                break;
-            }
-        }
-        const ranked = readable.sort(compareRows);
-        return {
-            observedAt,
-            searched: [known.runRoot],
-            ...projectBoundedList(ranked, limit),
-        };
-    }
-}
-/** Internal composition product; the package exposes the smaller Akuma instance instead. */
-export function createAkumaProduct(root, input = {}) {
-    return AkumaProduct.create(root, input);
-}