@astrosheep/keiyaku 2.9.2 → 2.9.4

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

@@ -0,0 +1,61 @@
+import * as path from "node:path";
+import { ProjectionStateError } from "../atomic-publish.js";
+import { createGit, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, } from "../../git/core.js";
+import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
+import { gitCommonRootPath, resolveGitCommonRoot } from "../../git/path-coordinate.js";
+/**
+ * Resolve projection storage root and authority from one Git probe.
+ *
+ * A non-bare repository uses the parent of its absolute common Git directory,
+ * so every linked worktree shares one coordinate. Repo-free callers retain the
+ * existing cwd-local authority until its replacement is legislated.
+ */
+export async function resolveProjectionCoordinate(cwd) {
+    cwd = normalizeFilesystemCoordinate(cwd);
+    const git = createGit(cwd);
+    let response;
+    try {
+        response = await git.raw([
+            "rev-parse",
+            "--is-bare-repository",
+            "--path-format=absolute",
+            "--git-common-dir",
+        ]);
+    }
+    catch (error) {
+        if (isGitExecutableUnavailable(error)) {
+            return { physicalRoot: cwd, authority: { kind: "user" } };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (NOT_GIT_REPOSITORY_PATTERNS.some((pattern) => message.includes(pattern))) {
+            return { physicalRoot: cwd, authority: { kind: "user" } };
+        }
+        throw new ProjectionStateError(`cannot resolve projection repository coordinate: ${message}`);
+    }
+    const [bare, commonDir] = response.trim().split(/\r?\n/);
+    const stableRoot = commonDir === undefined ? undefined : gitCommonRootPath(commonDir);
+    if (bare !== "false" || !commonDir || !stableRoot || !path.isAbsolute(stableRoot)) {
+        return { physicalRoot: cwd, authority: { kind: "user" } };
+    }
+    let physicalRoot;
+    try {
+        physicalRoot = await resolveGitCommonRoot(commonDir);
+    }
+    catch (error) {
+        throw new ProjectionStateError(`cannot resolve projection repository root ${stableRoot}`, { cause: error });
+    }
+    return {
+        physicalRoot,
+        authority: { kind: "repository", stableRoot: physicalRoot },
+    };
+}
+/**
+ * Select the filesystem authority for repository projection state.
+ *
+ * A non-bare repository uses the parent of its absolute common Git directory,
+ * so every linked worktree shares one coordinate. Repo-free callers retain the
+ * existing cwd-local authority until its replacement is legislated.
+ */
+export async function projectionCoordinateRoot(cwd) {
+    return (await resolveProjectionCoordinate(cwd)).physicalRoot;
+}

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

@@ -1,25 +1,25 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
+import { isErrnoException } from "../../errno.js";
 import { projectionCoordinateRoot } from "./projection-coordinate.js";
-import { ProjectionStateError, } from "./atomic-publish.js";
-export { atomicPublishFile, ProjectionStateError, randomHex8 } from "./atomic-publish.js";
-export { isTellCausallyConsumed, } from "./projection/tell/model.js";
-export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./projection/tell/store.js";
+import { ProjectionStateError, } from "../atomic-publish.js";
+export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
+export { isTellCausallyConsumed, } from "./tell/model.js";
+export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
 export const PROJECTION_ID_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*\/[0-9a-f]{8}$/;
 export function isProjectionId(value) {
     return PROJECTION_ID_PATTERN.test(value);
 }
-export function projectionRoot(cwd) {
-    return path.join(projectionCoordinateRoot(cwd), ...PROJECTION_ROOT_SEGMENTS);
+export async function projectionRoot(cwd) {
+    return path.join(await projectionCoordinateRoot(cwd), ...PROJECTION_ROOT_SEGMENTS);
 }
-export function projectionDir(cwd, id) {
+export async function projectionDir(cwd, id) {
     if (!isProjectionId(id))
         throw new ProjectionStateError(`invalid projection id: ${id}`);
     const [akuma, hex] = id.split("/");
-    return path.join(projectionRoot(cwd), akuma, hex);
+    return path.join(await projectionRoot(cwd), akuma, hex);
 }
 export function encodeProjectionJson(value) {
     return `${JSON.stringify(value)}\n`;

package/build/core/{projection-execution-observer.js → projection/projection-execution-observer.js}

@@ -1,59 +1,5 @@
-import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
-import { openProjectionTellObserver, } from "./projection/tell/database.js";
-function frameTellBodies(projectionDirectory, tellIds) {
-    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
-    const frames = originals
-        .map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`)
-        .join("\n\n");
-    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
-    return { frames, ...(effort ? { effort } : {}) };
-}
-function operatorBodyForContinuation(prompt, tellFrames, sessionContinuationPromptPrefix) {
-    return sessionContinuationPromptPrefix === undefined
-        ? `${prompt}\n\n${tellFrames}`
-        : `${sessionContinuationPromptPrefix}${tellFrames}`;
-}
-/** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
-export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId, options = {}) {
-    const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
-    if (tellIds.length === 0)
-        return { prompt, tellIds };
-    const { frames, effort } = frameTellBodies(projectionDirectory, tellIds);
-    const nextPrompt = operatorBodyForContinuation(prompt, frames, options.sessionContinuationPromptPrefix);
-    return { prompt: nextPrompt, tellIds, ...(effort ? { effort } : {}) };
-}
-/** Tier-2 has no steer acknowledgement: actual driver start is its ordinal-zero submission point. */
-export function markReplayStarted(projectionDirectory, executionId, tellIds) {
-    for (const tellId of tellIds) {
-        if (listTellIds(projectionDirectory, "inflight").includes(tellId)) {
-            markTellSubmitted(projectionDirectory, tellId, { executionId, fence: { kind: "ordinal", ordinal: 0 } });
-        }
-    }
-}
-/** A successful replay terminal is checkpoint ordinal one; failures intentionally do not consume. */
-export function markReplayCompleted(projectionDirectory, executionId) {
-    for (const tellId of listTellIds(projectionDirectory, "submitted")) {
-        const submitted = readTellSubmitted(projectionDirectory, tellId);
-        if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, { kind: "ordinal", ordinal: 1 })) {
-            markTellConsumed(projectionDirectory, tellId);
-        }
-    }
-}
-/**
- * Tier-2's only submission acknowledgement. A created driver is deliberately
- * insufficient: observe the first provider event, or a successful completion
- * from a provider that emitted no events.
- */
-export function createReplayRunStartGate(projectionDirectory, executionId, tellIds) {
-    let started = false;
-    const start = () => {
-        if (started)
-            return;
-        markReplayStarted(projectionDirectory, executionId, tellIds);
-        started = true;
-    };
-    return { observeProviderEvent: start, observeSuccessfulCompletion: start };
-}
+import { claimAllInbox, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
+import { openProjectionTellObserver, } from "./tell/database.js";
 const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
 function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, observer, pendingCompletionEvidence) {
     if (requireInbox && !observer?.hasInbox())
@@ -232,7 +178,6 @@ export function createProjectionExecutionObserver(input, dependencies = {}) {
     let closed = false;
     const observer = {
         onEvent(event) {
-            input.replayStartGate?.observeProviderEvent();
             appendEvent(input.projectionDirectory, input.executionId, event);
         },
         onCheckpoint(control, checkpoint) {

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

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
+import { openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 /** Read the immutable projection identity from the heart database. */
 export function readProjectionIdentity(projectionDirectory) {
     const heart = openProjectionGenerationStoreReadOnly(projectionDirectory);

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

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStore } from "./projection/generation/store.js";
+import { openProjectionGenerationStore } from "./generation/store.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 function settleReleasedLeash(store, projectionDirectory, executionId) {
     const observation = observeProjectionRunnerLock(projectionDirectory);

package/build/core/{projection-life-observer.js → projection/projection-life-observer.js}

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
+import { openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 function errorDetail(error) {

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

@@ -1,10 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
-import { ProjectionStateError, randomHex8 } from "./atomic-publish.js";
+import { isErrnoException } from "../../errno.js";
+import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 import { isoFromNowMs, PROJECTION_ROOT_SEGMENTS, projectionDir, projectionRoot, } from "./projection-core.js";
-import { parseExecutionAuthoritySelection, parseExecutionPact, parseExecutionPactFields, } from "./execution-pact.js";
-import { openProjectionGenerationStore } from "./projection/generation/store.js";
+import { parseExecutionAuthoritySelection, parseExecutionPact, parseExecutionPactFields, } from "../execution-pact.js";
+import { openProjectionGenerationStore } from "./generation/store.js";
 import { initializeProjectionRunnerLockDatabase } from "./projection-runner-lock.js";
 export class ProjectionMintCollisionError extends Error {
     code = "PROJECTION_MINT_COLLISION";
@@ -38,7 +38,7 @@ function removeEmptyAkumaRoot(dir) {
  * Validate mint inputs that can fail, then reserve one private staging directory.
  * Dot-prefixed staging is never a published projection address.
  */
-function reserveProjectionDirectory(input) {
+async function reserveProjectionDirectory(input) {
     const slug = assertMintSlug(input.slug);
     if (!Number.isInteger(input.pid) || input.pid < 0) {
         throw new ProjectionStateError("projection pid must be a non-negative integer");
@@ -50,7 +50,7 @@ function reserveProjectionDirectory(input) {
     if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
         throw new ProjectionStateError("maxAttempts must be a positive integer");
     }
-    const root = projectionRoot(input.cwd);
+    const root = await projectionRoot(input.cwd);
     fs.mkdirSync(root, { recursive: true });
     const akumaRoot = path.join(root, slug);
     const createdAkumaRoot = !fs.existsSync(akumaRoot);
@@ -63,7 +63,7 @@ function reserveProjectionDirectory(input) {
             throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
         }
         const id = `${slug}/${hex}`;
-        const dir = projectionDir(input.cwd, id);
+        const dir = await projectionDir(input.cwd, id);
         const stagingDir = path.join(akumaRoot, `.mint-${hex}`);
         if (fs.existsSync(dir))
             continue;
@@ -132,7 +132,7 @@ function publishReservedProjection(pact, reserved) {
  * Mint a user-authority projection directory.
  * Order (closed): validate → reserve staging → heart + leash → atomic rename.
  */
-export function mintProjection(input) {
+export async function mintProjection(input) {
     const authority = parseExecutionAuthoritySelection(input.authority, "projection identity", "user");
     const fields = parseExecutionPactFields(buildMintPactFields(input));
     const pact = parseExecutionPact({
@@ -146,7 +146,7 @@ export function mintProjection(input) {
         workspaceRoot: fields.workspaceRoot,
         ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
     });
-    const reserved = reserveProjectionDirectory(input);
+    const reserved = await reserveProjectionDirectory(input);
     return publishReservedProjection(pact, reserved);
 }
 /**
@@ -156,7 +156,7 @@ export function mintProjection(input) {
 export async function mintRepositoryProjection(input) {
     parseExecutionAuthoritySelection(input.authority, "projection identity", "repository");
     const fields = parseExecutionPactFields(buildMintPactFields(input));
-    const reserved = reserveProjectionDirectory(input);
+    const reserved = await reserveProjectionDirectory(input);
     const pact = parseExecutionPact({
         version: fields.version,
         pid: fields.pid,

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

@@ -1,19 +1,20 @@
 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 { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
+import { worktreeContainsCoordinate } from "../worktree-path.js";
+import { projectTerminalFailure, } from "./projection-terminal-failure.js";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
-export const DEFAULT_PROJECTION_STATUS_ROW_BUDGET = 20;
 const STATUS_GROUP = {
     "startup-timeout": 0,
     lost: 0,
@@ -63,9 +64,7 @@ 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,
@@ -74,12 +73,6 @@ export function prioritizeProjectionStatusRows(rows, showAll) {
         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;
     }
@@ -97,10 +90,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) {
@@ -268,7 +260,7 @@ function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallb
         diagnostics.push(invalidActivity);
     const activityAtMs = latestValidEventAtMs(events) ?? fallbackAtMs;
     return {
-        ...(events.length > 0 ? { activity: foldAgentActivity(events) } : {}),
+        ...(events.length > 0 ? { activity: foldPublicProjectionActivity(events) } : {}),
         ...(activityAtMs !== undefined
             ? {
                 activityAtMs,
@@ -304,11 +296,17 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         ? Date.parse(adoptedAt)
         : Number.NaN;
     const activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, Number.isFinite(adoptedAtMs) ? adoptedAtMs : undefined);
+    const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
+    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 } : {}),
@@ -319,12 +317,14 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         mintedAt: identityFacts.mintedAt,
         ...(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 +349,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 +382,83 @@ 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 phase = observeProjectionLifeSnapshot(projectionDir, {
+                nowMs: input.nowMs,
+                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+            }).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,104 @@
+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_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 } : {}),
+    };
+}