@astrosheep/keiyaku 2.8.0 → 2.8.2

package/build/core/projection-mint.js

@@ -19,11 +19,21 @@ function assertMintSlug(slug) {
     if (!normalized) {
         throw new ProjectionStateError("projection slug cannot be empty");
     }
-    if (normalized.includes("/") || normalized.includes("\0")) {
+    if (!/^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/.test(normalized)) {
         throw new ProjectionStateError(`invalid projection slug: ${slug}`);
     }
     return normalized;
 }
+function removeEmptyAkumaRoot(dir) {
+    try {
+        fs.rmdirSync(dir);
+    }
+    catch (error) {
+        if (isErrnoException(error) && ["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+            return;
+        throw error;
+    }
+}
 /**
  * Validate mint inputs that can fail, then reserve one private staging directory.
  * Dot-prefixed staging is never a published projection address.
@@ -42,14 +52,19 @@ function reserveProjectionDirectory(input) {
     }
     const root = projectionRoot(input.cwd);
     fs.mkdirSync(root, { recursive: true });
+    const akumaRoot = path.join(root, slug);
+    const createdAkumaRoot = !fs.existsSync(akumaRoot);
+    fs.mkdirSync(akumaRoot, { recursive: true });
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const hex = (input.randomHex?.(attempt) ?? randomHex8()).toLowerCase();
         if (!/^[0-9a-f]{8}$/.test(hex)) {
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
         }
-        const id = `${slug}-${hex}`;
+        const id = `${slug}/${hex}`;
         const dir = projectionDir(input.cwd, id);
-        const stagingDir = path.join(root, `.mint-${id}`);
+        const stagingDir = path.join(akumaRoot, `.mint-${hex}`);
         if (fs.existsSync(dir))
             continue;
         try {
@@ -59,6 +74,8 @@ function reserveProjectionDirectory(input) {
             if (isErrnoException(error) && error.code === "EEXIST") {
                 continue;
             }
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw error;
         }
         if (fs.existsSync(dir)) {
@@ -67,6 +84,8 @@ function reserveProjectionDirectory(input) {
         }
         return { id, dir, stagingDir };
     }
+    if (createdAkumaRoot)
+        removeEmptyAkumaRoot(akumaRoot);
     throw new ProjectionMintCollisionError(`exhausted ${maxAttempts} projection id attempts under ${PROJECTION_ROOT_SEGMENTS.join("/")} (PROJECTION_MINT_COLLISION)`);
 }
 /** Build the pact fields shared by both authority variants. */
@@ -104,6 +123,8 @@ function publishReservedProjection(pact, reserved) {
     finally {
         if (!published) {
             fs.rmSync(reserved.stagingDir, { recursive: true, force: true });
+            const parent = path.dirname(reserved.stagingDir);
+            removeEmptyAkumaRoot(parent);
         }
     }
 }

package/build/core/projection-runner-lock.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 export const PROJECTION_RUNNER_LOCK_DATABASE = "leash";
 const SQLITE_BUSY = 5;
-const SUPPORTED_PLATFORMS = new Set(["darwin", "linux"]);
+const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"]);
 export class ProjectionRunnerLockUnavailableError extends Error {
     code = "PROJECTION_RUNNER_LOCK_UNAVAILABLE";
     constructor(message, options) {

package/build/core/projection-status.js

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../errno.js";
-import { executionEventsPath, projectionRoot, } from "./projection-core.js";
+import { executionEventsPath, isProjectionId, projectionRoot, } from "./projection-core.js";
+import { readProjectionAlias } from "./projection-alias.js";
 import { ProjectionStateError } from "./atomic-publish.js";
 import { foldAgentActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
@@ -12,6 +13,73 @@ import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { selectCurrentGeneration } from "./projection-life-protocol.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "./stored-agent-event.js";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
+export const DEFAULT_PROJECTION_STATUS_ROW_BUDGET = 20;
+const STATUS_GROUP = {
+    "startup-timeout": 0,
+    lost: 0,
+    unknown: 0,
+    minting: 1,
+    out: 1,
+    failed: 2,
+    dead: 2,
+    done: 3,
+    dismissed: 4,
+};
+function isOmissibleProjectionStatusState(state) {
+    return state === "failed" || state === "dead" || state === "done" || state === "dismissed";
+}
+function rowSortTime(row) {
+    if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
+        return row.activityAtMs;
+    }
+    if (row.mintedAt !== undefined) {
+        const mintedAtMs = Date.parse(row.mintedAt);
+        if (Number.isFinite(mintedAtMs))
+            return mintedAtMs;
+    }
+    return Number.NEGATIVE_INFINITY;
+}
+function compareProjectionStatusRows(a, b) {
+    const groupDifference = STATUS_GROUP[a.state] - STATUS_GROUP[b.state];
+    if (groupDifference !== 0)
+        return groupDifference;
+    const aTime = rowSortTime(a);
+    const bTime = rowSortTime(b);
+    if (aTime !== bTime) {
+        if (aTime === Number.NEGATIVE_INFINITY)
+            return 1;
+        if (bTime === Number.NEGATIVE_INFINITY)
+            return -1;
+        return bTime - aTime;
+    }
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+export function prioritizeProjectionStatusRows(rows, showAll) {
+    const ordered = [...rows].sort(compareProjectionStatusRows);
+    if (showAll)
+        return { rows: ordered };
+    const protectedCount = ordered.filter((row) => STATUS_GROUP[row.state] < 2).length;
+    let terminalBudget = Math.max(0, DEFAULT_PROJECTION_STATUS_ROW_BUDGET - protectedCount);
+    const visible = [];
+    const byState = {
+        failed: 0,
+        dead: 0,
+        done: 0,
+        dismissed: 0,
+    };
+    for (const row of ordered) {
+        if (STATUS_GROUP[row.state] < 2 || terminalBudget > 0) {
+            visible.push(row);
+            if (STATUS_GROUP[row.state] >= 2)
+                terminalBudget -= 1;
+            continue;
+        }
+        if (isOmissibleProjectionStatusState(row.state))
+            byState[row.state] += 1;
+    }
+    const total = Object.values(byState).reduce((sum, count) => sum + count, 0);
+    return total > 0 ? { rows: visible, omitted: { total, byState } } : { rows: visible };
+}
 class ProjectionStatusFileError extends Error {
     diagnostic;
     constructor(kind, filePath) {
@@ -198,7 +266,7 @@ function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallb
             : {}),
     };
 }
-function readProjectionRow(projectionDir, id, nowMs) {
+function readProjectionRow(projectionDir, id, alias, nowMs) {
     const diagnostics = [];
     const identityFacts = readIdentityFacts(projectionDir, diagnostics);
     const tellCounts = identityFacts.identity
@@ -232,6 +300,7 @@ function readProjectionRow(projectionDir, id, nowMs) {
     const state = phase === "active" || phase === "quiescent" ? "out" : phase;
     return {
         id,
+        ...(alias ? { alias } : {}),
         state,
         akuma: identityFacts.akuma,
         provider: identityFacts.provider,
@@ -243,7 +312,7 @@ function readProjectionRow(projectionDir, id, nowMs) {
         diagnostics,
     };
 }
-export function readProjectionStatusBoard(cwd, nowMs) {
+export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
     const root = projectionRoot(cwd);
     try {
         if (!fs.lstatSync(root).isDirectory())
@@ -263,17 +332,47 @@ export function readProjectionStatusBoard(cwd, nowMs) {
             return null;
         throw error;
     }
-    const rows = entries
-        .filter((entry) => !entry.startsWith("."))
-        .filter((entry) => {
+    const aliases = new Map();
+    const aliasRoot = path.join(path.dirname(path.dirname(root)), ".keiyaku", "projection-alias");
+    try {
+        for (const alias of fs.readdirSync(aliasRoot).sort()) {
+            if (alias.startsWith("."))
+                continue;
+            const id = readProjectionAlias(cwd, alias);
+            if (id)
+                aliases.set(id, alias);
+        }
+    }
+    catch (error) {
+        if (!(isErrnoException(error) && error.code === "ENOENT"))
+            throw error;
+    }
+    const rows = [];
+    for (const akuma of entries.sort()) {
+        if (akuma.startsWith("."))
+            continue;
+        const akumaDir = path.join(root, akuma);
         try {
-            return fs.lstatSync(path.join(root, entry)).isDirectory();
+            if (!fs.lstatSync(akumaDir).isDirectory())
+                continue;
         }
         catch {
-            return false;
+            continue;
         }
-    })
-        .sort()
-        .map((id) => readProjectionRow(path.join(root, id), id, nowMs));
-    return rows.length > 0 ? { rows } : null;
+        for (const hex of fs.readdirSync(akumaDir).sort()) {
+            const id = `${akuma}/${hex}`;
+            const dir = path.join(akumaDir, hex);
+            if (!isProjectionId(id))
+                continue;
+            try {
+                if (!fs.lstatSync(dir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            rows.push(readProjectionRow(dir, id, aliases.get(id), nowMs));
+        }
+    }
+    return rows.length > 0 ? prioritizeProjectionStatusRows(rows, options.showAll === true) : null;
 }

package/build/core/projection-wake.js

@@ -116,6 +116,9 @@ export async function tellProjection(projectionDirectory, effort) {
                 ? await startCommittedSuccessor(projectionDirectory, successorExecutionId)
                 : "pending";
         }
+        if (life.phase !== "done") {
+            return "pending";
+        }
         const transition = store.launchIfSettled({
             executionId: successorExecutionId,
             facts,

package/build/core/response-artifact-id.js

@@ -0,0 +1,5 @@
+/** Neutral response-artifact identity grammar. Sole production regex for rsp_<ULID>. */
+export const RESPONSE_ARTIFACT_ID_RE = /^rsp_[0-9A-HJKMNP-TV-Z]{26}$/;
+export function isResponseArtifactId(value) {
+    return RESPONSE_ARTIFACT_ID_RE.test(value);
+}

package/build/core/status.js

@@ -528,7 +528,7 @@ export async function readKanshiBoard(cwd, now, opts) {
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
     return {
         contracts: filteredContracts,
-        projections: readProjectionStatusBoard(cwd, now),
+        projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,

package/build/core/transcripts.js

@@ -8,15 +8,17 @@ import { FlowError, requireText } from "../flow-error.js";
 import { getCurrentBranch } from "../git/branches.js";
 import { getLatestCommitHash } from "../git/staging.js";
 import { RESPONSE_ARTIFACT_NOTICE, RESPONSE_HISTORY_DIR } from "../keiyaku.js";
+import { attachAddressCarrier } from "./addressing.js";
 import { parseExecutionCoordinates } from "./execution-coordinate.js";
 import { createUlid } from "./ids.js";
 import { parseToAST } from "./markdown/parser.js";
+import { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
+export { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
 const RESPONSE_HISTORY_SLUG_MAX_LENGTH = 24;
 const RESPONSE_HISTORY_SESSION_KEY = "session";
 const RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY = "launch_snapshot";
 const RESPONSE_HISTORY_PROVENANCE_KEY = "provenance";
 const REVIEW_HISTORY_FILE_RE = /^\d{8}-\d{9}_REVIEW_(\d+)\.md$/;
-export const RESPONSE_ARTIFACT_ID_RE = /^rsp_[0-9A-HJKMNP-TV-Z]{26}$/;
 export const RESPONSE_ARTIFACT_HEADINGS = {
     call: "# Call",
     bind: "# Bind",
@@ -207,24 +209,41 @@ export async function readResponseArtifact(input) {
     const storageRoot = path.resolve(path.dirname(absolutePath), "..", "..");
     return { artifactId: provenance.artifactId, responsePath: path.relative(input.cwd, absolutePath), absolutePath, storageRoot, provenance, tool, ...(session ? { session } : {}), ...(launchSnapshot ? { launchSnapshot } : {}), ...(subagentName ? { subagentName } : {}) };
 }
-export async function locateResponseArtifact(cwd, artifactId) {
-    const identity = requireText("artifactId", artifactId);
-    if (!RESPONSE_ARTIFACT_ID_RE.test(identity))
-        throw artifactError(identity, "provenance.artifactId", "must be rsp_ followed by a ULID");
-    const historyDir = path.join(cwd, RESPONSE_HISTORY_DIR);
+export async function locateResponseArtifact(input) {
+    const carry = (error) => {
+        throw attachAddressCarrier(error, input.attempt);
+    };
+    let identity;
+    try {
+        identity = requireText("artifactId", input.artifactId);
+    }
+    catch (error) {
+        return carry(error);
+    }
+    if (!isResponseArtifactId(identity)) {
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; revive expects an artifact id`));
+    }
+    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
     let names;
     try {
         names = await fs.readdir(historyDir);
     }
     catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`);
-        throw error;
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
+        }
+        return carry(error);
     }
     let match;
     for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
         const responsePath = path.join(RESPONSE_HISTORY_DIR, name);
-        const document = await fs.readFile(path.join(cwd, responsePath), "utf8");
+        let document;
+        try {
+            document = await fs.readFile(path.join(input.cwd, responsePath), "utf8");
+        }
+        catch (error) {
+            return carry(error);
+        }
         const encoded = parseToAST(document).frontmatter?.entries?.[RESPONSE_HISTORY_PROVENANCE_KEY];
         if (encoded === undefined)
             continue;
@@ -237,15 +256,23 @@ export async function locateResponseArtifact(cwd, artifactId) {
         }
         if (!isRecord(indexed) || indexed.artifactId !== identity)
             continue;
-        const parsed = await readResponseArtifact({ cwd, responsePath });
+        let parsed;
+        try {
+            parsed = await readResponseArtifact({ cwd: input.cwd, responsePath });
+        }
+        catch (error) {
+            return carry(error);
+        }
         if (!parsed)
             continue;
-        if (match)
-            throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${identity}' is duplicated in ${historyDir}.`);
+        if (match) {
+            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${identity}' is duplicated in ${historyDir}.`));
+        }
         match = parsed;
     }
-    if (!match)
-        throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`);
+    if (!match) {
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
+    }
     return match;
 }
 export function requireResumableArtifact(artifact) {

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.8.0";
+export const VERSION = "2.8.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",
@@ -33,7 +33,7 @@
     "preversion": "npm test --silent",
     "version": "npm run sync:version --silent && git add src/generated/version.ts",
     "dev": "npx tsx src/index.ts",
-    "build": "rm -rf build && npx tsc && chmod +x build/index.js",
+    "build": "node scripts/build.mjs",
     "test:typecheck": "npx tsc --project tsconfig.tests.json",
     "prepublishOnly": "npm run build",
     "start": "node build/index.js",
@@ -48,10 +48,10 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
-    "@earendil-works/pi-coding-agent": "0.80.2",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opencode-ai/sdk": "1.17.20",
     "@openai/codex-sdk": "^0.113.0",
+    "@opencode-ai/sdk": "1.17.20",
     "simple-git": "^3.21.0",
     "zod": "4.3.6"
   },