@astrosheep/keiyaku 2.9.3 → 2.9.5

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, ...(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

@@ -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, 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, 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";
+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,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
-import { syncDirectorySync } from "../fs/durability.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}$/;
@@ -16,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}`);
@@ -62,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;
@@ -75,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) {

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

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

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

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

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

@@ -1,76 +1,27 @@
-import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
-import { openProjectionTellObserver, } from "./projection/tell/database.js";
-function frameTellBodies(projectionDirectory, tellIds) {
-    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
-    const frames = originals
-        .map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`)
-        .join("\n\n");
-    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
-    return { frames, ...(effort ? { effort } : {}) };
-}
-function operatorBodyForContinuation(prompt, tellFrames, sessionContinuationPromptPrefix) {
-    return sessionContinuationPromptPrefix === undefined
-        ? `${prompt}\n\n${tellFrames}`
-        : `${sessionContinuationPromptPrefix}${tellFrames}`;
-}
-/** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
-export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId, options = {}) {
-    const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
-    if (tellIds.length === 0)
-        return { prompt, tellIds };
-    const { frames, effort } = frameTellBodies(projectionDirectory, tellIds);
-    const nextPrompt = operatorBodyForContinuation(prompt, frames, options.sessionContinuationPromptPrefix);
-    return { prompt: nextPrompt, tellIds, ...(effort ? { effort } : {}) };
-}
-/** Tier-2 has no steer acknowledgement: actual driver start is its ordinal-zero submission point. */
-export function markReplayStarted(projectionDirectory, executionId, tellIds) {
-    for (const tellId of tellIds) {
-        if (listTellIds(projectionDirectory, "inflight").includes(tellId)) {
-            markTellSubmitted(projectionDirectory, tellId, { executionId, fence: { kind: "ordinal", ordinal: 0 } });
-        }
-    }
-}
-/** A successful replay terminal is checkpoint ordinal one; failures intentionally do not consume. */
-export function markReplayCompleted(projectionDirectory, executionId) {
-    for (const tellId of listTellIds(projectionDirectory, "submitted")) {
-        const submitted = readTellSubmitted(projectionDirectory, tellId);
-        if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, { kind: "ordinal", ordinal: 1 })) {
-            markTellConsumed(projectionDirectory, tellId);
-        }
-    }
-}
-/**
- * Tier-2's only submission acknowledgement. A created driver is deliberately
- * insufficient: observe the first provider event, or a successful completion
- * from a provider that emitted no events.
- */
-export function createReplayRunStartGate(projectionDirectory, executionId, tellIds) {
-    let started = false;
-    const start = () => {
-        if (started)
-            return;
-        markReplayStarted(projectionDirectory, executionId, tellIds);
-        started = true;
-    };
-    return { observeProviderEvent: start, observeSuccessfulCompletion: start };
-}
+import { claimAllInbox, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
+import { openProjectionTellObserver, } from "./tell/database.js";
 const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
-function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, observer, pendingCompletionEvidence) {
+export function renderProjectionTellFrame(tellId, text) {
+    return `--- tell ${tellId} ---\n${text}`;
+}
+function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, submissions, excludedTellIds, observer, pendingCompletionEvidence) {
     if (requireInbox && !observer?.hasInbox())
         return;
     claimAllInbox(projectionDirectory);
     for (const tellId of listTellIds(projectionDirectory, "inflight")) {
+        if (excludedTellIds.has(tellId))
+            continue;
         if (submitting.has(tellId))
             continue;
         // Construct before pin: a sync read/build failure must not leave submitting stuck.
         const original = readTellOriginal(projectionDirectory, "inflight", tellId);
         const tell = {
             id: tellId,
-            text: `--- tell ${tellId} ---\n${original.text}`,
+            text: renderProjectionTellFrame(tellId, original.text),
             ...(original.effort ? { effort: original.effort } : {}),
         };
         submitting.add(tellId);
-        void Promise.resolve()
+        const submission = Promise.resolve()
             .then(() => control.enqueue(tell))
             .then((ack) => {
             if (!ack)
@@ -93,6 +44,8 @@ function submitEligible(projectionDirectory, executionId, control, requireInbox,
             pendingCompletionEvidence.delete(tellId);
         })
             .finally(() => submitting.delete(tellId));
+        submissions.add(submission);
+        void submission.finally(() => submissions.delete(submission));
     }
 }
 export function createLiveTellDeliveryController(projectionDirectory, executionId, dependencies = {}) {
@@ -101,8 +54,10 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
     const clearTimer = dependencies.clearTimer ?? ((timer) => clearTimeout(timer));
     const openObserver = dependencies.openObserver ?? openProjectionTellObserver;
     const submitting = new Set();
+    const submissions = new Set();
     // In-memory only: bridges completion-before-ack when a tell is still submitting.
     const pendingCompletionEvidence = new Map();
+    const initial = new Set(dependencies.initialTellIds);
     let observer;
     let timer;
     let nextOpportunityAt = 0;
@@ -147,7 +102,7 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
         try {
             observer ??= openObserver(projectionDirectory);
             if (observer.hasDataVersionChanged()) {
-                submitEligible(projectionDirectory, executionId, control, true, submitting, observer, pendingCompletionEvidence);
+                submitEligible(projectionDirectory, executionId, control, true, submitting, submissions, initial, observer, pendingCompletionEvidence);
             }
         }
         catch {
@@ -185,7 +140,14 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                 return;
             latestControl = control;
             cancelOpportunity();
-            submitEligible(projectionDirectory, executionId, control, false, submitting, observer, pendingCompletionEvidence);
+            for (const tellId of initial) {
+                markTellSubmitted(projectionDirectory, tellId, {
+                    executionId,
+                    fence: checkpoint.fence,
+                });
+                initial.delete(tellId);
+            }
+            submitEligible(projectionDirectory, executionId, control, false, submitting, submissions, initial, observer, pendingCompletionEvidence);
             if (!checkpoint.consumptionEvidence)
                 return;
             for (const tellId of listTellIds(projectionDirectory, "submitted")) {
@@ -203,13 +165,14 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                     pendingCompletionEvidence.set(tellId, [checkpoint.fence]);
             }
         },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            cancelOpportunity();
-            discardObserver();
+        async close() {
+            if (!closed) {
+                closed = true;
+                cancelOpportunity();
+                discardObserver();
+            }
             // Do not drop pendingCompletionEvidence: in-flight acks may still submit/consume.
+            await Promise.all([...submissions]);
         },
     };
 }
@@ -228,11 +191,10 @@ export function buildSyncCheckpointCallback(projectionDirectory, executionId) {
  */
 export function createProjectionExecutionObserver(input, dependencies = {}) {
     const appendEvent = dependencies.appendGenerationEvent ?? appendGenerationEvent;
-    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId);
-    let closed = false;
+    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId, { initialTellIds: input.initialTellIds });
+    let closePromise;
     const observer = {
         onEvent(event) {
-            input.replayStartGate?.observeProviderEvent();
             appendEvent(input.projectionDirectory, input.executionId, event);
         },
         onCheckpoint(control, checkpoint) {
@@ -245,15 +207,12 @@ export function createProjectionExecutionObserver(input, dependencies = {}) {
     return {
         observer,
         close() {
-            if (closed)
-                return;
-            closed = true;
-            try {
-                tellController.close();
-            }
-            catch {
+            if (closePromise)
+                return closePromise;
+            closePromise = tellController.close().catch(() => {
                 // Controller cleanup cannot change provider completion.
-            }
+            });
+            return closePromise;
         },
     };
 }

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
+import { isIncompatibleProjectionGenerationStoreError, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 function errorDetail(error) {
@@ -25,7 +25,11 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             records = readRecords();
         }
         catch (error) {
+            if (isIncompatibleProjectionGenerationStoreError(error)) {
+                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
+            }
             return {
+                compatibility: "current",
                 life: {
                     phase: "unknown",
                     diagnostic: `generation history could not be observed: ${errorDetail(error)}`,
@@ -35,6 +39,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         const current = selectCurrentGeneration(records);
         if (!current || current.verdict || !current.adoption) {
             return {
+                compatibility: "current",
                 life: deriveProjectionLife({
                     records,
                     nowMs: options.nowMs,
@@ -49,7 +54,11 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             after = readRecords();
         }
         catch (error) {
+            if (isIncompatibleProjectionGenerationStoreError(error)) {
+                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
+            }
             return {
+                compatibility: "current",
                 life: {
                     phase: "unknown",
                     executionId: current.launch.executionId,
@@ -62,6 +71,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         if (records.length !== after.length || beforeTail !== afterTail)
             continue;
         return {
+            compatibility: "current",
             life: deriveProjectionLife({
                 records,
                 runnerLock: lock.state === "held"
@@ -76,6 +86,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         };
     }
     return {
+        compatibility: "current",
         life: {
             phase: "unknown",
             diagnostic: "generation history changed during runner-lock observation",
@@ -83,5 +94,8 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
     };
 }
 export function observeProjectionLife(projectionDirectory, options) {
-    return observeProjectionLifeSnapshot(projectionDirectory, options).life;
+    const snapshot = observeProjectionLifeSnapshot(projectionDirectory, options);
+    return snapshot.compatibility === "current"
+        ? snapshot.life
+        : { phase: "unknown", diagnostic: snapshot.diagnostic };
 }

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

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