@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/outcome-base.js

@@ -1,4 +1,185 @@
 import { ACTOR_IDENTITY } from "../keiyaku.js";
+export function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function isCompleteLifecycleOutcome(outcome) {
+    return outcome.family === "committed" && outcome.completion.status === "complete";
+}
+export function isContainedLifecycleOutcome(outcome) {
+    return outcome.family === "committed" && outcome.completion.status === "contained";
+}
+function effectCause(error) {
+    const source = error;
+    const code = typeof source?.code === "string" ? source.code : "LIFECYCLE_EFFECT_FAILED";
+    const message = typeof source?.message === "string" ? source.message : String(error);
+    const facts = source?.facts && typeof source.facts === "object" && !Array.isArray(source.facts)
+        ? source.facts
+        : undefined;
+    return { code, message, ...(facts ? { facts } : {}) };
+}
+/** Append-only, deduplicating executor used after the first durable effect begins. */
+export class EffectJournal {
+    #prefix;
+    #sequence = [];
+    #byKey = new Map();
+    #ledgerCommitted = false;
+    constructor(prefix) {
+        this.#prefix = prefix;
+    }
+    rows(phase) {
+        return this.#sequence.filter((entry) => entry.phase === phase).map((entry) => entry.row);
+    }
+    all() {
+        return this.#sequence.map((entry) => entry.row);
+    }
+    async run(attempt) {
+        const idempotencyKey = attempt.idempotencyKey ?? `${this.#prefix}:${attempt.effect}`;
+        const previous = this.#byKey.get(idempotencyKey);
+        if (previous)
+            return previous;
+        if (attempt.dependency) {
+            const dependency = this.#byKey.get(attempt.dependency)
+                ?? this.all().find((row) => row.effect === attempt.dependency);
+            if (!dependency || dependency.status !== "succeeded") {
+                return this.#append({
+                    effect: attempt.effect,
+                    idempotencyKey,
+                    dependency: attempt.dependency,
+                    status: "not-attempted",
+                    cause: { code: "DEPENDENCY_FAILED", message: `dependency ${attempt.dependency} did not succeed` },
+                });
+            }
+        }
+        try {
+            const receipt = await attempt.run();
+            return this.#append({
+                effect: attempt.effect,
+                idempotencyKey,
+                ...(attempt.dependency ? { dependency: attempt.dependency } : {}),
+                status: "succeeded",
+                ...(receipt ? { receipt } : {}),
+            });
+        }
+        catch (error) {
+            return this.#append({
+                effect: attempt.effect,
+                idempotencyKey,
+                ...(attempt.dependency ? { dependency: attempt.dependency } : {}),
+                status: "failed",
+                cause: effectCause(error),
+            });
+        }
+    }
+    record(row) {
+        const previous = this.#byKey.get(row.idempotencyKey);
+        return previous ?? this.#append(row);
+    }
+    /** Typed ledger acceptance starts derived replay without fabricating a CAS receipt. */
+    beginDerivedReplay() {
+        this.#ledgerCommitted = true;
+    }
+    #append(row) {
+        const phase = this.#ledgerCommitted ? "downstream" : "prerequisite";
+        this.#sequence.push({ phase, row });
+        this.#byKey.set(row.idempotencyKey, row);
+        if (row.effect === "ledger-cas" && row.status === "succeeded")
+            this.#ledgerCommitted = true;
+        return row;
+    }
+}
+export function carrierLifecycleEffect(carrier) {
+    const idempotencyKey = `carrier:${carrier.ledgerHead}`;
+    if (carrier.status === "failed") {
+        return { effect: "carrier-projection", idempotencyKey, status: "failed", cause: { code: "CARRIER_MATERIALIZATION_FAILED", message: carrier.cause } };
+    }
+    if (carrier.status === "target-unavailable") {
+        return { effect: "carrier-projection", idempotencyKey, status: "failed", cause: { code: "CARRIER_TARGET_UNAVAILABLE", message: carrier.reason } };
+    }
+    return { effect: "carrier-projection", idempotencyKey, status: "succeeded", receipt: { ledgerHead: carrier.ledgerHead, status: carrier.status } };
+}
+export function committedLifecycleFacts(input) {
+    return {
+        family: "committed",
+        completion: { status: "complete" },
+        committed: { head: input.head, entryKind: input.entryKind },
+        carrier: input.carrier,
+        prerequisites: input.prerequisites ?? [],
+        downstream: input.downstream ?? [],
+        replay: {
+            idempotencyKey: `${input.contractId}:${input.head}`,
+            action: (input.downstream ?? []).some((row) => row.status !== "succeeded") ? "reconcile" : "none",
+            reason: (input.downstream ?? []).some((row) => row.status !== "succeeded")
+                ? "one or more committed-head effects remain"
+                : "all minimum effects completed",
+        },
+        cancellationObserved: input.cancellationObserved ?? false,
+    };
+}
+export function containedCommittedLifecycleFacts(input) {
+    const complete = committedLifecycleFacts(input);
+    return { ...complete, completion: { status: "contained", cause: input.cause } };
+}
+export function cancelledLifecycleFacts(contractId, authoritativeHead) {
+    return {
+        family: "cancelled-before-effects",
+        authoritativeHead,
+        cancellation: { code: "CARRIER_GATE_CANCELLED", message: "contract lifecycle operation cancelled before durable effects" },
+        prerequisites: [],
+        downstream: [],
+        replay: { idempotencyKey: `${contractId}:${authoritativeHead ?? "unobserved"}:cancelled`, action: "retry", reason: "zero durable effects were attempted" },
+        cancellationObserved: true,
+    };
+}
+export function refusedLifecycleFacts(input) {
+    return {
+        family: "refused-before-effects",
+        authoritativeHead: input.authoritativeHead,
+        reason: input.message,
+        failedInvariant: { code: input.code, message: input.message, ...(input.facts ? { facts: input.facts } : {}), ...(input.pinned ? { pinned: input.pinned } : {}), ...(input.current ? { current: input.current } : {}) },
+        prerequisites: [],
+        downstream: [],
+        replay: { idempotencyKey: `${input.contractId}:${input.authoritativeHead}:refused`, action: "retry", reason: "zero durable effects were attempted" },
+        cancellationObserved: false,
+    };
+}
+export function precommitLifecycleFacts(input) {
+    const durableReceipt = input.journal.all().some((row) => row.status === "succeeded");
+    return {
+        family: "precommit-effects-only",
+        authoritativeHead: input.authoritativeHead,
+        prerequisites: input.journal.rows("prerequisite"),
+        downstream: input.journal.rows("downstream"),
+        replay: {
+            idempotencyKey: `${input.contractId}:${input.authoritativeHead}:precommit`,
+            action: durableReceipt ? "reconcile" : "retry",
+            reason: durableReceipt
+                ? "durable prerequisite receipts require idempotent reconciliation"
+                : "no successful durable prerequisite receipt was recorded",
+        },
+        cancellationObserved: input.cancellationObserved ?? false,
+    };
+}
+export function derivedCleanupFacts(input) {
+    const cleanup = {
+        effect: input.effect,
+        idempotencyKey: `${input.contractId}:${input.authoritativeHead}:${input.effect}`,
+        status: "succeeded",
+        receipt: input.receipt,
+    };
+    return {
+        family: "precommit-effects-only",
+        authoritativeHead: input.authoritativeHead,
+        cleanup,
+        prerequisites: [cleanup],
+        downstream: [],
+        replay: {
+            idempotencyKey: `${input.contractId}:${input.authoritativeHead}:${input.effect}`,
+            action: "none",
+            reason: "derived cleanup completed without changing lifecycle authority",
+        },
+        cancellationObserved: false,
+    };
+}
 export function defaultActorClock(nowMs = Date.now()) {
     return { actor: ACTOR_IDENTITY, nowMs };
 }

package/build/core/process-group.js

@@ -0,0 +1,139 @@
+import { execFile } from "node:child_process";
+export const PROCESS_GROUP_KILL_GRACE_MS = 10_000;
+const PROCESS_DISAPPEARANCE_POLL_MS = 25;
+export class ProcessTreeTerminationError extends Error {
+    code = "TREE_TERMINATION_FAILED";
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProcessTreeTerminationError";
+    }
+}
+function defaultWait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isMissingProcessError(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ESRCH");
+}
+export function ownedProcessIdentity(child, platform = process.platform) {
+    if (!child.pid)
+        return undefined;
+    return { pid: child.pid, platform: platform === "win32" ? "win32" : "posix" };
+}
+export function ownedProcessIsLive(identity) {
+    try {
+        process.kill(identity.platform === "posix" ? -identity.pid : identity.pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !isMissingProcessError(error);
+    }
+}
+function signalOwnedProcess(identity, signal) {
+    try {
+        process.kill(identity.platform === "posix" ? -identity.pid : identity.pid, signal);
+    }
+    catch (error) {
+        if (!isMissingProcessError(error))
+            throw error;
+    }
+}
+async function waitForDisappearance(identity, timeoutMs, wait) {
+    const deadline = Date.now() + timeoutMs;
+    while (ownedProcessIsLive(identity)) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return false;
+        await wait(Math.min(PROCESS_DISAPPEARANCE_POLL_MS, remaining));
+    }
+    return true;
+}
+function waitForChildClose(child) {
+    return new Promise((resolve) => {
+        child.once("close", resolve);
+        child.once("error", resolve);
+    });
+}
+function defaultTaskkill(pid) {
+    return new Promise((resolve, reject) => {
+        execFile("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+async function terminateIdentity(identity, options) {
+    if (!ownedProcessIsLive(identity))
+        return;
+    if (identity.platform === "win32") {
+        try {
+            await options.taskkill(identity.pid);
+        }
+        catch (error) {
+            if (!ownedProcessIsLive(identity))
+                return;
+            throw error;
+        }
+        if (!await waitForDisappearance(identity, options.graceMs, options.wait)) {
+            throw new Error(`owned process tree ${identity.pid} remained after taskkill`);
+        }
+        return;
+    }
+    signalOwnedProcess(identity, "SIGTERM");
+    if (await waitForDisappearance(identity, options.graceMs, options.wait))
+        return;
+    signalOwnedProcess(identity, "SIGKILL");
+    if (!await waitForDisappearance(identity, options.graceMs, options.wait)) {
+        throw new Error(`owned process group ${identity.pid} remained after SIGKILL`);
+    }
+}
+/** Terminate an orphaned runner identity retained by repository coordination. */
+export async function terminateOwnedProcess(identity, options = {}) {
+    try {
+        await terminateIdentity(identity, {
+            graceMs: options.graceMs ?? PROCESS_GROUP_KILL_GRACE_MS,
+            wait: options.wait ?? defaultWait,
+            taskkill: options.taskkill ?? defaultTaskkill,
+        });
+    }
+    catch (error) {
+        throw new ProcessTreeTerminationError(error instanceof Error ? error.message : String(error), { cause: error });
+    }
+}
+/** Terminate a detached child tree, then await group disappearance and pipe-draining close. */
+export async function terminateProcessGroup(child, options = {}) {
+    const graceMs = options.graceMs ?? PROCESS_GROUP_KILL_GRACE_MS;
+    const wait = options.wait ?? defaultWait;
+    const platform = options.platform ?? process.platform;
+    const identity = ownedProcessIdentity(child, platform);
+    const closed = waitForChildClose(child);
+    try {
+        if (platform === "win32" && identity) {
+            await Promise.all([
+                (options.taskkill ?? defaultTaskkill)(identity.pid),
+                closed,
+            ]);
+            return;
+        }
+        if (identity) {
+            await Promise.all([
+                terminateIdentity(identity, {
+                    graceMs,
+                    wait,
+                    taskkill: options.taskkill ?? defaultTaskkill,
+                }),
+                closed,
+            ]);
+            return;
+        }
+        child.kill("SIGTERM");
+        await wait(graceMs);
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill("SIGKILL");
+        await closed;
+    }
+    catch (error) {
+        throw new ProcessTreeTerminationError(error instanceof Error ? error.message : String(error), { cause: error });
+    }
+}

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

@@ -4,7 +4,7 @@ import { DatabaseSync } from "node:sqlite";
 import { configureHeartBusyTimeout } from "../heart.js";
 import { ProjectionGenerationStoreError, parseStoredRow, validateHistory, } from "./model.js";
 export const PROJECTION_GENERATION_STORE_FILE = "heart";
-export const PROJECTION_GENERATION_SCHEMA_VERSION = 3;
+export const PROJECTION_GENERATION_SCHEMA_VERSION = 4;
 const SCHEMA_TABLE_SQL = `
   CREATE TABLE generation_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
@@ -42,7 +42,7 @@ const TELL_TABLE_SQL = `
     created_at TEXT NOT NULL CHECK (length(trim(created_at)) > 0),
     effort TEXT CHECK (effort IS NULL OR length(trim(effort)) > 0),
     state TEXT NOT NULL CHECK (
-      state IN ('inbox', 'inflight', 'submitted', 'consumed', 'delivered')
+      state IN ('inbox', 'inflight', 'submitted', 'seen', 'consumed')
     ),
     execution_id TEXT CHECK (
       execution_id IS NULL OR length(trim(execution_id)) > 0
@@ -50,12 +50,47 @@ const TELL_TABLE_SQL = `
     fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
     replayed_from_json TEXT CHECK (
       replayed_from_json IS NULL OR json_valid(replayed_from_json)
-    ),
-    delivered_at TEXT CHECK (
-      delivered_at IS NULL OR length(trim(delivered_at)) > 0
     )
   ) STRICT
 `;
+const TELL_RECEIPT_TABLE_SQL = `
+  CREATE TABLE projection_tell_receipts (
+    tell_id TEXT NOT NULL REFERENCES projection_tells(tell_id),
+    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+    stage TEXT NOT NULL CHECK (stage IN ('seen', 'consumed')),
+    correlation_kind TEXT NOT NULL CHECK (correlation_kind IN ('exact', 'fence', 'inherited')),
+    fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
+    received_at TEXT NOT NULL CHECK (length(trim(received_at)) > 0),
+    PRIMARY KEY (tell_id, execution_id, stage)
+  ) STRICT
+`;
+const TELL_RECEIPT_CAPABILITY_TABLE_SQL = `
+  CREATE TABLE projection_tell_receipt_capabilities (
+    execution_id TEXT PRIMARY KEY CHECK (length(trim(execution_id)) > 0),
+    seen TEXT NOT NULL CHECK (seen IN ('exact', 'fence', 'unavailable')),
+    consumed TEXT NOT NULL CHECK (consumed IN ('exact', 'fence', 'unavailable'))
+  ) STRICT
+`;
+const TELL_LAUNCH_BATCH_TABLE_SQL = `
+  CREATE TABLE projection_tell_launch_batches (
+    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+    tell_id TEXT NOT NULL REFERENCES projection_tells(tell_id),
+    PRIMARY KEY (execution_id, tell_id)
+  ) STRICT
+`;
+/** One row records that an execution's launch-input membership is fixed, even when empty. */
+const TELL_LAUNCH_ADMISSION_TABLE_SQL = `
+  CREATE TABLE projection_tell_launch_admissions (
+    execution_id TEXT PRIMARY KEY CHECK (length(trim(execution_id)) > 0)
+  ) STRICT
+`;
+const TELL_LAUNCH_COORDINATE_TABLE_SQL = `
+  CREATE TABLE projection_tell_launch_coordinates (
+    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+    fence_json TEXT NOT NULL CHECK (json_valid(fence_json)),
+    PRIMARY KEY (execution_id, fence_json)
+  ) STRICT
+`;
 const closedDatabases = new WeakSet();
 /** Classify only proved missing schema evidence as historical incompatibility. */
 export function projectionGenerationStoreInspectionError(databasePath, error) {
@@ -114,7 +149,7 @@ function validateSchemaShape(database) {
     ORDER BY name
   `).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") {
+    if (signature !== "table:generation_records,table:generation_schema,table:projection_identity,table:projection_tell_launch_admissions,table:projection_tell_launch_batches,table:projection_tell_launch_coordinates,table:projection_tell_receipt_capabilities,table:projection_tell_receipts,table:projection_tells") {
         throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`, { observation: "incompatible" });
     }
     const metadata = database.prepare("SELECT singleton, version FROM generation_schema").all();
@@ -139,9 +174,44 @@ function validateSchemaShape(database) {
     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") {
+    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") {
         throw new ProjectionGenerationStoreError("projection tell schema is malformed", { observation: "incompatible" });
     }
+    const receiptColumns = database.prepare("PRAGMA table_info(projection_tell_receipts)").all();
+    const receiptSignature = receiptColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (receiptSignature !== "tell_id:TEXT:1:1,execution_id:TEXT:1:2,stage:TEXT:1:3,correlation_kind:TEXT:1:0,fence_json:TEXT:0:0,received_at:TEXT:1:0") {
+        throw new ProjectionGenerationStoreError("projection tell receipt schema is malformed", { observation: "incompatible" });
+    }
+    const capabilityColumns = database.prepare("PRAGMA table_info(projection_tell_receipt_capabilities)").all();
+    const capabilitySignature = capabilityColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (capabilitySignature !== "execution_id:TEXT:1:1,seen:TEXT:1:0,consumed:TEXT:1:0") {
+        throw new ProjectionGenerationStoreError("projection tell receipt capability schema is malformed", { observation: "incompatible" });
+    }
+    const launchBatchColumns = database.prepare("PRAGMA table_info(projection_tell_launch_batches)").all();
+    const launchBatchSignature = launchBatchColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (launchBatchSignature !== "execution_id:TEXT:1:1,tell_id:TEXT:1:2") {
+        throw new ProjectionGenerationStoreError("projection tell launch batch schema is malformed", { observation: "incompatible" });
+    }
+    const launchAdmissionColumns = database.prepare("PRAGMA table_info(projection_tell_launch_admissions)").all();
+    const launchAdmissionSignature = launchAdmissionColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (launchAdmissionSignature !== "execution_id:TEXT:1:1") {
+        throw new ProjectionGenerationStoreError("projection tell launch admission schema is malformed", { observation: "incompatible" });
+    }
+    const launchCoordinateColumns = database.prepare("PRAGMA table_info(projection_tell_launch_coordinates)").all();
+    const launchCoordinateSignature = launchCoordinateColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (launchCoordinateSignature !== "execution_id:TEXT:1:1,fence_json:TEXT:1:2") {
+        throw new ProjectionGenerationStoreError("projection tell launch coordinate 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", { observation: "incompatible" });
@@ -162,6 +232,11 @@ function initializeOrValidateSchema(database) {
             database.exec(RECORD_TABLE_SQL);
             database.exec(IDENTITY_TABLE_SQL);
             database.exec(TELL_TABLE_SQL);
+            database.exec(TELL_RECEIPT_TABLE_SQL);
+            database.exec(TELL_RECEIPT_CAPABILITY_TABLE_SQL);
+            database.exec(TELL_LAUNCH_BATCH_TABLE_SQL);
+            database.exec(TELL_LAUNCH_ADMISSION_TABLE_SQL);
+            database.exec(TELL_LAUNCH_COORDINATE_TABLE_SQL);
             database.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
                 .run(PROJECTION_GENERATION_SCHEMA_VERSION);
             database.exec(`PRAGMA user_version = ${PROJECTION_GENERATION_SCHEMA_VERSION}`);

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

@@ -1,16 +1,7 @@
 import { GENERATION_VERDICT_STATES, } from "../projection-life-protocol.js";
-import { OUTCOME_ERROR_VERSION, SUBAGENT_FAILURE_CODES } from "../../../agents/types.js";
+import { OutcomeErrorValidationError, parseCurrentOutcomeError, } from "../../../agents/harness/index.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. */
@@ -152,34 +143,16 @@ export function validateVerdictFacts(value, location) {
         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" });
+        try {
+            facts.error = parseCurrentOutcomeError(facts.error, `${location}.error`);
         }
-        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`);
+        catch (error) {
+            if (error instanceof OutcomeErrorValidationError) {
+                throw new ProjectionGenerationStoreError(error.message, {
+                    observation: error.incompatible ? "incompatible" : "unknown",
+                });
             }
+            throw error;
         }
     }
     return facts;

package/build/core/projection/generation/projection-generation-continuation.js

@@ -3,14 +3,6 @@ import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../../..
 import { listTellMetadataFromDatabase, readPendingTellWindowFromDatabase, } from "../tell/store.js";
 import { PENDING_PROJECTION_TELL_STATES } from "../tell/model.js";
 import { readValidatedHistory, withGenerationReadSnapshot } from "./database.js";
-function retainedFenceFor(current) {
-    return current?.verdict?.facts.state === "launch-failed"
-        ? current.launch.facts.tellFence ?? []
-        : [];
-}
-function interruptedForReplay(current) {
-    return current?.verdict?.facts.state === "interrupted";
-}
 function snapshotTells(database, layers, admit) {
     const pending = listTellMetadataFromDatabase(database, layers)
         .filter((item) => admit?.({
@@ -26,18 +18,19 @@ function snapshotTells(database, layers, admit) {
         ...(effort ? { effort } : {}),
     };
 }
-/** Ordinary completed-generation handoff retains only tells not yet delivered. */
+/** All non-consumed tells remain eligible for an ordinary successor. */
 export function snapshotPendingTells(projectionDirectory) {
     return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
 }
-/** Interrupted generations replay pending mail and their own delivered tells. */
+/** Interrupt successors replay every non-consumed tell. */
 export function snapshotInterruptTells(projectionDirectory, executionId) {
-    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], (item) => item.layer !== "delivered" || item.executionId === executionId));
+    void executionId;
+    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
 }
-/** Retry ordinary pending mail plus exactly the durable fence of a failed launch. */
+/** Failed launch recovery retains every non-consumed tell. */
 export function snapshotRetainedSuccessorTells(projectionDirectory, retainedFence) {
-    const retained = new Set(retainedFence);
-    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], ({ layer, tellId }) => layer !== "delivered" || retained.has(tellId)));
+    void retainedFence;
+    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
 }
 /** Build the durable successor fence only after continuation is admitted. */
 export function snapshotProjectionContinuationTells(projectionDirectory, current) {
@@ -47,14 +40,9 @@ export function snapshotProjectionContinuationTells(projectionDirectory, current
     }
     return snapshot.successor;
 }
-function readContinuationFromDatabase(database, current, limit = 10) {
+function readContinuationFromDatabase(database, limit = 10) {
     const tells = readPendingTellWindowFromDatabase(database, limit);
-    const retainedFence = retainedFenceFor(current);
-    const successor = interruptedForReplay(current)
-        ? snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], (item) => item.layer !== "delivered" || item.executionId === current.launch.executionId)
-        : retainedFence.length > 0
-            ? snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], ({ layer, tellId }) => layer !== "delivered" || retainedFence.includes(tellId))
-            : snapshotTells(database, PENDING_PROJECTION_TELL_STATES);
+    const successor = snapshotTells(database, PENDING_PROJECTION_TELL_STATES);
     return {
         tells,
         successor,
@@ -65,7 +53,7 @@ function readContinuationFromDatabase(database, current, limit = 10) {
 export function readProjectionGenerationContinuationSnapshot(projectionDirectory, limit = 10) {
     return withGenerationReadSnapshot(projectionDirectory, (database) => {
         const { records, current } = readValidatedHistory(database);
-        const continuation = readContinuationFromDatabase(database, current, limit);
+        const continuation = readContinuationFromDatabase(database, limit);
         return {
             records,
             current,

package/build/core/projection/generation/projection-generation-execution.js

@@ -2,7 +2,7 @@ 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, readTellOriginal, readProjectionEvents, } from "../projection-core.js";
+import { claimAndReserveFencedTells, 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";
@@ -26,6 +26,12 @@ function requirePositiveSafeInteger(value, field) {
     }
     return value;
 }
+function requireNonNegativeSafeInteger(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`generation launch ${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
 function parseLaunchInputs(launch) {
     const raw = launch.facts.inputs;
     if (!isObject(raw))
@@ -58,7 +64,7 @@ function parseLaunchInputs(launch) {
         ...(context ? { context } : {}),
         launchSnapshot,
         idleTimeoutMs: requirePositiveSafeInteger(raw.idleTimeoutMs, "idleTimeoutMs"),
-        executionTimeoutMs: requirePositiveSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
+        executionTimeoutMs: requireNonNegativeSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
         persistProjectionResponse: raw.persistProjectionResponse,
         ...(raw.session ? { session: raw.session } : {}),
         ...(resumePath ? { resumePath } : {}),
@@ -104,6 +110,7 @@ async function completionFacts(projectionDirectory, executionId, inputs, outcome
                 },
                 task: inputs.task,
                 response: outcome.finalMessage,
+                ...(outcome.error ? { terminalFailure: outcome.error } : {}),
                 session: outcome.session,
                 launchSnapshot: inputs.launchSnapshot,
                 effectivePolicy: inputs.launchSnapshot.akuma.policy,
@@ -140,7 +147,7 @@ export function prepareProjectionGenerationExecution(projectionDirectory, launch
     const inputs = parseLaunchInputs(launch);
     initializeConfig(process.env, inputs.cwd);
     const executionId = launch.executionId;
-    const initialTellIds = claimFencedTells(projectionDirectory, launch.facts.tellFence ?? [], executionId);
+    const initialTellIds = claimAndReserveFencedTells(projectionDirectory, launch.facts.tellFence ?? [], executionId);
     const tellPrompt = initialTellIds.map((tellId) => {
         const tell = readTellOriginal(projectionDirectory, "inflight", tellId);
         return renderProjectionTellFrame(tellId, tell.text);
@@ -158,7 +165,7 @@ export function prepareProjectionGenerationExecution(projectionDirectory, launch
     const observerController = createProjectionExecutionObserver({
         projectionDirectory,
         executionId,
-        initialTellIds,
+        reservedLaunchTellIds: initialTellIds,
     });
     return {
         start() {
@@ -169,8 +176,8 @@ export function prepareProjectionGenerationExecution(projectionDirectory, launch
                         ...terms,
                         session: inputs.session,
                         resumePath: inputs.resumePath ?? projectionDirectory,
-                    }, { observer: observerController.observer })
-                    : call(terms, { observer: observerController.observer });
+                    }, { observer: observerController.observer, launchTellIds: initialTellIds })
+                    : call(terms, { observer: observerController.observer, launchTellIds: initialTellIds });
             }
             catch (error) {
                 void observerController.close();