@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/markdown/parser.js

@@ -258,71 +258,3 @@ export function parseToAST(content, options = {}) {
     });
     return parser.parseDocument();
 }
-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/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

@@ -76,7 +76,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}`);
     }
     const objects = database.prepare(`
     SELECT name, type
@@ -138,7 +138,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}`);
         }
         validateSchemaShape(database);
         database.exec("COMMIT");
@@ -268,39 +268,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,6 +1,16 @@
-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";
     constructor(message, options) {
@@ -121,6 +131,37 @@ 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.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}`);
+        }
+        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) {

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 { demoteSubmittedTellsForReplay, readProjectionEvents, } from "../projection-core.js";
+import { createProjectionExecutionObserver, } 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);
 }
@@ -134,50 +135,27 @@ 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 terms = attachProviderLoaderPorts(buildCallTerms(inputs.launchSnapshot, inputs.prompt, inputs.cwd, {
         idleTimeoutMs: inputs.idleTimeoutMs,
         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 } : {}),
     });
     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) {
@@ -186,14 +164,6 @@ export function executeProjectionGeneration(projectionDirectory, launch) {
     }
     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"

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,5 +1,5 @@
 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;
@@ -30,7 +30,7 @@ export async function startProjectionGeneration(projectionDirectory, executionId
     catch (error) {
         const detail = `runner spawn failed: ${errorDetail(error)}`;
         recordLaunchFailure(projectionDirectory, executionId, detail, "spawn");
-        return { status: "failed", detail };
+        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)}`,
@@ -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.
@@ -315,6 +323,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,7 +1,7 @@
-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 { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, };
 export { GENERATION_VERDICT_STATES, ProjectionGenerationStoreError, } from "./model.js";
 export class ProjectionGenerationStore {
     databasePath;

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

@@ -131,7 +131,6 @@ export function verdictIfOpen(database, readOnly, input) {
     if (input.verdict === "killed") {
         throw new ProjectionGenerationStoreError("verdict 'killed' is reserved to runnerKilledIfRequested and settleKillIfRunnerDead");
     }
-    const facts = validateVerdictFacts({ ...(input.facts ?? {}), state: input.verdict }, "verdict facts");
     return writeTransition(database, readOnly, () => {
         const history = readValidatedHistory(database);
         const current = history.current;
@@ -150,6 +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");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
 }

package/build/core/projection/index.js

@@ -0,0 +1,27 @@
+/**
+ * Public surface for the projection package.
+ * Only symbols required by current external consumers are re-exported.
+ * Package-internal modules must import each other directly, not through this file.
+ */
+export { heartPath } from "./heart.js";
+export { AGENT_ACTIVITY_WINDOW_SIZE, foldAgentActivity, } from "./projection-activity.js";
+export { assertProjectionAlias, isProjectionAlias, moveProjectionAlias, projectionAliasRoot, readProjectionAlias, } from "./projection-alias.js";
+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 { 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 { 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";
+export { projectionGenerationRunnerArgv, spawnProjectionGenerationRunner, } from "./generation/projection-generation-process.js";
+export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
+export { executeProjectionGeneration } from "./generation/projection-generation-execution.js";
+export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";
+export { claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";

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

@@ -9,6 +9,9 @@ function duration(first, last) {
     return Math.max(0, last - first);
 }
 function warningIdentity(warning) {
+    if (warning.reason === "rate-limit") {
+        return JSON.stringify(warning);
+    }
     if (warning.reason === "retry") {
         return JSON.stringify({
             reason: warning.reason,
@@ -238,3 +241,12 @@ export function foldAgentActivity(events) {
         ...(failure ? { failure } : {}),
     };
 }
+/**
+ * Public wait/status activity deliberately excludes provider-origin terminal
+ * prose. Diagnostic and fail-event text remains available to artifact/internal
+ * consumers through the full fold, but has no JSON or human projection path.
+ */
+export function foldPublicProjectionActivity(events) {
+    const { diagnostic: _diagnostic, failure: _failure, ...activity } = foldAgentActivity(events);
+    return activity;
+}

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

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
-import { ProjectionStateError, randomHex8 } from "./atomic-publish.js";
+import { isErrnoException } from "../../errno.js";
+import { syncDirectorySync } from "../../fs/durability.js";
+import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { isProjectionId } from "./projection-core.js";
 export const PROJECTION_ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
@@ -15,12 +16,12 @@ export function assertProjectionAlias(value) {
     }
     return value;
 }
-export function projectionAliasRoot(cwd) {
-    return path.join(projectionCoordinateRoot(cwd), ".keiyaku", "projection-alias");
+export async function projectionAliasRoot(cwd) {
+    return path.join(await projectionCoordinateRoot(cwd), ".keiyaku", "projection-alias");
 }
-export function projectionAliasPath(cwd, alias) {
+export async function projectionAliasPath(cwd, alias) {
     assertProjectionAlias(alias);
-    return path.join(projectionAliasRoot(cwd), alias);
+    return path.join(await projectionAliasRoot(cwd), alias);
 }
 function invalidAliasRef(filePath) {
     return new ProjectionStateError(`invalid projection alias ref: ${filePath}`);
@@ -61,8 +62,8 @@ function readBoundedRegularAliasRef(filePath) {
     }
 }
 /** Undefined means no ref; malformed refs fail closed with their exact sidecar path. */
-export function readProjectionAlias(cwd, alias) {
-    const filePath = projectionAliasPath(cwd, alias);
+export async function readProjectionAlias(cwd, alias) {
+    const filePath = await projectionAliasPath(cwd, alias);
     const content = readBoundedRegularAliasRef(filePath);
     if (content === undefined)
         return undefined;
@@ -74,14 +75,14 @@ export function readProjectionAlias(cwd, alias) {
     return id;
 }
 /** Atomically replace one alias ref. Aliases intentionally have no multi-ref transaction. */
-export function moveProjectionAlias(cwd, alias, id) {
+export async function moveProjectionAlias(cwd, alias, id) {
     assertProjectionAlias(alias);
     if (!isProjectionId(id))
         throw new ProjectionStateError(`invalid projection id: ${id}`);
-    const previous = readProjectionAlias(cwd, alias);
-    const root = projectionAliasRoot(cwd);
+    const previous = await readProjectionAlias(cwd, alias);
+    const root = await projectionAliasRoot(cwd);
     fs.mkdirSync(root, { recursive: true });
-    const target = projectionAliasPath(cwd, alias);
+    const target = await projectionAliasPath(cwd, alias);
     let temp;
     try {
         for (let attempt = 0; attempt < 16; attempt += 1) {
@@ -107,13 +108,7 @@ export function moveProjectionAlias(cwd, alias, id) {
         if (!temp)
             throw new ProjectionStateError(`failed to create projection alias temp: ${target}`);
         fs.renameSync(temp, target);
-        const directoryFd = fs.openSync(root, fs.constants.O_RDONLY);
-        try {
-            fs.fsyncSync(directoryFd);
-        }
-        finally {
-            fs.closeSync(directoryFd);
-        }
+        syncDirectorySync(root);
     }
     finally {
         if (temp)