@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/core/audit/readiness.js

@@ -0,0 +1,4 @@
+/** Readiness is assembled from the coordinate owner's one frozen read. */
+export function readinessFromFacts(facts) {
+    return facts;
+}

package/build/core/audit/report.js

@@ -0,0 +1,38 @@
+export function collectFindings(input) {
+    const findings = [];
+    const selector = `keiyaku @${input.contractId}`;
+    if (input.rehearsal.status === "clean")
+        findings.push({ code: "BASE_DRIFT", detail: `${input.rehearsal.oldBase} -> ${input.rehearsal.newBase}`, nextCommand: `${selector} renew` });
+    if (input.rehearsal.status === "conflict")
+        findings.push({ code: "RENEW_CONFLICT", detail: input.rehearsal.paths.join(", "), nextCommand: `${selector} renew` });
+    if (input.rehearsal.status === "unknown")
+        findings.push({ code: "RENEW_UNKNOWN", detail: `${input.rehearsal.cause.code}: ${input.rehearsal.cause.message}`, nextCommand: `${selector} audit` });
+    for (const row of input.scope?.filter((item) => item.class === "violated") ?? [])
+        findings.push({ code: "SCOPE_RESIDUE", detail: `${row.path}: ${row.residue.length} unexplained changes`, nextCommand: `${selector} amend --scope-add ${JSON.stringify(row.path)}` });
+    if (input.verification.status === "evaluated") {
+        for (const result of input.verification.results) {
+            if (result.status === "executed" && result.exitCode !== 0)
+                findings.push({ code: "VERIFICATION_FAILED", detail: `${result.label} exited ${result.exitCode}`, nextCommand: result.command });
+            if (result.status === "unverifiable")
+                findings.push({ code: "VERIFICATION_UNVERIFIABLE", detail: `${result.label}: ${result.cause}`, nextCommand: result.command });
+        }
+    }
+    const residue = input.readiness.deliveryResidue;
+    if (residue.tracked.length + residue.staged.length + residue.unstaged.length + residue.untracked.length > 0)
+        findings.push({ code: "DELIVERY_RESIDUE", detail: `registered delivery worktree has uncommitted residue at ${input.deliveryCwd}`, nextCommand: `git -C ${JSON.stringify(input.deliveryCwd)} status --short` });
+    if (input.readiness.arc.max > 0 && input.readiness.arc.open === null && input.readiness.arc.looseCommits.length > 0)
+        findings.push({ code: "LOOSE_COMMITS", detail: `${input.readiness.arc.looseCommits.length} loose commits after fence`, nextCommand: `printf '# Continue\\n\\n## Objective\\nReceipt loose commits.\\n\\n## Brief\\nContinue delivery.\\n' | ${selector} arc` });
+    if (input.readiness.renewSession.open)
+        findings.push({ code: "RENEW_SESSION_OPEN", detail: "renew recovery session is open", nextCommand: `${selector} renew --continue` });
+    if (input.readiness.rewriteGuard.liveProjection)
+        findings.push({ code: "LIVE_REWRITE_GUARD", detail: "a live projection owns the delivery worktree", nextCommand: "keiyaku status" });
+    for (const dependency of input.readiness.dependencies.filter((item) => !item.satisfied))
+        findings.push({ code: "DEPENDENCY_OPEN", detail: `dependency ${dependency.id} is ${dependency.state}`, nextCommand: `keiyaku @${dependency.id} log` });
+    if (input.readiness.petition.state === "petitioned" && input.readiness.petition.queue?.position !== 1)
+        findings.push({ code: "PETITION_QUEUE", detail: `petition queue position ${input.readiness.petition.queue?.position ?? "unknown"}`, nextCommand: "keiyaku status" });
+    return findings;
+}
+export function emptyRaceReport(input) {
+    const findings = [{ code: "COORDINATE_RACE", detail: input.detail, nextCommand: `keiyaku @${input.contractId} audit`, race: input.race }];
+    return { contract: input.contractId, coordinates: input.coordinates, terms: input.terms, rehearsal: { status: "unknown", cause: { code: "COORDINATE_RACE", message: input.detail } }, candidate: null, diff: null, presentation: null, files: null, scope: null, verification: { status: "not_evaluated", reason: "coordinate_race", results: [] }, readiness: null, findings, counts: { files: 0, selected: 0, omitted: 0, inScope: 0, downgraded: 0, violated: 0, findings: 1 } };
+}

package/build/core/audit.js

@@ -0,0 +1 @@
+export { auditContract } from "./audit/facade.js";

package/build/core/bind.js

@@ -119,7 +119,7 @@ function incompleteTaskBindError(taskId, missing) {
     const template = renderMissingBindSectionsTemplate(missing);
     const message = [
         `task ${coordinate} carries no ${describeMissingBindSections(missing)}`,
-        `» keiyaku bind --task ${coordinate} <<'KEIYAKU'`,
+        `» keiyaku bind --task ${coordinate} - <<'KEIYAKU'`,
         template,
         "KEIYAKU",
     ].join("\n");

package/build/core/call/execution.js

@@ -159,6 +159,7 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
                 task: options.task ?? prompt,
                 launchSnapshot,
                 idleTimeoutMs: resolvedTerms.idleTimeoutMs,
+                executionTimeoutMs: resolvedTerms.executionTimeoutMs,
                 cwd,
                 historyCwd: options.historyStorageCwd ?? cwd,
                 ...(options.evidenceCwd !== undefined ? { evidenceCwd: options.evidenceCwd } : {}),

package/build/core/contract-view.js

@@ -5,6 +5,7 @@ import { shortCommitHash } from "../git/commits.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
 import { readLedger } from "./ledger.js";
 import { deriveContractState } from "./status/lifecycle.js";
+import { renderScopeFragment } from "./scope.js";
 const VERB_COLUMN_WIDTH = 11;
 const TIME_COLUMN_WIDTH = 6;
 const ACTOR_COLUMN_WIDTH = 11;
@@ -41,8 +42,6 @@ function sealAggregate(entries) {
 function scopeStatusFact(entry) {
     if (entry.data.scopeAudit.violations.length === 0)
         return "scope ✓ clean";
-    if (entry.data.scopeAudit.waived)
-        return `scope ▲ waived ${entry.data.scopeAudit.violations.length}`;
     return `scope ✕ ${entry.data.scopeAudit.violations.length}`;
 }
 function formatDiffstat(insertions, deletions) {
@@ -258,7 +257,7 @@ export function renderContractView(input) {
         bind.data.objective,
         "",
         "## Scope",
-        ...bind.data.scope.map((pattern) => `- ${pattern}`),
+        ...renderScopeFragment(bind.data.scope).split("\n"),
         "",
         "## Checks",
         ...bind.data.checks.map((check) => `- ${check}`),

package/build/core/draft.js

@@ -1,7 +1,8 @@
 import { FlowError } from "../flow-error.js";
 import { parseToAST } from "./markdown/parser.js";
 import { extractListItems, renderSectionContent } from "./markdown/render.js";
-import { normalizeScopePattern } from "./scope.js";
+import { normalizeSectionTitle } from "./markdown/titles.js";
+import { markdownSourceSections, renderScopeFragment, validateScopeFragmentLines } from "./scope.js";
 const KNOWN_SECTIONS = new Set(["objective", "scope", "checks"]);
 const BIND_DRAFT_SECTION_ORDER = ["name", "objective", "scope", "checks"];
 function invalidBindDraft(message) {
@@ -74,7 +75,16 @@ function extractSingleLineChecks(section) {
     });
 }
 function collectBindDraftNodes(content) {
-    const ast = parseToAST(content);
+    // Scope is parsed from source lines below. Hide its body from the Markdown AST
+    // so fence-like and heading-like payload bytes cannot acquire structure there.
+    let structuralContent = content;
+    const scopeSources = markdownSourceSections(content)
+        .filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope")
+        .sort((left, right) => right.contentStart - left.contentStart);
+    for (const source of scopeSources) {
+        structuralContent = `${structuralContent.slice(0, source.contentStart)}\`\`\`\nscope\n\`\`\`\n${structuralContent.slice(source.end)}`;
+    }
+    const ast = parseToAST(structuralContent);
     let name;
     let seenH1 = false;
     const sections = new Map();
@@ -107,21 +117,22 @@ function collectBindDraftNodes(content) {
     }
     return { ...(name === undefined ? {} : { name }), sections, extensions };
 }
-function parseScopeSection(scope) {
-    const unexpectedScopeLine = findUnexpectedListOnlyLine(scope);
-    if (unexpectedScopeLine) {
-        invalidBindDraft(`Scope must be a bullet list; found '${unexpectedScopeLine}'`);
+function parseScopeSection(content) {
+    const sourceSections = markdownSourceSections(content).filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope");
+    if (sourceSections.length !== 1)
+        invalidBindDraft("bind draft must contain exactly one Scope section");
+    const source = sourceSections[0];
+    try {
+        return validateScopeFragmentLines(content.slice(source.contentStart, source.end).split(/\r?\n/), {
+            heading: "## Scope",
+            emptyMessage: "Scope must be a gitignore-subset fragment; found empty Scope section",
+        });
     }
-    const scopeItems = extractListItems(scope);
-    if (scopeItems.length === 0) {
-        invalidBindDraft("Scope must be a bullet list; found empty Scope section");
+    catch (error) {
+        if (error instanceof FlowError)
+            throw new FlowError(error.code, `INVALID_BIND_DRAFT: ${error.message}`);
+        throw error;
     }
-    return scopeItems.map((item) => {
-        if (item.trim().length === 0) {
-            invalidBindDraft("empty scope pattern in bind draft");
-        }
-        return normalizeScopePattern(item);
-    });
 }
 /**
  * Parse any subset of the bind document grammar. Absent sections stay undefined
@@ -142,8 +153,9 @@ export function parsePartialBindDraft(content) {
         partial.objective = objectiveText;
     }
     const scope = sections.get("scope");
-    if (scope)
-        partial.scope = parseScopeSection(scope);
+    if (scope) {
+        partial.scope = parseScopeSection(content);
+    }
     const checks = sections.get("checks");
     if (checks)
         partial.checks = extractSingleLineChecks(checks);
@@ -192,7 +204,7 @@ export function renderMissingBindSectionsTemplate(missing) {
             continue;
         }
         if (section === "scope") {
-            lines.push("## Scope", "- <pattern>");
+            lines.push("## Scope", "```", "<pattern>", "<another-pattern>", "```");
             continue;
         }
         lines.push("## Checks", "- <verification>");
@@ -233,6 +245,7 @@ export function parseBindDraft(content) {
         invalidBindDraft("missing Objective section in bind draft");
     if (!scope)
         invalidBindDraft("missing Scope section in bind draft");
+    const parsedScope = parseScopeSection(content);
     if (!checks)
         invalidBindDraft("missing Checks section in bind draft");
     const objectiveText = renderSectionContent(objective).trim();
@@ -241,7 +254,7 @@ export function parseBindDraft(content) {
     return {
         name,
         objective: objectiveText,
-        scope: parseScopeSection(scope),
+        scope: parsedScope,
         checks: extractSingleLineChecks(checks),
         extensions,
     };
@@ -250,7 +263,7 @@ export function renderBindDraft(draft) {
     const sections = [
         `# ${draft.name}`,
         `## Objective\n${draft.objective}`,
-        `## Scope\n${draft.scope.map((pattern) => `- ${pattern}`).join("\n")}`,
+        `## Scope\n${renderScopeFragment(draft.scope)}`,
         `## Checks\n${draft.checks.map((check) => `- ${check}`).join("\n")}`,
     ];
     for (const extension of draft.extensions) {

package/build/core/entry.js

@@ -35,7 +35,6 @@ const diffstatSchema = z
 const scopeAuditSchema = z
     .object({
     violations: z.array(nonEmptyString),
-    waived: z.boolean(),
 })
     .strict();
 export const fullBranchRefSchema = z
@@ -200,10 +199,10 @@ export const forfeitEntryDataSchema = z
     note: nonEmptyString.optional(),
 })
     .strict();
-function makeEntrySchema(kind, data) {
+function makeEntrySchema(kind, data, version = 1) {
     return z
         .object({
-        v: z.literal(1),
+        v: z.literal(version),
         kind: z.literal(kind),
         contract: z.string().trim().regex(CONTRACT_ID_RE, "contract id cannot contain whitespace"),
         at: isoUtcSchema,
@@ -214,7 +213,7 @@ function makeEntrySchema(kind, data) {
 }
 export const bindEntrySchema = makeEntrySchema("bind", bindEntryDataSchema);
 export const arcEntrySchema = makeEntrySchema("arc", arcEntryDataSchema);
-export const sealEntrySchema = makeEntrySchema("seal", sealEntryDataSchema);
+export const sealEntrySchema = makeEntrySchema("seal", sealEntryDataSchema, 2);
 export const amendEntrySchema = makeEntrySchema("amend", amendEntryDataSchema);
 export const renewEntrySchema = makeEntrySchema("renew", renewEntryDataSchema);
 export const petitionEntrySchema = makeEntrySchema("petition", petitionEntryDataSchema);

package/build/core/markdown/lex.js

@@ -173,7 +173,8 @@ export function stripTrailingBlankLines(lines) {
     return trimmed;
 }
 export function isSectionHeaderToken(token) {
-    return token.type === "header" && (token.level === 1 || token.level === 2);
+    // Column-0 only: indented ATX-looking lines remain content, not structure.
+    return token.type === "header" && token.leadingSpaces === 0 && (token.level === 1 || token.level === 2);
 }
 export function isFenceClosingToken(token, fence) {
     return token.type === "fence" && token.delimiter === fence.delimiter && token.length >= fence.length;

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(`incompatible projection generation schema version ${version}; 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(`incompatible projection generation schema version ${version}; 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) {

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

@@ -13,11 +13,18 @@ const OUTCOME_ERROR_KEYS = new Set([
 ]);
 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;
@@ -131,11 +138,14 @@ 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}`);
+            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`);
@@ -181,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"
@@ -240,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/projection-generation-execution.js

@@ -2,8 +2,8 @@ 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, } from "../projection-execution-observer.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";
@@ -58,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 } : {}),
@@ -140,13 +141,25 @@ export function executeProjectionGeneration(projectionDirectory, launch, provide
     initializeConfig(process.env, inputs.cwd);
     const executionId = launch.executionId;
     demoteSubmittedTellsForReplay(projectionDirectory, executionId);
-    const terms = attachProviderLoaderPorts(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),
     }), providerLoaderPorts);
     const observerController = createProjectionExecutionObserver({
         projectionDirectory,
         executionId,
+        initialTellIds,
     });
     let projection;
     try {
@@ -159,7 +172,7 @@ export function executeProjectionGeneration(projectionDirectory, launch, provide
             : call(terms, { observer: observerController.observer });
     }
     catch (error) {
-        observerController.close();
+        void observerController.close();
         throw error;
     }
     const outcome = projection.outcome.then(async (result) => {
@@ -174,10 +187,10 @@ export function executeProjectionGeneration(projectionDirectory, launch, provide
             };
         }
         finally {
-            observerController.close();
+            await observerController.close();
         }
-    }, (error) => {
-        observerController.close();
+    }, async (error) => {
+        await observerController.close();
         throw error;
     });
     return {

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

@@ -6,13 +6,13 @@ 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,7 +29,7 @@ export async function startProjectionGeneration(projectionDirectory, executionId
     }
     catch (error) {
         const detail = `runner spawn failed: ${errorDetail(error)}`;
-        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn");
+        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
         return { status: "failed", cause: "spawn", detail };
     }
     const deadline = now() + PROJECTION_ADOPTION_TIMEOUT_MS;
@@ -75,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();

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

@@ -286,6 +286,7 @@ export async function runProjectionGeneration(input) {
                     facts: {
                         stage: "spawn",
                         detail: `successor runner spawn failed: ${errorDetail(error)}`,
+                        terminalAt: new Date(now()).toISOString(),
                     },
                 });
             }

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

@@ -2,7 +2,7 @@ import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE,
 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, };
-export { GENERATION_VERDICT_STATES, ProjectionGenerationStoreError, } from "./model.js";
+export { GENERATION_VERDICT_STATES, isIncompatibleProjectionGenerationStoreError, ProjectionGenerationStoreError, } from "./model.js";
 export class ProjectionGenerationStore {
     databasePath;
     readOnly;

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

@@ -149,7 +149,7 @@ export function verdictIfOpen(database, readOnly, input) {
         if (input.verdict === "launch-failed" && current.adoption) {
             return rejected("already-adopted", current);
         }
-        const facts = validateVerdictFacts({ ...(input.facts ?? {}), state: input.verdict }, "verdict facts");
+        const facts = validateVerdictFacts({ ...(input.facts ?? {}), state: input.verdict, ...(input.terminalAt ? { terminalAt: assertIsoTimestamp(input.terminalAt, "terminalAt") } : {}) }, "verdict facts");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
 }
@@ -160,6 +160,9 @@ export function supersedeStartupTimeout(database, readOnly, input) {
     const startupTimeoutMs = assertPositiveSafeInteger(input.startupTimeoutMs, "startupTimeoutMs");
     const diagnostic = cloneFacts(input.diagnostic, "startup-timeout diagnostic");
     const successorFacts = validateLaunchFacts(input.successorFacts, "successor launch facts");
+    const terminalAt = input.terminalAt === undefined
+        ? undefined
+        : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
         const history = readValidatedHistory(database);
         const current = history.current;
@@ -180,7 +183,12 @@ export function supersedeStartupTimeout(database, readOnly, input) {
         if (observedAtMs - launchedAtMs < startupTimeoutMs) {
             return rejected("startup-timeout-not-elapsed", current);
         }
-        const verdictFacts = validateVerdictFacts({ ...diagnostic, state: "launch-failed" }, "startup-timeout verdict facts");
+        const verdictFactsBase = {
+            ...diagnostic,
+            state: "launch-failed",
+            ...(terminalAt === undefined ? {} : { terminalAt }),
+        };
+        const verdictFacts = validateVerdictFacts(verdictFactsBase, "startup-timeout verdict facts");
         const firstSeq = history.records.length + 1;
         return committed([
             appendRecord(database, "verdict", executionId, verdictFacts, firstSeq),
@@ -196,6 +204,9 @@ export function replaceDeadRunner(database, readOnly, input) {
         throw new ProjectionGenerationStoreError("released runner-lock evidence must not be empty");
     }
     const successorFacts = validateLaunchFacts(input.successorFacts, "dead-runner successor launch facts");
+    const terminalAt = input.terminalAt === undefined
+        ? undefined
+        : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
         const history = readValidatedHistory(database);
         const current = history.current;
@@ -212,7 +223,12 @@ export function replaceDeadRunner(database, readOnly, input) {
         if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {
             return rejected("execution-id-already-used", current);
         }
-        const verdictFacts = validateVerdictFacts({ state: "lost-runner", releasedLockEvidence }, "dead-runner verdict facts");
+        const verdictFactsBase = {
+            state: "lost-runner",
+            releasedLockEvidence,
+            ...(terminalAt === undefined ? {} : { terminalAt }),
+        };
+        const verdictFacts = validateVerdictFacts(verdictFactsBase, "dead-runner verdict facts");
         const firstSeq = history.records.length + 1;
         return committed([
             appendRecord(database, "verdict", executionId, verdictFacts, firstSeq),

package/build/core/projection/index.js

@@ -10,13 +10,13 @@ export { resolveProjectionCoordinate } from "./projection-coordinate.js";
 export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionRoot, readProjectionEvents, } from "./projection-core.js";
 export { readProjectionIdentity } from "./projection-identity.js";
 export { killProjectionGeneration } from "./projection-kill.js";
-export { observeProjectionLife } from "./projection-life-observer.js";
+export { observeProjectionLife, observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 export { mintProjection, mintRepositoryProjection, ProjectionMintCollisionError, } from "./projection-mint.js";
 export { acquireProjectionRunnerLock, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
 export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readProjectionStatusBoard, } from "./projection-status.js";
 export { projectTerminalFailure, } from "./projection-terminal-failure.js";
 export { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet, } from "./projection-wait.js";
-export { assertTellEffortSupported, tellProjection, } from "./projection-wake.js";
+export { assertTellEffortSupported, assertProjectionTellable, tellProjection, } from "./projection-wake.js";
 export { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, ProjectionGenerationStore, } from "./generation/store.js";
 export { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
 export { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";