@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/{projection-status.js → projection/projection-status.js}

@@ -1,19 +1,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
+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 { foldAgentActivity, } from "./projection-activity.js";
+import { ProjectionStateError } from "../atomic-publish.js";
+import { foldPublicProjectionActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { readProjectionTellCounts } from "./projection/tell/store.js";
-import { isProjectionGenerationSchemaV1Residue, ProjectionGenerationStoreError, } from "./projection/generation/store.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.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 { 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";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
-export const DEFAULT_PROJECTION_STATUS_ROW_BUDGET = 20;
 const STATUS_GROUP = {
     "startup-timeout": 0,
     lost: 0,
@@ -25,13 +27,15 @@ const STATUS_GROUP = {
     done: 3,
     killed: 4,
     dismissed: 4,
+    incompatible: 5,
 };
 function isOmissibleProjectionStatusState(state) {
     return state === "failed"
         || state === "dead"
         || state === "done"
         || state === "killed"
-        || state === "dismissed";
+        || state === "dismissed"
+        || state === "incompatible";
 }
 function rowSortTime(row) {
     if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
@@ -63,23 +67,16 @@ 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 visible = ordered.filter((row) => !isOmissibleProjectionStatusState(row.state));
     const byState = {
         failed: 0,
         dead: 0,
         done: 0,
         killed: 0,
         dismissed: 0,
+        incompatible: 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;
     }
@@ -97,10 +94,9 @@ class ProjectionStatusFileError extends Error {
     }
 }
 function oversizedProjectionFileDiagnostic(filePath) {
-    const label = path.basename(filePath);
     return {
         kind: "oversized-projection-file",
-        detail: `${label} exceeds status read limit · newest complete events retained`,
+        fileName: path.basename(filePath),
     };
 }
 function recordProjectionStatusFileError(error, diagnostics) {
@@ -247,84 +243,130 @@ function readStoredEvents(projectionDir, executionId, diagnostics) {
     }
     return values;
 }
-function latestValidEventAtMs(events) {
+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)
-            latest = atMs;
+        if (latest === undefined || atMs > latest.atMs)
+            latest = { at: event.at, atMs };
     }
     return latest;
 }
-function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAtMs) {
-    if (!executionId)
-        return {};
+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 activityAtMs = latestValidEventAtMs(events) ?? fallbackAtMs;
+    const latest = latestValidEvent(events) ?? validFallback;
     return {
-        ...(events.length > 0 ? { activity: foldAgentActivity(events) } : {}),
-        ...(activityAtMs !== undefined
+        ...(events.length > 0 ? { activity: foldPublicProjectionActivity(events) } : {}),
+        ...(latest !== undefined
             ? {
-                activityAtMs,
-                activityAgeMs: Math.max(0, nowMs - activityAtMs),
+                activityAt: latest.at,
+                activityAtMs: latest.atMs,
+                activityAgeMs: Math.max(0, nowMs - latest.atMs),
             }
             : {}),
     };
 }
+function terminalTimestamp(current) {
+    return extractTerminalTimestamp(current?.verdict?.facts);
+}
 function readProjectionRow(projectionDir, id, alias, nowMs) {
     const diagnostics = [];
+    const snapshot = observeProjectionLifeSnapshot(projectionDir, {
+        nowMs,
+        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+    });
+    if (snapshot.compatibility === "incompatible") {
+        return {
+            id,
+            ...(alias ? { alias } : {}),
+            state: "incompatible",
+            observation: snapshot,
+            tellCounts: emptyTellCounts(),
+            diagnostics,
+        };
+    }
     const identityFacts = readIdentityFacts(projectionDir, diagnostics);
     const tellCounts = identityFacts.identity
         ? readHeartTellCounts(projectionDir, diagnostics)
         : emptyTellCounts();
     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,
             diagnostics,
         };
     }
-    const observation = observeProjectionLifeSnapshot(projectionDir, {
-        nowMs,
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-    });
-    const life = observation.life;
-    const current = observation.records
-        ? selectCurrentGeneration(observation.records)
+    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 activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, Number.isFinite(adoptedAtMs) ? adoptedAtMs : undefined);
+    const activityFacts = 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,
     };
 }
-export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
-    const root = projectionRoot(cwd);
+export async function readProjectionStatusBoard(cwd, nowMs, options = {}) {
+    const root = await projectionRoot(cwd);
     try {
         if (!fs.lstatSync(root).isDirectory())
             return null;
@@ -349,7 +391,7 @@ export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
         for (const alias of fs.readdirSync(aliasRoot).sort()) {
             if (alias.startsWith("."))
                 continue;
-            const id = readProjectionAlias(cwd, alias);
+            const id = await readProjectionAlias(cwd, alias);
             if (id)
                 aliases.set(id, alias);
         }
@@ -382,10 +424,86 @@ export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
             catch {
                 continue;
             }
-            if (isProjectionGenerationSchemaV1Residue(dir))
-                continue;
             rows.push(readProjectionRow(dir, id, aliases.get(id), nowMs));
         }
     }
     return rows.length > 0 ? prioritizeProjectionStatusRows(rows, options.showAll === true) : null;
 }
+/**
+ * Renew-only lifecycle guard. Immutable identity is checked before lifecycle,
+ * so an unrelated or unattributable projection cannot block a commission.
+ */
+export async function hasStrandableProjectionGeneration(input) {
+    const root = await projectionRoot(input.cwd);
+    let akumas;
+    try {
+        if (!fs.lstatSync(root).isDirectory())
+            return false;
+        akumas = fs.readdirSync(root);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    for (const akuma of akumas.sort()) {
+        if (akuma.startsWith("."))
+            continue;
+        const akumaDir = path.join(root, akuma);
+        try {
+            if (!fs.lstatSync(akumaDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        let hexes;
+        try {
+            hexes = fs.readdirSync(akumaDir);
+        }
+        catch {
+            continue;
+        }
+        for (const hex of hexes.sort()) {
+            const projectionId = `${akuma}/${hex}`;
+            const projectionDir = path.join(akumaDir, hex);
+            if (!isProjectionId(projectionId))
+                continue;
+            try {
+                if (!fs.lstatSync(projectionDir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            let identity;
+            try {
+                identity = readProjectionIdentity(projectionDir);
+            }
+            catch {
+                // Corrupt identity has no trustworthy commission/worktree join and
+                // therefore cannot become a repository-wide renew interlock.
+                continue;
+            }
+            if (identity.binding.kind !== "commission"
+                || identity.binding.commissionId !== input.commissionId
+                || !worktreeContainsCoordinate(input.deliveryWorktree, identity.workspaceRoot)) {
+                continue;
+            }
+            const observation = observeProjectionLifeSnapshot(projectionDir, {
+                nowMs: input.nowMs,
+                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+            });
+            if (observation.compatibility !== "current")
+                continue;
+            const phase = observation.life.phase;
+            if (phase === "active"
+                || phase === "minting"
+                || phase === "startup-timeout"
+                || phase === "unknown") {
+                return true;
+            }
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,106 @@
+import { constants as osConstants } from "node:os";
+import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
+import { OUTCOME_ERROR_VERSION } from "../../agents/types.js";
+const HARNESS_FAILURE_CODES = new Set([
+    "SUBAGENT_TIMEOUT",
+    "SUBAGENT_TRANSPORT_ERROR",
+    "SUBAGENT_POLICY_BUDGET",
+    "SUBAGENT_NON_ZERO_EXIT",
+    "SUBAGENT_SPAWN_ERROR",
+    "SUBAGENT_EXEC_ERROR",
+    "SUBAGENT_PROVIDER_UNAVAILABLE",
+]);
+const SYSTEM_SIGNALS = new Set(Object.keys(osConstants.signals));
+function objectValue(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function failureCode(value) {
+    return typeof value === "string" && HARNESS_FAILURE_CODES.has(value)
+        ? value
+        : undefined;
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+function exitCode(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
+}
+function signal(value) {
+    return typeof value === "string" && SYSTEM_SIGNALS.has(value)
+        ? value
+        : undefined;
+}
+function artifactId(source) {
+    for (const value of [source.artifactId, source.sourceArtifactId]) {
+        if (typeof value === "string" && RESPONSE_ARTIFACT_ID_RE.test(value))
+            return value;
+    }
+    return undefined;
+}
+function providerFailureCause(value) {
+    const source = objectValue(value);
+    return source?.kind === "rate_limit_exhausted"
+        ? { kind: "rate_limit_exhausted" }
+        : undefined;
+}
+/**
+ * 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.
+ */
+export function projectTerminalFailure(state, facts) {
+    if (state !== "failed" && state !== "lost-runner" && state !== "launch-failed")
+        return undefined;
+    const source = objectValue(facts);
+    if (!source)
+        return undefined;
+    const error = objectValue(source.error);
+    const publicArtifactId = artifactId(source);
+    // Runner verdict authority wins classification even when harness evidence is
+    // also attached to the verdict.
+    if (state === "launch-failed" || state === "lost-runner") {
+        const phase = state === "lost-runner"
+            ? "adoption"
+            : source.stage === "spawn" ? "launch" : "adoption";
+        const code = phase === "launch"
+            ? "SUBAGENT_SPAWN_ERROR"
+            : "SUBAGENT_EXEC_ERROR";
+        const timeoutMs = nonNegativeNumber(error?.timeoutMs ?? source.timeoutMs);
+        const publicExitCode = exitCode(error?.exitCode ?? source.exitCode);
+        const publicSignal = signal(error?.signal ?? source.signal);
+        return {
+            class: "runner",
+            code,
+            phase,
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            ...(publicExitCode !== undefined ? { exitCode: publicExitCode } : {}),
+            ...(publicSignal ? { signal: publicSignal } : {}),
+            ...(publicArtifactId ? { artifactId: publicArtifactId } : {}),
+        };
+    }
+    if (error?.version !== OUTCOME_ERROR_VERSION)
+        return undefined;
+    const publicSignal = signal(error?.signal ?? source.signal);
+    const publicExitCode = exitCode(error?.exitCode ?? source.exitCode);
+    const code = failureCode(error?.code ?? source.code)
+        ?? (publicSignal ? "SUBAGENT_EXEC_ERROR" : undefined)
+        ?? (publicExitCode !== undefined ? "SUBAGENT_NON_ZERO_EXIT" : undefined);
+    if (!code || code === "SUBAGENT_SPAWN_ERROR")
+        return undefined;
+    const timeoutMs = nonNegativeNumber(error?.timeoutMs ?? source.timeoutMs);
+    const publicCause = providerFailureCause(error?.publicCause);
+    return {
+        class: "harness",
+        code,
+        phase: source.phase === "adoption" ? "adoption" : "runtime",
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(publicExitCode !== undefined ? { exitCode: publicExitCode } : {}),
+        ...(publicSignal ? { signal: publicSignal } : {}),
+        ...(publicArtifactId ? { artifactId: publicArtifactId } : {}),
+        ...(publicCause ? { publicCause } : {}),
+    };
+}