@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/projection/projection-status.js

@@ -1,20 +1,14 @@
 import fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../../errno.js";
-import { executionEventsPath, isProjectionId, projectionRoot, } from "./projection-core.js";
-import { readProjectionAlias } from "./projection-alias.js";
-import { ProjectionStateError } from "../atomic-publish.js";
-import { foldPublicProjectionActivity, } from "./projection-activity.js";
+import { isProjectionId, projectionRoot, projectionRootAtCoordinate } from "./projection-core.js";
+import { projectionAliasRootAtCoordinate, readProjectionAliasAtRoot, } from "./projection-alias.js";
+import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { readProjectionTellCounts } from "./tell/store.js";
-import { ProjectionGenerationStoreError, } from "./generation/store.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
-import { selectCurrentGeneration, } from "./projection-life-protocol.js";
-import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
 import { worktreeContainsCoordinate } from "../worktree-path.js";
-import { projectTerminalFailure, } from "./projection-terminal-failure.js";
-import { extractTerminalTimestamp } from "./generation/model.js";
+import { readProjectionRow, readProjectionSummary } from "./projection-status-observation.js";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
 const STATUS_GROUP = {
     "startup-timeout": 0,
@@ -84,324 +78,13 @@ export function prioritizeProjectionStatusRows(rows) {
 export function requiresProjectionStatusDetails(state) {
     return !isOmissibleProjectionStatusState(state);
 }
-class ProjectionStatusFileError extends Error {
-    diagnostic;
-    constructor(kind, filePath) {
-        const label = path.basename(filePath);
-        const detail = `${label} is not a regular file`;
-        super(detail);
-        this.name = "ProjectionStatusFileError";
-        this.diagnostic = { kind, detail };
-    }
-}
-function oversizedProjectionFileDiagnostic(filePath) {
-    return {
-        kind: "oversized-projection-file",
-        fileName: path.basename(filePath),
-    };
-}
-function recordProjectionStatusFileError(error, diagnostics) {
-    if (!(error instanceof ProjectionStatusFileError))
-        return false;
-    diagnostics.push(error.diagnostic);
-    return true;
-}
-function readBoundedRegularFileTail(filePath) {
-    const before = fs.lstatSync(filePath);
-    if (!before.isFile())
-        throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-    let fd;
-    try {
-        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | fs.constants.O_NOFOLLOW);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ELOOP") {
-            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-        }
-        throw error;
-    }
-    try {
-        const opened = fs.fstatSync(fd);
-        if (!opened.isFile())
-            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-        const snapshotSize = opened.size;
-        const truncated = snapshotSize > MAX_STATUS_FILE_BYTES;
-        const readLength = Math.min(snapshotSize, MAX_STATUS_FILE_BYTES);
-        const readOffset = Math.max(0, snapshotSize - MAX_STATUS_FILE_BYTES);
-        const buffer = Buffer.allocUnsafe(readLength);
-        let total = 0;
-        while (total < readLength) {
-            const bytesRead = fs.readSync(fd, buffer, total, readLength - total, readOffset + total);
-            if (bytesRead === 0)
-                break;
-            total += bytesRead;
-        }
-        let tail = buffer.subarray(0, total);
-        if (truncated) {
-            const firstLf = tail.indexOf(0x0a);
-            if (firstLf < 0) {
-                return { content: "", truncated: true };
-            }
-            tail = tail.subarray(firstLf + 1);
-        }
-        return { content: tail.toString("utf8"), truncated };
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function displayedTellCounts(counts) {
-    return {
-        inbox: counts.inbox,
-        inflight: counts.inflight,
-        submitted: counts.submitted,
-        consumed: counts.consumed,
-    };
-}
-function emptyTellCounts() {
-    return { inbox: 0, inflight: 0, submitted: 0, consumed: 0 };
-}
-function readIdentityFacts(projectionDir, diagnostics) {
-    try {
-        const identity = readProjectionIdentity(projectionDir);
-        return {
-            identity,
-            pid: identity.pid,
-            akuma: identity.akuma,
-            provider: identity.provider,
-            mintedAt: identity.mintedAt,
-            workspaceRoot: identity.workspaceRoot,
-        };
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            diagnostics.push({ kind: "missing-identity", detail: "heart identity missing" });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        if (error instanceof ProjectionGenerationStoreError) {
-            diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        if (error instanceof ProjectionStateError) {
-            diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        diagnostics.push({ kind: "unreadable-identity", detail: `heart identity unreadable: ${String(error)}` });
-        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
-    }
-}
-function readHeartTellCounts(projectionDir, diagnostics) {
-    try {
-        return displayedTellCounts(readProjectionTellCounts(projectionDir));
-    }
-    catch (error) {
-        if (error instanceof ProjectionGenerationStoreError || error instanceof ProjectionStateError) {
-            diagnostics.push({ kind: "unreadable-tells", detail: error.message });
-            return emptyTellCounts();
-        }
-        diagnostics.push({ kind: "unreadable-tells", detail: `heart tells unreadable: ${String(error)}` });
-        return emptyTellCounts();
-    }
-}
-function readStoredEvents(projectionDir, executionId, diagnostics) {
-    let content;
-    let truncated = false;
-    const eventsPath = executionEventsPath(projectionDir, executionId);
-    try {
-        const read = readBoundedRegularFileTail(eventsPath);
-        content = read.content;
-        truncated = read.truncated;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return [];
-        if (recordProjectionStatusFileError(error, diagnostics))
-            return [];
-        diagnostics.push({ kind: "unreadable-activity", detail: `activity ledger unreadable: ${String(error)}` });
-        return [];
-    }
-    if (truncated) {
-        diagnostics.push(oversizedProjectionFileDiagnostic(eventsPath));
-    }
-    // Parse only LF-terminated records. An unterminated final line is ignored even
-    // when it happens to parse: it may be a concurrent append fragment.
-    const lines = content.split("\n");
-    const values = [];
-    let malformed = 0;
-    for (const line of lines.slice(0, -1)) {
-        try {
-            values.push(JSON.parse(line));
-        }
-        catch {
-            malformed += 1;
-        }
-    }
-    if (malformed > 0) {
-        diagnostics.push({
-            kind: "invalid-activity-event",
-            detail: `${malformed} persisted activity event${malformed === 1 ? "" : "s"} malformed`,
-        });
-    }
-    return values;
-}
-function latestValidEvent(events) {
-    let latest;
-    for (const event of events) {
-        const atMs = Date.parse(event.at);
-        if (!Number.isFinite(atMs))
-            continue;
-        if (latest === undefined || atMs > latest.atMs)
-            latest = { at: event.at, atMs };
-    }
-    return latest;
-}
-function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAt) {
-    const fallbackAtMs = fallbackAt === undefined ? undefined : Date.parse(fallbackAt);
-    const validFallback = fallbackAt !== undefined && Number.isFinite(fallbackAtMs)
-        ? { at: fallbackAt, atMs: fallbackAtMs }
-        : undefined;
-    if (!executionId) {
-        return validFallback
-            ? { activityAt: validFallback.at, activityAtMs: validFallback.atMs, activityAgeMs: Math.max(0, nowMs - validFallback.atMs) }
-            : {};
-    }
-    const stored = readStoredEvents(projectionDir, executionId, diagnostics);
-    const { events, malformed } = selectValidStoredAgentEvents(stored);
-    const invalidActivity = invalidActivityEventDiagnostic(malformed);
-    if (invalidActivity)
-        diagnostics.push(invalidActivity);
-    const latest = latestValidEvent(events) ?? validFallback;
-    return {
-        ...(events.length > 0 ? { activity: foldPublicProjectionActivity(events) } : {}),
-        ...(latest !== undefined
-            ? {
-                activityAt: latest.at,
-                activityAtMs: latest.atMs,
-                activityAgeMs: Math.max(0, nowMs - latest.atMs),
-            }
-            : {}),
-    };
-}
-function terminalTimestamp(current) {
-    return extractTerminalTimestamp(current?.verdict?.facts);
-}
-function readProjectionSummary(projectionDir, id, alias, nowMs) {
-    const diagnostics = [];
-    const snapshot = observeProjectionLifeSnapshot(projectionDir, {
-        nowMs,
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-    });
-    if (snapshot.compatibility === "incompatible") {
-        return {
-            id,
-            ...(alias ? { alias } : {}),
-            projectionDir,
-            snapshot,
-            identityFacts: null,
-            diagnostics,
-            state: "incompatible",
-        };
-    }
-    const identityFacts = readIdentityFacts(projectionDir, diagnostics);
-    const life = snapshot.life;
-    const phase = life.phase;
-    const state = phase === "active" || phase === "quiescent" ? "out" : phase;
-    return {
-        id,
-        ...(alias ? { alias } : {}),
-        projectionDir,
-        snapshot,
-        identityFacts,
-        diagnostics,
-        state,
-    };
-}
-function readProjectionRow(summary, nowMs, readDetails) {
-    const { id, alias, projectionDir, snapshot } = summary;
-    const diagnostics = [...summary.diagnostics];
-    if (snapshot.compatibility === "incompatible") {
-        return {
-            id,
-            ...(alias ? { alias } : {}),
-            state: "incompatible",
-            observation: snapshot,
-            tellCounts: emptyTellCounts(),
-            diagnostics,
-        };
-    }
-    const identityFacts = summary.identityFacts;
-    if (!identityFacts.identity) {
-        const diagnostic = diagnostics.map((entry) => entry.detail).find((detail) => detail !== undefined)
-            ?? "projection identity could not be observed";
-        return {
-            id,
-            ...(alias ? { alias } : {}),
-            state: "unknown",
-            observation: {
-                compatibility: "current",
-                lifecycle: { phase: "unknown", diagnostic },
-            },
-            tellCounts: emptyTellCounts(),
-            diagnostics,
-        };
-    }
-    const life = snapshot.life;
-    const current = snapshot.records ? selectCurrentGeneration(snapshot.records) : null;
-    const adoptedAt = current?.adoption?.facts.adoptedAt;
-    const adoptedAtMs = typeof adoptedAt === "string"
-        ? Date.parse(adoptedAt)
-        : Number.NaN;
-    const tellCounts = readDetails
-        ? readHeartTellCounts(projectionDir, diagnostics)
-        : emptyTellCounts();
-    const activityFacts = readDetails
-        ? readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt)
-        : {};
-    const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
-    const terminalAt = terminalTimestamp(current);
-    const durationAnchorMs = current?.verdict
-        ? (terminalAt === undefined ? Number.NaN : Date.parse(terminalAt))
-        : nowMs;
-    const durationMs = Number.isFinite(mintedAtMs) && Number.isFinite(durationAnchorMs)
-        ? Math.max(0, durationAnchorMs - mintedAtMs)
-        : undefined;
-    const displayAgeMs = activityFacts.activityAgeMs
-        ?? (Number.isFinite(mintedAtMs) ? Math.max(0, nowMs - mintedAtMs) : undefined);
-    if (life.phase === "unknown" && life.diagnostic) {
-        diagnostics.push({ kind: "unknown-lifecycle", detail: life.diagnostic });
-    }
-    const phase = life.phase;
-    const state = phase === "active" || phase === "quiescent" ? "out" : phase;
-    const terminalFailure = current?.verdict
-        ? projectTerminalFailure(current.verdict.facts.state, current.verdict.facts)
-        : undefined;
-    return {
-        id,
-        ...(alias ? { alias } : {}),
-        state,
-        observation: { compatibility: "current", lifecycle: life },
-        akuma: identityFacts.akuma,
-        provider: identityFacts.provider,
-        pid: identityFacts.pid,
-        mintedAt: identityFacts.mintedAt,
-        ...(terminalAt ? { terminalAt } : {}),
-        ...(durationMs !== undefined ? { durationMs } : {}),
-        ...(identityFacts.workspaceRoot ? { workspaceRoot: identityFacts.workspaceRoot } : {}),
-        ...activityFacts,
-        ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
-        ...(terminalFailure ? { terminalFailure } : {}),
-        tellCounts,
-        diagnostics,
-    };
-}
-async function readProjectionStatusAliases(cwd, root) {
+async function readProjectionStatusAliases(root) {
     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()) {
+        for (const alias of fs.readdirSync(root).sort()) {
             if (alias.startsWith("."))
                 continue;
-            const id = await readProjectionAlias(cwd, alias);
+            const id = await readProjectionAliasAtRoot(root, alias);
             if (id)
                 aliases.set(id, alias);
         }
@@ -424,8 +107,8 @@ function readProjectionTopologyEntries(directory) {
         throw error;
     }
 }
-async function readProjectionRootTopology(cwd) {
-    const root = await projectionRoot(cwd);
+function readProjectionRootTopology(coordinate) {
+    const root = projectionRootAtCoordinate(coordinate);
     const akumas = readProjectionTopologyEntries(root);
     return akumas ? { root, akumas } : null;
 }
@@ -433,7 +116,7 @@ function readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs) {
     const akumaDir = path.join(root, akuma);
     const hexes = readProjectionTopologyEntries(akumaDir);
     if (!hexes)
-        return [];
+        return null;
     const summaries = [];
     for (const hex of hexes) {
         const id = `${akuma}/${hex}`;
@@ -447,7 +130,9 @@ function readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs) {
         catch {
             continue;
         }
-        summaries.push(readProjectionSummary(dir, id, aliases.get(id), nowMs));
+        summaries.push(readProjectionSummary(dir, id, aliases.get(id), nowMs, {
+            requiresIdentity: requiresProjectionStatusDetails,
+        }));
     }
     return summaries;
 }
@@ -456,24 +141,33 @@ function isNonterminalProjectionStatusSummary(summary) {
         && requiresProjectionStatusDetails(summary.state);
 }
 export async function readOperationalProjectionStatusBoard(cwd, nowMs) {
-    const topology = await readProjectionRootTopology(cwd);
+    const coordinate = await resolveProjectionCoordinate(cwd);
+    const topology = readProjectionRootTopology(coordinate);
     if (!topology)
         return null;
     const { root, akumas } = topology;
-    const aliases = await readProjectionStatusAliases(cwd, root);
+    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
     const summaries = [];
     for (const akuma of akumas) {
         if (akuma.startsWith("."))
             continue;
-        summaries.push(...readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs));
+        const scoped = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+        // Seeing an entry and then being unable to observe its namespace is not an
+        // observable zero. Keep the whole aggregate surface unavailable.
+        if (scoped === null)
+            return null;
+        summaries.push(...scoped);
     }
     const rows = summaries.map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)));
-    return rows.length > 0 ? prioritizeProjectionStatusRows(rows) : null;
+    // A published root is an observable surface even when it currently has no
+    // rows. The caller must distinguish that fact from an unavailable root.
+    return prioritizeProjectionStatusRows(rows);
 }
 export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
     if (!isProjectionId(projectionId))
         return null;
-    const root = await projectionRoot(cwd);
+    const coordinate = await resolveProjectionCoordinate(cwd);
+    const root = projectionRootAtCoordinate(coordinate);
     try {
         if (!fs.lstatSync(root).isDirectory())
             return null;
@@ -494,13 +188,14 @@ export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
             return null;
         throw error;
     }
-    const aliases = await readProjectionStatusAliases(cwd, root);
+    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
     return readProjectionRow(readProjectionSummary(dir, projectionId, aliases.get(projectionId), nowMs), nowMs, true);
 }
 export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
     if (!isProjectionId(`${akuma}/00000000`))
         return null;
-    const root = await projectionRoot(cwd);
+    const coordinate = await resolveProjectionCoordinate(cwd);
+    const root = projectionRootAtCoordinate(coordinate);
     try {
         if (!fs.lstatSync(root).isDirectory())
             return null;
@@ -510,8 +205,11 @@ export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
             return null;
         throw error;
     }
-    const aliases = await readProjectionStatusAliases(cwd, root);
-    const rows = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs)
+    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
+    const summaries = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+    if (summaries === null)
+        return null;
+    const rows = summaries
         .filter(isNonterminalProjectionStatusSummary)
         .map((summary) => readProjectionRow(summary, nowMs, true))
         .sort(compareProjectionStatusRows);

package/build/core/projection/projection-terminal-failure.js

@@ -43,15 +43,19 @@ function artifactId(source) {
 }
 function providerFailureCause(value) {
     const source = objectValue(value);
-    return source?.kind === "rate_limit_exhausted"
-        ? { kind: "rate_limit_exhausted" }
-        : undefined;
+    return source && isHarnessFailureValue(source) ? source : undefined;
+}
+function isHarnessFailureValue(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isHarnessFailureValue);
+    const object = objectValue(value);
+    return object !== undefined && Object.values(object).every(isHarnessFailureValue);
 }
-/**
- * Convert artifact-rich verdict facts into the strict public allowlist. Raw
- * messages, output, diagnostics, sessions, provider payloads, and unknown
- * strings have no path through this function.
- */
+/** Convert the public harness terminal failure into the shared projection face. */
 export function projectTerminalFailure(state, facts) {
     if (state !== "failed" && state !== "lost-runner" && state !== "launch-failed")
         return undefined;
@@ -97,6 +101,7 @@ export function projectTerminalFailure(state, facts) {
         class: "harness",
         code,
         phase: source.phase === "adoption" ? "adoption" : "runtime",
+        ...(typeof error.message === "string" ? { message: error.message } : {}),
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         ...(publicExitCode !== undefined ? { exitCode: publicExitCode } : {}),
         ...(publicSignal ? { signal: publicSignal } : {}),

package/build/core/projection/projection-wait.js

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { foldPublicProjectionActivity } from "./projection-activity.js";
-import { readGenerationEvents, isProjectionId, projectionRoot, } from "./projection-core.js";
+import { readGenerationEvents, isProjectionId, projectionRootAtCoordinate, } from "./projection-core.js";
+import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { readProjectionIdentity } from "./projection-identity.js";
 import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
 import { extractTerminalTimestamp } from "./generation/model.js";
@@ -15,7 +16,11 @@ import { tellProjection } from "./projection-wake.js";
 import { FlowError } from "../../flow-error.js";
 /** Return the commission-bound projection IDs visible at one admission instant. */
 export async function snapshotCommissionProjectionIds(cwd, commissionId) {
-    const root = await projectionRoot(cwd);
+    return snapshotCommissionProjectionIdsAtCoordinate(await resolveProjectionCoordinate(cwd), commissionId);
+}
+/** Scan one already-resolved projection coordinate for commission-bound IDs. */
+export async function snapshotCommissionProjectionIdsAtCoordinate(coordinate, commissionId) {
+    const root = projectionRootAtCoordinate(coordinate);
     let akumas;
     try {
         akumas = fs.readdirSync(root).sort();