@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/markdown/render.js

@@ -0,0 +1,68 @@
+function renderListItemFirstLine(item) {
+    const content = renderNodeContent(item);
+    if (!content) {
+        return `${" ".repeat(item.indent)}${item.marker}`;
+    }
+    const [firstLine, ...rest] = content.split("\n");
+    const prefix = `${" ".repeat(item.indent)}${item.marker}${firstLine.length > 0 ? " " : ""}${firstLine}`;
+    if (rest.length === 0) {
+        return prefix;
+    }
+    return [prefix, ...rest].join("\n");
+}
+export function renderBlock(node) {
+    switch (node.type) {
+        case "section": {
+            const header = `${"#".repeat(node.level)} ${node.title}`;
+            const body = renderNodeContent(node);
+            return body ? `${header}\n${body}` : header;
+        }
+        case "list":
+            return node.items.map((item) => renderListItemFirstLine(item)).join("\n");
+        case "code_block":
+            return node.lines.join("\n");
+        case "blockquote":
+            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
+        case "text":
+            return node.value;
+        case "heading":
+            return `${"#".repeat(node.level)} ${node.text}`;
+    }
+}
+export function renderNodeContent(node) {
+    switch (node.type) {
+        case "document":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "section":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "list":
+            return renderBlock(node);
+        case "list_item":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "code_block":
+            return node.lines.join("\n");
+        case "blockquote":
+            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
+        case "text":
+            return node.value;
+        case "heading":
+            return `${"#".repeat(node.level)} ${node.text}`;
+    }
+}
+export function renderSectionContent(sectionNode) {
+    return sectionNode.children.map((child) => renderBlock(child)).join("\n");
+}
+export function extractListItems(sectionNode) {
+    const items = [];
+    for (const child of sectionNode.children) {
+        if (child.type !== "list")
+            continue;
+        for (const item of child.items) {
+            const rendered = renderNodeContent(item).trimEnd();
+            if (rendered.trim().length > 0) {
+                items.push(rendered);
+            }
+        }
+    }
+    return items;
+}

package/build/core/markdown/sections.js

@@ -1,4 +1,5 @@
-import { extractListItems, parseToAST, renderBlock, renderSectionContent } from "./parser.js";
+import { parseToAST } from "./parser.js";
+import { extractListItems, renderBlock, renderSectionContent } from "./render.js";
 import { KeiyakuParseError } from "./types.js";
 import { normalizeSectionTitle } from "./titles.js";
 function splitByHeadingBlocks(sectionNode) {

package/build/core/outcome-base.js

@@ -0,0 +1,4 @@
+import { ACTOR_IDENTITY } from "../keiyaku.js";
+export function defaultActorClock(nowMs = Date.now()) {
+    return { actor: ACTOR_IDENTITY, nowMs };
+}

package/build/core/projection/generation/database.js

@@ -57,11 +57,40 @@ const TELL_TABLE_SQL = `
   ) STRICT
 `;
 const closedDatabases = new WeakSet();
+/** Classify only proved missing schema evidence as historical incompatibility. */
+export function projectionGenerationStoreInspectionError(databasePath, error) {
+    if (error instanceof ProjectionGenerationStoreError)
+        return error;
+    const code = error && typeof error === "object" && "code" in error
+        ? error.code
+        : undefined;
+    if (code === "ENOENT") {
+        return new ProjectionGenerationStoreError(`projection generation store does not exist at ${databasePath}`, {
+            cause: error,
+            observation: "incompatible",
+        });
+    }
+    return new ProjectionGenerationStoreError(`projection generation store could not be inspected at ${databasePath}`, {
+        cause: error,
+    });
+}
+function projectionGenerationStoreReadError(databasePath, error) {
+    if (error instanceof ProjectionGenerationStoreError)
+        return error;
+    const sqliteCode = error && typeof error === "object" && "errcode" in error
+        ? error.errcode
+        : undefined;
+    const incompatible = sqliteCode === 11 || sqliteCode === 26;
+    return new ProjectionGenerationStoreError(`cannot read projection generation store at ${databasePath}`, {
+        cause: error,
+        ...(incompatible ? { observation: "incompatible" } : {}),
+    });
+}
 function pragmaNumber(database, pragma) {
     const row = database.prepare(`PRAGMA ${pragma}`).get();
     const value = row ? Object.values(row)[0] : undefined;
     if (typeof value !== "number" && typeof value !== "bigint") {
-        throw new ProjectionGenerationStoreError(`PRAGMA ${pragma} returned an invalid value`);
+        throw new ProjectionGenerationStoreError(`PRAGMA ${pragma} returned an invalid value`, { observation: "incompatible" });
     }
     return Number(value);
 }
@@ -76,7 +105,7 @@ export function rollbackQuietly(database) {
 function validateSchemaShape(database) {
     const version = pragmaNumber(database, "user_version");
     if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-        throw new ProjectionGenerationStoreError(`projection generation schema version ${version} is not supported; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
+        throw new ProjectionGenerationStoreError(`incompatible projection generation schema version ${version}; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`, { observation: "incompatible" });
     }
     const objects = database.prepare(`
     SELECT name, type
@@ -86,36 +115,36 @@ function validateSchemaShape(database) {
   `).all();
     const signature = objects.map((object) => `${object.type}:${object.name}`).join(",");
     if (signature !== "table:generation_records,table:generation_schema,table:projection_identity,table:projection_tells") {
-        throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`);
+        throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`, { observation: "incompatible" });
     }
     const metadata = database.prepare("SELECT singleton, version FROM generation_schema").all();
     if (metadata.length !== 1 || Number(metadata[0].singleton) !== 1 || Number(metadata[0].version) !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-        throw new ProjectionGenerationStoreError("projection generation schema metadata is malformed");
+        throw new ProjectionGenerationStoreError("projection generation schema metadata is malformed", { observation: "incompatible" });
     }
     const recordColumns = database.prepare("PRAGMA table_info(generation_records)").all();
     const columnSignature = recordColumns
         .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
         .join(",");
     if (columnSignature !== "seq:INTEGER:0:1,kind:TEXT:1:0,execution_id:TEXT:1:0,facts_json:TEXT:1:0") {
-        throw new ProjectionGenerationStoreError("projection generation record schema is malformed");
+        throw new ProjectionGenerationStoreError("projection generation record schema is malformed", { observation: "incompatible" });
     }
     const identityColumns = database.prepare("PRAGMA table_info(projection_identity)").all();
     const identitySignature = identityColumns
         .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
         .join(",");
     if (identitySignature !== "singleton:INTEGER:0:1,version:INTEGER:1:0,pid:INTEGER:1:0,akuma:TEXT:1:0,provider:TEXT:1:0,authority_json:TEXT:1:0,binding_json:TEXT:1:0,minted_at:TEXT:1:0,workspace_root:TEXT:1:0,effective_policy_json:TEXT:0:0") {
-        throw new ProjectionGenerationStoreError("projection identity schema is malformed");
+        throw new ProjectionGenerationStoreError("projection identity schema is malformed", { observation: "incompatible" });
     }
     const tellColumns = database.prepare("PRAGMA table_info(projection_tells)").all();
     const tellSignature = tellColumns
         .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
         .join(",");
     if (tellSignature !== "tell_id:TEXT:1:1,text:TEXT:1:0,created_at:TEXT:1:0,effort:TEXT:0:0,state:TEXT:1:0,execution_id:TEXT:0:0,fence_json:TEXT:0:0,replayed_from_json:TEXT:0:0,delivered_at:TEXT:0:0") {
-        throw new ProjectionGenerationStoreError("projection tell schema is malformed");
+        throw new ProjectionGenerationStoreError("projection tell schema is malformed", { observation: "incompatible" });
     }
     const quickCheck = database.prepare("PRAGMA quick_check").get();
     if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
-        throw new ProjectionGenerationStoreError("projection generation database failed quick_check");
+        throw new ProjectionGenerationStoreError("projection generation database failed quick_check", { observation: "incompatible" });
     }
 }
 function initializeOrValidateSchema(database) {
@@ -138,7 +167,7 @@ function initializeOrValidateSchema(database) {
             database.exec(`PRAGMA user_version = ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
         }
         else if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-            throw new ProjectionGenerationStoreError(`projection generation schema version ${version} is not supported; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
+            throw new ProjectionGenerationStoreError(`incompatible projection generation schema version ${version}; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`, { observation: "incompatible" });
         }
         validateSchemaShape(database);
         database.exec("COMMIT");
@@ -195,13 +224,11 @@ export function openReadOnlyDatabase(projectionDirectory) {
     const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
     try {
         if (!fs.lstatSync(databasePath).isFile()) {
-            throw new ProjectionGenerationStoreError("projection generation store must be a regular file");
+            throw new ProjectionGenerationStoreError("projection generation store must be a regular file", { observation: "incompatible" });
         }
     }
     catch (error) {
-        if (error instanceof ProjectionGenerationStoreError)
-            throw error;
-        throw new ProjectionGenerationStoreError(`projection generation store does not exist at ${databasePath}`, { cause: error });
+        throw projectionGenerationStoreInspectionError(databasePath, error);
     }
     let database;
     try {
@@ -220,9 +247,7 @@ export function openReadOnlyDatabase(projectionDirectory) {
             database?.close();
         }
         catch { /* preserve the read/open failure */ }
-        if (error instanceof ProjectionGenerationStoreError)
-            throw error;
-        throw new ProjectionGenerationStoreError(`cannot read projection generation store at ${databasePath}`, { cause: error });
+        throw projectionGenerationStoreReadError(databasePath, error);
     }
 }
 export function assertDatabaseOpen(database) {
@@ -268,39 +293,3 @@ export function closeDatabase(database) {
     closedDatabases.add(database);
     database.close();
 }
-/**
- * Discovery-only predicate: a readable regular heart whose PRAGMA user_version
- * is exactly 1 is recognized historical residue. Never opens through the store
- * class, never mutates, and any observation failure returns false so callers
- * proceed into the strict current-schema reader.
- */
-export function isProjectionGenerationSchemaV1Residue(projectionDirectory) {
-    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-    let database;
-    let residue = false;
-    try {
-        if (!fs.lstatSync(databasePath).isFile())
-            return false;
-        database = new DatabaseSync(databasePath, {
-            readOnly: true,
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        configureHeartBusyTimeout(database);
-        residue = pragmaNumber(database, "user_version") === 1;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        if (database) {
-            try {
-                database.close();
-            }
-            catch {
-                residue = false;
-            }
-        }
-    }
-    return residue;
-}

package/build/core/projection/generation/model.js

@@ -1,13 +1,30 @@
-import { GENERATION_VERDICT_STATES, } from "../../projection-life-protocol.js";
+import { GENERATION_VERDICT_STATES, } from "../projection-life-protocol.js";
+import { OUTCOME_ERROR_VERSION, SUBAGENT_FAILURE_CODES } from "../../../agents/types.js";
 export { GENERATION_VERDICT_STATES };
 export const VERDICTS = new Set(GENERATION_VERDICT_STATES);
+const OUTCOME_ERROR_CODES = new Set(SUBAGENT_FAILURE_CODES);
+const OUTCOME_ERROR_KEYS = new Set([
+    "version",
+    "code",
+    "message",
+    "timeoutMs",
+    "exitCode",
+    "publicCause",
+]);
 export class ProjectionGenerationStoreError extends Error {
     code = "PROJECTION_GENERATION_STORE_ERROR";
+    /** Historical schemas/outcomes are not a current lifecycle observation. */
+    observation;
     constructor(message, options) {
         super(message, options);
         this.name = "ProjectionGenerationStoreError";
+        this.observation = options?.observation ?? "unknown";
     }
 }
+export function isIncompatibleProjectionGenerationStoreError(error) {
+    return error instanceof ProjectionGenerationStoreError
+        && error.observation === "incompatible";
+}
 export function isPlainObject(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -121,6 +138,40 @@ export function validateVerdictFacts(value, location) {
     if (typeof facts.state !== "string" || !VERDICTS.has(facts.state)) {
         throw new ProjectionGenerationStoreError(`${location}.state is not in the closed verdict vocabulary`);
     }
+    if (facts.terminalAt !== undefined) {
+        facts.terminalAt = assertIsoTimestamp(facts.terminalAt, `${location}.terminalAt`);
+    }
+    if (facts.state === "failed") {
+        const error = isPlainObject(facts.error) ? facts.error : undefined;
+        const version = error?.version;
+        if (!error || version !== OUTCOME_ERROR_VERSION) {
+            throw new ProjectionGenerationStoreError(`${location}.error has incompatible version ${version === undefined ? "missing" : String(version)}; expected ${OUTCOME_ERROR_VERSION}`, { observation: "incompatible" });
+        }
+        if (Object.keys(error).some((key) => !OUTCOME_ERROR_KEYS.has(key))) {
+            throw new ProjectionGenerationStoreError(`${location}.error is not the current closed OutcomeError shape`);
+        }
+        if (typeof error.code !== "string" || !OUTCOME_ERROR_CODES.has(error.code)) {
+            throw new ProjectionGenerationStoreError(`${location}.error.code is not a recognized subagent failure code`);
+        }
+        if (typeof error.message !== "string") {
+            throw new ProjectionGenerationStoreError(`${location}.error.message must be a string`);
+        }
+        if (error.timeoutMs !== null && (typeof error.timeoutMs !== "number"
+            || !Number.isSafeInteger(error.timeoutMs)
+            || error.timeoutMs < 0)) {
+            throw new ProjectionGenerationStoreError(`${location}.error.timeoutMs must be null or a non-negative safe integer`);
+        }
+        if (error.exitCode !== null && (typeof error.exitCode !== "number"
+            || !Number.isSafeInteger(error.exitCode))) {
+            throw new ProjectionGenerationStoreError(`${location}.error.exitCode must be null or a safe integer`);
+        }
+        if (error.publicCause !== undefined) {
+            const cause = isPlainObject(error.publicCause) ? error.publicCause : undefined;
+            if (!cause || cause.kind !== "rate_limit_exhausted" || Object.keys(cause).length !== 1) {
+                throw new ProjectionGenerationStoreError(`${location}.error.publicCause is not a current closed cause`);
+            }
+        }
+    }
     return facts;
 }
 export function parseStoredRow(row) {
@@ -140,7 +191,7 @@ export function parseStoredRow(row) {
         decoded = JSON.parse(row.facts_json);
     }
     catch (error) {
-        throw new ProjectionGenerationStoreError(`generation row ${seq} contains malformed facts JSON`, { cause: error });
+        throw new ProjectionGenerationStoreError(`generation row ${seq} contains malformed facts JSON`, { cause: error, observation: "incompatible" });
     }
     const location = `generation row ${seq} facts`;
     const facts = row.kind === "launch"
@@ -199,3 +250,13 @@ export function validateHistory(records) {
     }
     return current;
 }
+export function extractTerminalTimestamp(facts) {
+    if (!facts)
+        return undefined;
+    for (const key of ["completedAt", "failedAt", "dismissedAt", "killedAt", "terminalAt"]) {
+        const value = facts[key];
+        if (typeof value === "string" && Number.isFinite(Date.parse(value)))
+            return value;
+    }
+    return undefined;
+}

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

@@ -1,6 +1,6 @@
-import { ProjectionStateError } from "./atomic-publish.js";
-import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
-import { listTellIds, readTellOriginal, readTellSubmitted, } from "./projection-core.js";
+import { ProjectionStateError } from "../../atomic-publish.js";
+import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../../../agents/launch-snapshot/model.js";
+import { listTellIds, readTellOriginal, readTellSubmitted, } from "../projection-core.js";
 export function snapshotPendingTells(projectionDirectory) {
     const pending = ["inbox", "inflight", "submitted"]
         .flatMap((layer) => listTellIds(projectionDirectory, layer)

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

@@ -1,12 +1,13 @@
-import { initializeConfig } from "../config/env.js";
-import { buildCallTerms } from "../agents/call-terms.js";
-import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
-import { revive, call, } from "../agents/harness/index.js";
-import { demoteSubmittedTellsForReplay, readProjectionEvents, } from "./projection-core.js";
-import { createProjectionExecutionObserver, createReplayRunStartGate, markReplayCompleted, snapshotReplayPrompt, } from "./projection-execution-observer.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { selectValidStoredAgentEvents } from "./stored-agent-event.js";
-import { persistResponseHistory } from "./transcripts.js";
+import { initializeConfig } from "../../../config/env.js";
+import { buildCallTerms } from "../../../agents/call-terms.js";
+import { parseResolvedAkumaLaunchSnapshot } from "../../../agents/launch-snapshot/model.js";
+import { revive, call, } from "../../../agents/harness/index.js";
+import { claimFencedTells, demoteSubmittedTellsForReplay, readTellOriginal, readProjectionEvents, } from "../projection-core.js";
+import { createProjectionExecutionObserver, renderProjectionTellFrame, } from "../projection-execution-observer.js";
+import { readProjectionIdentity } from "../projection-identity.js";
+import { selectValidStoredAgentEvents } from "../../stored-agent-event.js";
+import { persistResponseHistory } from "../../transcripts.js";
+import { attachProviderLoaderPorts, } from "../../provider-loader-ports.js";
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -57,6 +58,7 @@ function parseLaunchInputs(launch) {
         ...(context ? { context } : {}),
         launchSnapshot,
         idleTimeoutMs: requirePositiveSafeInteger(raw.idleTimeoutMs, "idleTimeoutMs"),
+        executionTimeoutMs: requirePositiveSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
         persistProjectionResponse: raw.persistProjectionResponse,
         ...(raw.session ? { session: raw.session } : {}),
         ...(resumePath ? { resumePath } : {}),
@@ -134,66 +136,47 @@ async function completionFacts(projectionDirectory, executionId, inputs, outcome
  * Construct the public Projection once and expose a provider-neutral execution
  * handle. Provider adapters and harness public types are unchanged.
  */
-export function executeProjectionGeneration(projectionDirectory, launch) {
+export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
     const inputs = parseLaunchInputs(launch);
     initializeConfig(process.env, inputs.cwd);
     const executionId = launch.executionId;
-    const tellFence = launch.facts.tellFence ?? [];
     demoteSubmittedTellsForReplay(projectionDirectory, executionId);
-    const baseTerms = buildCallTerms(inputs.launchSnapshot, inputs.prompt, inputs.cwd, {
+    const initialTellIds = claimFencedTells(projectionDirectory, launch.facts.tellFence ?? [], executionId);
+    const tellPrompt = initialTellIds.map((tellId) => {
+        const tell = readTellOriginal(projectionDirectory, "inflight", tellId);
+        return renderProjectionTellFrame(tellId, tell.text);
+    }).join("\n\n");
+    const prompt = tellPrompt === ""
+        ? inputs.prompt
+        : inputs.session
+            ? tellPrompt
+            : `${inputs.prompt}\n\n${tellPrompt}`;
+    const terms = attachProviderLoaderPorts(buildCallTerms(inputs.launchSnapshot, prompt, inputs.cwd, {
         idleTimeoutMs: inputs.idleTimeoutMs,
+        executionTimeoutMs: inputs.executionTimeoutMs,
         initialTurn: maximumValidEnvelopeTurn(projectionDirectory),
-    });
-    const launchSnapshot = baseTerms.provider === "codex-sdk"
-        ? snapshotReplayPrompt(projectionDirectory, baseTerms.prompt, tellFence, executionId, {
-            sessionContinuationPromptPrefix: inputs.session && inputs.resumePath
-                ? baseTerms.sessionContinuationPromptPrefix
-                : undefined,
-        })
-        : undefined;
-    const terms = launchSnapshot
-        ? baseTerms.provider === "codex-sdk" && launchSnapshot.effort
-            ? {
-                ...baseTerms,
-                prompt: launchSnapshot.prompt,
-                threadOptions: {
-                    ...baseTerms.threadOptions,
-                    modelReasoningEffort: launchSnapshot.effort,
-                },
-            }
-            : { ...baseTerms, prompt: launchSnapshot.prompt }
-        : baseTerms;
-    // A constructed driver is not an SDK run acknowledgement. Tier-2 has no
-    // live steer surface, so the first provider event is the earliest harness
-    // observable start; a successful no-event completion is the only fallback.
-    const replayStartGate = launchSnapshot
-        ? createReplayRunStartGate(projectionDirectory, executionId, launchSnapshot.tellIds)
-        : undefined;
+    }), providerLoaderPorts);
     const observerController = createProjectionExecutionObserver({
         projectionDirectory,
         executionId,
-        ...(replayStartGate ? { replayStartGate } : {}),
+        initialTellIds,
     });
     let projection;
     try {
-        projection = inputs.session && inputs.resumePath
-            ? revive({ ...terms, session: inputs.session, resumePath: inputs.resumePath }, { observer: observerController.observer })
+        projection = inputs.session
+            ? revive({
+                ...terms,
+                session: inputs.session,
+                resumePath: inputs.resumePath ?? projectionDirectory,
+            }, { observer: observerController.observer })
             : call(terms, { observer: observerController.observer });
     }
     catch (error) {
-        observerController.close();
+        void observerController.close();
         throw error;
     }
     const outcome = projection.outcome.then(async (result) => {
         try {
-            if (result.status === "completed") {
-                // A provider may complete successfully without emitting any observable
-                // events. Its successful completion is still a real run start.
-                replayStartGate?.observeSuccessfulCompletion();
-                if (launchSnapshot) {
-                    markReplayCompleted(projectionDirectory, executionId);
-                }
-            }
             return {
                 verdict: result.status === "completed"
                     ? "completed"
@@ -204,10 +187,10 @@ export function executeProjectionGeneration(projectionDirectory, launch) {
             };
         }
         finally {
-            observerController.close();
+            await observerController.close();
         }
-    }, (error) => {
-        observerController.close();
+    }, async (error) => {
+        await observerController.close();
         throw error;
     });
     return {

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

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import * as path from "node:path";
-import { ProjectionStateError } from "./atomic-publish.js";
-import { createUlid } from "./ids.js";
+import { ProjectionStateError } from "../../atomic-publish.js";
+import { createUlid } from "../../ids.js";
 const EXECUTION_ID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
 export function createProjectionExecutionId(nowMs = Date.now()) {
     return createUlid(nowMs, [...randomBytes(10)]);

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

@@ -1,18 +1,18 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { openProjectionGenerationStore } from "./projection/generation/store.js";
+import { openProjectionGenerationStore } from "./store.js";
 import { spawnProjectionGenerationRunner, } from "./projection-generation-process.js";
 export const PROJECTION_ADOPTION_TIMEOUT_MS = 4_000;
 export const PROJECTION_ADOPTION_POLL_MS = 20;
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function recordLaunchFailure(projectionDirectory, executionId, detail, stage) {
+function recordLaunchFailure(projectionDirectory, executionId, detail, stage, terminalAt) {
     const store = openProjectionGenerationStore(projectionDirectory);
     try {
         return store.verdictIfOpen({
             executionId,
             verdict: "launch-failed",
-            facts: { stage, detail },
+            facts: { stage, detail, ...(terminalAt ? { terminalAt } : {}) },
         }).status === "committed";
     }
     finally {
@@ -29,8 +29,8 @@ export async function startProjectionGeneration(projectionDirectory, executionId
     }
     catch (error) {
         const detail = `runner spawn failed: ${errorDetail(error)}`;
-        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn");
-        return { status: "failed", detail };
+        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
+        return { status: "failed", cause: "spawn", detail };
     }
     const deadline = now() + PROJECTION_ADOPTION_TIMEOUT_MS;
     for (;;) {
@@ -41,6 +41,7 @@ export async function startProjectionGeneration(projectionDirectory, executionId
             if (current?.launch.executionId !== executionId) {
                 return {
                     status: "failed",
+                    cause: "adoption",
                     detail: "launch stopped being current before adoption",
                 };
             }
@@ -49,6 +50,7 @@ export async function startProjectionGeneration(projectionDirectory, executionId
             if (current.verdict) {
                 return {
                     status: "failed",
+                    cause: "adoption",
                     detail: typeof current.verdict.facts.detail === "string"
                         ? current.verdict.facts.detail
                         : `launch ended as ${String(current.verdict.facts.state)}`,
@@ -73,7 +75,7 @@ export async function startProjectionGeneration(projectionDirectory, executionId
         store.close();
     }
     const detail = "runner did not commit adoption before startup timeout";
-    if (!recordLaunchFailure(projectionDirectory, executionId, detail, "adoption")) {
+    if (!recordLaunchFailure(projectionDirectory, executionId, detail, "adoption", new Date(now()).toISOString())) {
         const raced = openProjectionGenerationStore(projectionDirectory);
         try {
             const current = raced.readCurrentGeneration();
@@ -86,5 +88,5 @@ export async function startProjectionGeneration(projectionDirectory, executionId
         }
     }
     child.kill("SIGTERM");
-    return { status: "failed", detail };
+    return { status: "failed", cause: "adoption", detail };
 }

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

@@ -4,7 +4,8 @@ import { spawn as nodeSpawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { executionStdioLogPath } from "./projection-generation-identity.js";
 const MODULE_FILE = fileURLToPath(import.meta.url);
-const PACKAGE_ROOT = path.resolve(path.dirname(MODULE_FILE), "..", "..");
+// Lives at src/core/projection/generation/ — four levels up is the package root.
+const PACKAGE_ROOT = path.resolve(path.dirname(MODULE_FILE), "..", "..", "..", "..");
 const RUNNER_ENTRY = MODULE_FILE.endsWith(".ts")
     ? [process.execPath, "--import", "tsx", path.join(PACKAGE_ROOT, "src", "index.ts")]
     : [process.execPath, path.join(PACKAGE_ROOT, "build", "index.js")];

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

@@ -1,8 +1,9 @@
-import { openProjectionGenerationStore, } from "./projection/generation/store.js";
-import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "./projection-runner-lock.js";
+import { openProjectionGenerationStore, } from "./store.js";
+import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "../projection-runner-lock.js";
 import { createProjectionExecutionId } from "./projection-generation-identity.js";
 import { applyContinuationEffort, } from "./projection-generation-continuation.js";
-import { openProjectionTellObserver } from "./projection/tell/database.js";
+import { openProjectionTellObserver } from "../tell/database.js";
+import { OUTCOME_ERROR_VERSION } from "../../../agents/types.js";
 /** Private runner-side kill grace. Not a setting, env, parameter, or export. */
 const KILL_GRACE_MS = 5000;
 function successorLaunchFacts(launch, completionFacts, effort, now) {
@@ -228,6 +229,13 @@ export async function runProjectionGeneration(input) {
                         diagnostic: "escalation-failed",
                         detail: errorDetail(error),
                         failedAt: new Date(now()).toISOString(),
+                        error: {
+                            version: OUTCOME_ERROR_VERSION,
+                            code: "SUBAGENT_EXEC_ERROR",
+                            message: errorDetail(error),
+                            timeoutMs: null,
+                            exitCode: null,
+                        },
                     },
                 });
                 // Durably completed after the failed verdict; outer catch must not overwrite.
@@ -278,6 +286,7 @@ export async function runProjectionGeneration(input) {
                     facts: {
                         stage: "spawn",
                         detail: `successor runner spawn failed: ${errorDetail(error)}`,
+                        terminalAt: new Date(now()).toISOString(),
                     },
                 });
             }
@@ -315,6 +324,13 @@ export async function runProjectionGeneration(input) {
                 facts: {
                     failedAt: new Date(now()).toISOString(),
                     detail: error instanceof Error ? error.message : String(error),
+                    error: {
+                        version: OUTCOME_ERROR_VERSION,
+                        code: "SUBAGENT_EXEC_ERROR",
+                        message: error instanceof Error ? error.message : String(error),
+                        timeoutMs: null,
+                        exitCode: null,
+                    },
                 },
             });
         }

package/build/core/projection/generation/store.js

@@ -1,8 +1,8 @@
-import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, closeDatabase, isProjectionGenerationSchemaV1Residue, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, } from "./database.js";
+import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, closeDatabase, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, } from "./database.js";
 import { initializeIdentity as initializeProjectionIdentity, readIdentity as readProjectionIdentity, } from "./identity.js";
 import * as transitions from "./transitions.js";
-export { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, isProjectionGenerationSchemaV1Residue, };
-export { GENERATION_VERDICT_STATES, ProjectionGenerationStoreError, } from "./model.js";
+export { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, };
+export { GENERATION_VERDICT_STATES, isIncompatibleProjectionGenerationStoreError, ProjectionGenerationStoreError, } from "./model.js";
 export class ProjectionGenerationStore {
     databasePath;
     readOnly;