@astrosheep/keiyaku 2.9.11 → 2.9.13

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

@@ -10,7 +10,7 @@ export function launchIfSettled(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const facts = validateLaunchFacts(input.facts, "launch facts");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         if (history.records.some((record) => record.kind === "launch" && record.executionId === executionId)) {
             return rejected("execution-id-already-used", history.current);
         }
@@ -27,7 +27,7 @@ export function failInterruptWakeIfSettled(database, readOnly, input) {
     const successorFacts = validateLaunchFacts(input.successorFacts, "interrupt wake successor launch facts");
     const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -56,7 +56,7 @@ export function adoptionIfCurrent(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const facts = validateAdoptionFacts(input.facts, "adoption facts");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -73,7 +73,7 @@ export function requestKillIfOpen(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const killedAt = assertIsoTimestamp(input.killedAt, "killedAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -93,7 +93,7 @@ export function requestInterruptIfOpen(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const interruptedAt = assertIsoTimestamp(input.interruptedAt, "interruptedAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -111,6 +111,7 @@ export function requestInterruptIfOpen(database, readOnly, input) {
 }
 export function runnerKilledIfRequested(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
+    const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
     const callerFacts = cloneFacts(input.facts ?? {}, "killed verdict facts");
     if ("state" in callerFacts) {
         throw new ProjectionGenerationStoreError("killed verdict facts.state is reserved");
@@ -121,8 +122,11 @@ export function runnerKilledIfRequested(database, readOnly, input) {
     if ("killedAt" in callerFacts) {
         throw new ProjectionGenerationStoreError("killed verdict facts.killedAt is reserved");
     }
+    if ("terminalAt" in callerFacts) {
+        throw new ProjectionGenerationStoreError("killed verdict facts.terminalAt is reserved");
+    }
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -137,6 +141,7 @@ export function runnerKilledIfRequested(database, readOnly, input) {
             state: "killed",
             killIntentSeq: current.killIntent.seq,
             killedAt: current.killIntent.facts.killedAt,
+            terminalAt,
         }, "killed verdict facts");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
@@ -153,7 +158,7 @@ export function runnerInterruptedIfRequested(database, readOnly, input) {
         ? undefined
         : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -184,7 +189,7 @@ export function runnerVerdictIfOpen(database, readOnly, input) {
     const callerFacts = cloneFacts(input.facts ?? {}, "runner verdict facts");
     const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -221,6 +226,7 @@ export function runnerVerdictIfOpen(database, readOnly, input) {
 }
 export function settleKillIfRunnerDead(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
+    const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
     const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released runner-lock evidence");
     if (Object.keys(releasedLockEvidence).length === 0) {
         throw new ProjectionGenerationStoreError("released runner-lock evidence must not be empty");
@@ -235,8 +241,11 @@ export function settleKillIfRunnerDead(database, readOnly, input) {
     if ("killedAt" in callerFacts) {
         throw new ProjectionGenerationStoreError("killed verdict facts.killedAt is reserved");
     }
+    if ("terminalAt" in callerFacts) {
+        throw new ProjectionGenerationStoreError("killed verdict facts.terminalAt is reserved");
+    }
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -251,6 +260,7 @@ export function settleKillIfRunnerDead(database, readOnly, input) {
             state: "killed",
             killIntentSeq: current.killIntent.seq,
             killedAt: current.killIntent.facts.killedAt,
+            terminalAt,
             releasedLockEvidence,
         }, "killed verdict facts");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
@@ -264,7 +274,7 @@ export function verdictIfOpen(database, readOnly, input) {
         throw new ProjectionGenerationStoreError(`verdict '${input.verdict}' is reserved to its runner-owned transition`);
     }
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -298,7 +308,7 @@ export function supersedeStartupTimeout(database, readOnly, input) {
         ? undefined
         : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -346,7 +356,7 @@ export function settleStartupFailure(database, readOnly, input) {
         ? undefined
         : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -385,7 +395,7 @@ export function replaceDeadRunner(database, readOnly, input) {
         ? undefined
         : assertIsoTimestamp(input.terminalAt, "terminalAt");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);
@@ -426,7 +436,7 @@ export function handoff(database, readOnly, input) {
     const tellFence = validateTellFence([...input.tellFence], "handoff tellFence");
     const successorFacts = validateLaunchFacts({ ...successorFactsBase, tellFence }, "handoff successor launch facts");
     return writeTransition(database, readOnly, () => {
-        const history = readValidatedHistory(database);
+        const history = readValidatedHistory(database, readOnly);
         const current = history.current;
         if (!current)
             return rejected("no-current-launch", null);

package/build/core/projection/index.js

@@ -10,18 +10,18 @@ export { resolveProjectionCoordinate } from "./projection-coordinate.js";
 export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionDirAtCoordinate, projectionRoot, readProjectionEvents, readGenerationEventsWithRetention, } from "./projection-core.js";
 export { readProjectionIdentity } from "./projection-identity.js";
 export { interruptProjectionGeneration, killProjectionGeneration } from "./projection-kill.js";
+export { openProjectionGenerationDoorbell, projectionGenerationDoorbellAddress, ringProjectionGenerationDoorbell, } from "./generation/projection-generation-doorbell.js";
 export { observeProjectionLife, observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 export { mintProjection, mintRepositoryProjection, ProjectionMintCollisionError, } from "./projection-mint.js";
-export { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, acquireProjectionRunnerTransferTarget, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
-export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readAkumaNonterminalProjectionStatus, readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "./projection-status.js";
+export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, paginateProjectionStatusRoster, triageProjectionStatusRows, readAkumaNonterminalProjectionStatus, readExactProjectionStatus, readOperationalProjectionStatusBoard, readProjectionRosterStatusBoard, selectProjectionStatus, } from "./projection-status.js";
 export { PROJECTION_HISTORY_FILTER_COMPLETION, PROJECTION_HISTORY_FILTER_FIELDS, PROJECTION_HISTORY_FILTER_GRAMMAR, parseProjectionHistoryFilter, parseProjectionHistorySort, readProjectionHistoryAddress, readExactProjectionHistory, readProjectionHistory, resolveProjectionHistoryAddress, selectProjectionHistory, } from "./projection-history.js";
 export { projectTerminalFailure, } from "./projection-terminal-failure.js";
 export { snapshotCommissionProjectionIds, snapshotCommissionProjectionIdsAtCoordinate, 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 { createProjectionExecutionId, projectionRunnerLeasePath, } from "./generation/projection-generation-identity.js";
+export { startProjectionGeneration } from "./generation/projection-generation-launcher.js";
+export { projectionGenerationRunnerArgv, prepareProjectionGenerationRunner, } from "./generation/projection-generation-process.js";
 export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
 export { executeProjectionGeneration, prepareProjectionGenerationExecution, } from "./generation/projection-generation-execution.js";
 export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";

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

@@ -3,14 +3,18 @@ import * as path from "node:path";
 import { isErrnoException } from "../../errno.js";
 import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "../atomic-publish.js";
+import { isAkumaName } from "./akuma-name.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 export { isTellCausallyConsumed, } from "./tell/model.js";
 export { bindTellLaunchReservation, claimAllInbox, claimAndReserveFencedTells, claimFencedTells, listTellLaunchBatch, listTellLaunchAdmissions, isTellLaunchAdmissionMember, claimTellToInflight, listTellIds, markTellSubmitted, recordTellReceiptCapabilities, recordTellReceipt, readTellReceiptCapabilities, 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}$/;
+const PROJECTION_HEX_PATTERN = /^[0-9a-f]{8}$/;
 export function isProjectionId(value) {
-    return PROJECTION_ID_PATTERN.test(value);
+    const slash = value.indexOf("/");
+    if (slash <= 0 || slash !== value.lastIndexOf("/"))
+        return false;
+    return isAkumaName(value.slice(0, slash)) && PROJECTION_HEX_PATTERN.test(value.slice(slash + 1));
 }
 /** Derive one projection storage root from already-resolved repository authority. */
 export function projectionRootAtCoordinate(coordinate) {

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

@@ -1,5 +1,5 @@
 import { claimAllInbox, isTellLaunchAdmissionMember, listTellLaunchAdmissions, listTellIds, markTellSubmitted, bindTellLaunchReservation, recordTellReceiptCapabilities, recordTellReceipt, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
-import { openProjectionTellObserver, } from "./tell/database.js";
+import { openProjectionTellObserver } from "./generation/database.js";
 const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
 export function renderProjectionTellFrame(tellId, text) {
     void tellId;

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

@@ -8,18 +8,17 @@ import { parseStructuredQuery, STRUCTURED_QUERY_COMPLETION, STRUCTURED_QUERY_GRA
 import { selectValidStoredAgentEvents } from "../stored-agent-event.js";
 import { extractTerminalTimestamp } from "./generation/model.js";
 import { readProjectionAlias } from "./projection-alias.js";
-import { foldPublicProjectionActivity } from "./projection-activity.js";
+import { foldPublicProjectionActivity, } from "./projection-activity.js";
 import { isProjectionId, projectionDir, projectionRoot, readGenerationEventsWithRetention, readProjectionEvents } from "./projection-core.js";
 import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { readProjectionIdentity } from "./projection-identity.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./projection-life-protocol.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
+import { selectCurrentGeneration } from "./generation/protocol.js";
 export const PROJECTION_HISTORY_FILTER_FIELDS = ["contract", "akuma", "role", "outcome", "created", "updated"];
 export const PROJECTION_HISTORY_FILTER_GRAMMAR = STRUCTURED_QUERY_GRAMMAR;
 export const PROJECTION_HISTORY_FILTER_COMPLETION = STRUCTURED_QUERY_COMPLETION;
 const HISTORY_FIELDS = new Set(PROJECTION_HISTORY_FILTER_FIELDS);
-const HISTORY_ROLES = new Set(["call", "revive", "unknown"]);
+const HISTORY_ROLES = new Set(["call", "fork", "unknown"]);
 const HISTORY_OUTCOMES = new Set(["minting", "startup-timeout", "unknown", "out", "lost", "done", "killed", "dismissed", "failed", "dead", "incompatible"]);
 const RELATIVE_TIME = /^now-([1-9][0-9]*)([smhdw])$/;
 const UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 };
@@ -119,7 +118,7 @@ function outcomeFromLife(phase) {
 function roleFromRecords(records) {
     const inputs = records?.find((record) => record.kind === "launch")?.facts.inputs;
     return inputs && typeof inputs === "object" && !Array.isArray(inputs) && typeof inputs.sourceArtifactId === "string"
-        ? "revive"
+        ? "fork"
         : records?.some((record) => record.kind === "launch") ? "call" : "unknown";
 }
 async function artifactFromVerdict(cwd, artifactId, executionId, index) {
@@ -235,10 +234,9 @@ async function readRun(artifactRoot, directory, id, alias, artifactIndex, addres
     const diagnostics = [];
     const snapshot = observeProjectionLifeSnapshot(directory, {
         nowMs: Date.now(),
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
     });
     if (snapshot.compatibility === "incompatible") {
-        return { id, ...(alias ? { alias } : {}), akuma: null, provider: null, pid: null, role: "unknown", contractId: null, outcome: "incompatible", mintedAt: null, terminalAt: null, generation: null, activityAt: null, artifact: null, artifacts: [], activityRetention: "incompatible", activityCount: 0, activityRange: null, telemetry: null, consequences: null, diagnostics: [snapshot.diagnostic], activity: null };
+        return { id, ...(alias ? { alias } : {}), akuma: null, provider: null, pid: null, role: "unknown", contractId: null, outcome: "incompatible", mintedAt: null, terminalAt: null, generation: null, activityAt: null, artifact: null, artifacts: [], activityRetention: "incompatible", activityCount: 0, activityRange: null, telemetry: null, consequences: null, diagnostics: [snapshot.diagnostic], terminalAnswer: null, activity: null };
     }
     let identity;
     try {
@@ -296,6 +294,9 @@ async function readRun(artifactRoot, directory, id, alias, artifactIndex, addres
         telemetry: telemetryFromActivity(activity),
         consequences: null,
         diagnostics,
+        terminalAnswer: typeof current?.verdict?.facts.finalMessage === "string"
+            ? { kind: "text", text: current.verdict.facts.finalMessage }
+            : null,
         activity,
     };
 }
@@ -384,7 +385,6 @@ async function retainedArtifactRelationships(root, artifactId, preferredAkuma) {
                 return [];
             const snapshot = observeProjectionLifeSnapshot(directory, {
                 nowMs: Date.now(),
-                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
             });
             if (snapshot.compatibility === "incompatible" || !snapshot.records)
                 return [];

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

@@ -1,5 +1,7 @@
 import { openProjectionGenerationStore } from "./generation/store.js";
-import { acquireProjectionRunnerSettlementLock, observeProjectionRunnerLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.js";
+import { acquireRunnerLostProof, observeRunnerLease, RunnerLeaseUnavailableError, } from "../run-control/runner-lease.js";
+import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.js";
+import { ringProjectionGenerationDoorbell } from "./generation/projection-generation-doorbell.js";
 /** The runner observes this durable intent and owns native termination. */
 export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.now()) {
     const store = openProjectionGenerationStore(projectionDirectory);
@@ -11,19 +13,23 @@ export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.
             if (current.verdict)
                 return { status: "already-closed", executionId: current.launch.executionId };
             const executionId = current.launch.executionId;
-            if (!current.adoption || observeProjectionRunnerLock(projectionDirectory).state !== "held") {
+            if (!current.adoption || observeRunnerLease(projectionRunnerLeasePath(projectionDirectory)).state !== "held") {
                 return { status: "already-closed", executionId };
             }
             const request = store.requestInterruptIfOpen({
                 executionId,
                 interruptedAt: new Date(nowMs).toISOString(),
             });
-            if (request.status === "committed")
+            if (request.status === "committed") {
+                ringProjectionGenerationDoorbell(store.readIdentity(), executionId);
                 return { status: "accepted", executionId };
+            }
             if (request.reason === "not-current")
                 continue;
-            if (request.reason === "interrupt-requested")
+            if (request.reason === "interrupt-requested") {
+                ringProjectionGenerationDoorbell(store.readIdentity(), executionId);
                 return { status: "accepted", executionId };
+            }
             return { status: "already-closed", executionId };
         }
     }
@@ -31,7 +37,7 @@ export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.
         store.close();
     }
 }
-function settleReleasedLeash(store, projectionDirectory, executionId) {
+function settleReleasedLeash(store, projectionDirectory, executionId, terminalAt) {
     const current = store.readCurrentGeneration();
     if (current?.launch.executionId !== executionId
         || current.verdict) {
@@ -39,10 +45,10 @@ function settleReleasedLeash(store, projectionDirectory, executionId) {
     }
     let deathEvidence;
     try {
-        deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
+        deathEvidence = acquireRunnerLostProof(projectionRunnerLeasePath(projectionDirectory));
     }
     catch (error) {
-        if (error instanceof ProjectionRunnerLockUnavailableError) {
+        if (error instanceof RunnerLeaseUnavailableError) {
             return { status: "accepted", executionId };
         }
         return { status: "accepted", executionId };
@@ -50,7 +56,8 @@ function settleReleasedLeash(store, projectionDirectory, executionId) {
     try {
         store.settleKillIfRunnerDead({
             executionId,
-            releasedLockEvidence: { state: "acquired", executionId },
+            releasedLockEvidence: { state: "acquired", executionId, observedAt: terminalAt },
+            terminalAt,
         });
     }
     finally {
@@ -78,11 +85,14 @@ export function killProjectionGeneration(projectionDirectory, nowMs = Date.now()
             const executionId = current.launch.executionId;
             const request = store.requestKillIfOpen({ executionId, killedAt });
             if (request.status === "committed") {
-                return settleReleasedLeash(store, projectionDirectory, executionId);
+                // A missing, stale, or rejected endpoint has no lifecycle meaning.
+                ringProjectionGenerationDoorbell(store.readIdentity(), executionId);
+                return settleReleasedLeash(store, projectionDirectory, executionId, new Date(nowMs).toISOString());
             }
             if (request.reason === "kill-requested") {
                 // Idempotent first intent: still accepted, then one leash observation.
-                return settleReleasedLeash(store, projectionDirectory, executionId);
+                ringProjectionGenerationDoorbell(store.readIdentity(), executionId);
+                return settleReleasedLeash(store, projectionDirectory, executionId, new Date(nowMs).toISOString());
             }
             if (request.reason === "already-terminal") {
                 return { status: "already-closed", executionId };

package/build/core/projection/projection-life-observer.js

@@ -1,13 +1,15 @@
 import { isIncompatibleProjectionGenerationStoreError, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
-import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
-import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+import { deriveProjectionLife, selectCurrentGeneration, } from "./generation/protocol.js";
+import { observeRunnerLease } from "../run-control/runner-lease.js";
+import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.js";
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /**
  * Observe the current generation without creating, repairing, or mutating
  * projection storage. Generation history is the ordering authority; the
- * runner lock is consulted only for an adopted, non-terminal generation.
+ * runner lock is consulted for every non-terminal generation. Launch age is
+ * not lifecycle authority.
  */
 export function observeProjectionLifeSnapshot(projectionDirectory, options) {
     const readRecords = () => {
@@ -37,18 +39,17 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             };
         }
         const current = selectCurrentGeneration(records);
-        if (!current || current.verdict || !current.adoption) {
+        if (!current || current.verdict) {
             return {
                 compatibility: "current",
                 life: deriveProjectionLife({
                     records,
                     nowMs: options.nowMs,
-                    startupTimeoutMs: options.startupTimeoutMs,
                 }),
                 records,
             };
         }
-        const lock = observeProjectionRunnerLock(projectionDirectory, options.platform);
+        const lock = observeRunnerLease(projectionRunnerLeasePath(projectionDirectory));
         let after;
         try {
             after = readRecords();
@@ -74,13 +75,12 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             compatibility: "current",
             life: deriveProjectionLife({
                 records,
-                runnerLock: lock.state === "held"
+                runnerLease: lock.state === "held"
                     ? "held"
                     : lock.state === "released"
                         ? "released"
                         : "unknown",
                 nowMs: options.nowMs,
-                startupTimeoutMs: options.startupTimeoutMs,
             }),
             records,
         };

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

@@ -5,7 +5,9 @@ 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 "./generation/store.js";
-import { initializeProjectionRunnerLockDatabase } from "./projection-runner-lock.js";
+import { initializeRunnerLeaseDatabase } from "../run-control/runner-lease.js";
+import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.js";
+import { isAkumaName } from "./akuma-name.js";
 export class ProjectionMintCollisionError extends Error {
     code = "PROJECTION_MINT_COLLISION";
     constructor(message, options) {
@@ -15,14 +17,10 @@ export class ProjectionMintCollisionError extends Error {
 }
 const DEFAULT_MINT_ATTEMPTS = 16;
 function assertMintSlug(slug) {
-    const normalized = slug.trim();
-    if (!normalized) {
-        throw new ProjectionStateError("projection slug cannot be empty");
-    }
-    if (!/^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/.test(normalized)) {
+    if (!isAkumaName(slug)) {
         throw new ProjectionStateError(`invalid projection slug: ${slug}`);
     }
-    return normalized;
+    return slug;
 }
 function removeEmptyAkumaRoot(dir) {
     try {
@@ -115,7 +113,7 @@ function publishReservedProjection(pact, reserved) {
         finally {
             heart.close();
         }
-        initializeProjectionRunnerLockDatabase(reserved.stagingDir);
+        initializeRunnerLeaseDatabase(projectionRunnerLeasePath(reserved.stagingDir));
         fs.renameSync(reserved.stagingDir, reserved.dir);
         published = true;
         return { id: reserved.id, dir: reserved.dir, pact };

package/build/core/projection/projection-status-observation.js

@@ -7,12 +7,51 @@ import { foldPublicProjectionActivity } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
 import { readPendingTellWindow, readProjectionTellCounts } from "./tell/store.js";
 import { ProjectionGenerationStoreError } from "./generation/store.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./projection-life-protocol.js";
+import { selectCurrentGeneration } from "./generation/protocol.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
 import { projectTerminalFailure } from "./projection-terminal-failure.js";
 import { extractTerminalTimestamp } from "./generation/model.js";
+function latestActivityRow(activity, kind, predicate) {
+    const rows = activity?.retainedTimeline.filter((row) => row.kind === kind) ?? [];
+    return [...rows].reverse().find((row) => predicate?.(row) ?? true);
+}
+export function deriveProjectionStatusReadFacts(input) {
+    const warning = latestActivityRow(input.activity, "warning");
+    const runningTool = latestActivityRow(input.activity, "ran", (row) => row.state === "running");
+    const said = latestActivityRow(input.activity, "said");
+    const answer = typeof input.verdictFacts?.finalMessage === "string"
+        ? { kind: "text", text: input.verdictFacts.finalMessage }
+        : undefined;
+    const responsePath = typeof input.verdictFacts?.responsePath === "string" ? input.verdictFacts.responsePath : undefined;
+    const artifactId = typeof input.verdictFacts?.artifactId === "string" ? input.verdictFacts.artifactId : undefined;
+    const launchInputs = input.launchFacts?.inputs;
+    const incognito = launchInputs !== null && typeof launchInputs === "object" && !Array.isArray(launchInputs)
+        && launchInputs.persistProjectionResponse === false;
+    const persistenceFailed = input.verdictFacts?.responsePersistError !== undefined;
+    const snapshot = warning
+        ? { kind: "warning", row: warning }
+        : runningTool
+            ? { kind: "running-tool", row: runningTool }
+            : said
+                ? { kind: "said", row: said }
+                : input.activity?.plan
+                    ? { kind: "plan", plan: input.activity.plan }
+                    : undefined;
+    const responseArtifact = input.verdictFacts === undefined
+        ? undefined
+        : responsePath
+            ? { state: "retained", path: responsePath, ...(artifactId ? { artifactId } : {}) }
+            : incognito
+                ? { state: "none", reason: "incognito" }
+                : { state: "unavailable", reason: persistenceFailed ? "persistence-failed" : "not-observed" };
+    return {
+        ...(answer ? { terminalAnswer: answer } : {}),
+        ...(responseArtifact ? { responseArtifact } : {}),
+        attention: { ...(warning ? { latestWarning: warning } : {}) },
+        ...(snapshot ? { snapshot } : {}),
+    };
+}
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
 class ProjectionStatusFileError extends Error {
     diagnostic;
@@ -233,11 +272,19 @@ function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallb
 function terminalTimestamp(current) {
     return extractTerminalTimestamp(current?.verdict?.facts);
 }
+function terminalAgeAt(terminalAt, observedAtMs) {
+    const terminalAtMs = Date.parse(terminalAt ?? "");
+    return Number.isFinite(terminalAtMs) ? Math.max(0, observedAtMs - terminalAtMs) : undefined;
+}
+function projectionStatusState(life) {
+    if (life.verdict === "lost-runner")
+        return "dead";
+    return life.phase === "active" || life.phase === "quiescent" ? "out" : life.phase;
+}
 export function readProjectionSummary(projectionDir, id, alias, nowMs, options) {
     const diagnostics = [];
     const snapshot = observeProjectionLifeSnapshot(projectionDir, {
         nowMs,
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
     });
     if (snapshot.compatibility === "incompatible") {
         return {
@@ -251,8 +298,7 @@ export function readProjectionSummary(projectionDir, id, alias, nowMs, options)
         };
     }
     const life = snapshot.life;
-    const phase = life.phase;
-    const state = phase === "active" || phase === "quiescent" ? "out" : phase;
+    const state = projectionStatusState(life);
     const identityFacts = options?.requiresIdentity?.(state) === false
         ? null
         : readIdentityFacts(projectionDir, diagnostics);
@@ -268,27 +314,38 @@ export function readProjectionSummary(projectionDir, id, alias, nowMs, options)
 }
 export function readProjectionRow(summary, nowMs, readDetails) {
     const { id, alias, projectionDir, snapshot } = summary;
+    const identity = { canonicalId: id };
     const diagnostics = [...summary.diagnostics];
     if (snapshot.compatibility === "incompatible") {
         return {
             id,
+            identity,
             observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: "incompatible",
             observation: snapshot,
             tellCounts: emptyTellCounts(),
+            attention: {},
             diagnostics,
         };
     }
     const identityFacts = summary.identityFacts;
     if (identityFacts === null && !readDetails) {
+        const current = snapshot.records ? selectCurrentGeneration(snapshot.records) : null;
+        const terminalAt = terminalTimestamp(current);
+        const terminalAgeMs = current?.verdict ? terminalAgeAt(terminalAt, nowMs) : undefined;
+        const readFacts = deriveProjectionStatusReadFacts({ state: summary.state });
         return {
             id,
+            identity,
             observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: summary.state,
             observation: { compatibility: "current", lifecycle: snapshot.life },
+            ...(terminalAt ? { terminalAt } : {}),
+            ...(terminalAgeMs !== undefined ? { terminalAgeMs } : {}),
             tellCounts: emptyTellCounts(),
+            ...readFacts,
             diagnostics,
         };
     }
@@ -297,6 +354,7 @@ export function readProjectionRow(summary, nowMs, readDetails) {
             ?? "projection identity could not be observed";
         return {
             id,
+            identity,
             observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: "unknown",
@@ -305,6 +363,7 @@ export function readProjectionRow(summary, nowMs, readDetails) {
                 lifecycle: { phase: "unknown", diagnostic },
             },
             tellCounts: emptyTellCounts(),
+            attention: {},
             diagnostics,
         };
     }
@@ -325,8 +384,10 @@ export function readProjectionRow(summary, nowMs, readDetails) {
         : {};
     const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
     const terminalAt = terminalTimestamp(current);
+    const terminalAtMs = Date.parse(terminalAt ?? "");
+    const terminalAgeMs = current?.verdict ? terminalAgeAt(terminalAt, nowMs) : undefined;
     const durationAnchorMs = current?.verdict
-        ? (terminalAt === undefined ? Number.NaN : Date.parse(terminalAt))
+        ? terminalAtMs
         : nowMs;
     const durationMs = Number.isFinite(mintedAtMs) && Number.isFinite(durationAnchorMs)
         ? Math.max(0, durationAnchorMs - mintedAtMs)
@@ -336,13 +397,19 @@ export function readProjectionRow(summary, nowMs, readDetails) {
     if (life.phase === "unknown" && life.diagnostic) {
         diagnostics.push({ kind: "unknown-lifecycle", detail: life.diagnostic });
     }
-    const phase = life.phase;
-    const state = phase === "active" || phase === "quiescent" ? "out" : phase;
+    const state = projectionStatusState(life);
     const terminalFailure = current?.verdict
         ? projectTerminalFailure(current.verdict.facts.state, current.verdict.facts)
         : undefined;
+    const readFacts = deriveProjectionStatusReadFacts({
+        state,
+        activity: activityFacts.activity,
+        verdictFacts: current?.verdict?.facts,
+        launchFacts: current?.launch.facts,
+    });
     return {
         id,
+        identity,
         observedAtMs: nowMs,
         ...(alias ? { alias } : {}),
         state,
@@ -353,11 +420,13 @@ export function readProjectionRow(summary, nowMs, readDetails) {
         pid: identityFacts.pid,
         mintedAt: identityFacts.mintedAt,
         ...(terminalAt ? { terminalAt } : {}),
+        ...(terminalAgeMs !== undefined ? { terminalAgeMs } : {}),
         ...(durationMs !== undefined ? { durationMs } : {}),
         ...(identityFacts.workspaceRoot ? { workspaceRoot: identityFacts.workspaceRoot } : {}),
         ...activityFacts,
         ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
         ...(terminalFailure ? { terminalFailure } : {}),
+        ...readFacts,
         tellCounts,
         ...(pendingTells.length > 0 ? { pendingTells } : {}),
         diagnostics,