@astrosheep/keiyaku 2.9.7 → 2.9.9

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

@@ -40,6 +40,95 @@ function readJournalMode(database) {
 function assertCurrentLockSchema(database) {
     database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
 }
+function assertBusyTimeout(busyTimeoutMs) {
+    if (!Number.isSafeInteger(busyTimeoutMs) || busyTimeoutMs < 0) {
+        throw new ProjectionRunnerLockUnavailableError("projection runner lock busy timeout must be a non-negative safe integer");
+    }
+}
+function openGuard(lockPath, busyTimeoutMs) {
+    const database = new DatabaseSync(lockPath);
+    try {
+        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
+        database.exec("BEGIN DEFERRED");
+        assertCurrentLockSchema(database);
+        if (readJournalMode(database) !== "delete") {
+            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
+        }
+        return database;
+    }
+    catch (error) {
+        closeTransaction(database);
+        throw error;
+    }
+}
+function openReservation(lockPath, busyTimeoutMs) {
+    const database = new DatabaseSync(lockPath);
+    try {
+        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
+        database.exec("BEGIN IMMEDIATE");
+        return database;
+    }
+    catch (error) {
+        closeTransaction(database);
+        throw error;
+    }
+}
+function closeTransaction(database) {
+    let failure;
+    try {
+        database.exec("ROLLBACK");
+    }
+    catch (error) {
+        failure = error;
+    }
+    try {
+        database.close();
+    }
+    catch (error) {
+        failure ??= error;
+    }
+    return failure;
+}
+function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
+    let closed = false;
+    let reservation = initialReservation;
+    return {
+        path: lockPath,
+        releaseReservationForTransfer() {
+            if (closed || reservation === undefined)
+                return;
+            const released = reservation;
+            reservation = undefined;
+            const failure = closeTransaction(released);
+            if (failure !== undefined) {
+                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation release failed: ${errorDetail(failure)}`, { cause: failure });
+            }
+        },
+        reclaimReservation() {
+            if (closed || reservation !== undefined)
+                return;
+            try {
+                reservation = openReservation(lockPath, busyTimeoutMs);
+            }
+            catch (error) {
+                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation reclaim failed: ${errorDetail(error)}`, { cause: error });
+            }
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            let failure;
+            if (reservation !== undefined)
+                failure = closeTransaction(reservation);
+            const guardFailure = closeTransaction(guard);
+            failure ??= guardFailure;
+            if (failure !== undefined) {
+                throw new ProjectionRunnerLockUnavailableError(`projection runner lock release failed: ${errorDetail(failure)}`, { cause: failure });
+            }
+        },
+    };
+}
 function closeAfterFailedAcquire(database, error) {
     try {
         database.close();
@@ -95,13 +184,12 @@ export function initializeProjectionRunnerLockDatabase(projectionDirectory, plat
     return lockPath;
 }
 /**
- * Open the already initialized projection-local lock database and hold one
- * rollback-mode EXCLUSIVE transaction until close() or process death. SQLite
- * requires a writable connection for this write-grade lock; the preceding
- * regular-file check prevents ordinary missing storage from being created.
- * Database bytes and timestamps are deliberately absent from the returned authority.
+ * Hold one rollback-mode SHARED guard plus the sole RESERVED claim until
+ * close() or process death. An EXCLUSIVE probe cannot pass either component.
+ * During handoff the child overlaps the guard before the RESERVED claim moves,
+ * so kernel exclusion remains continuous without transferring a connection.
  */
-export function acquireProjectionRunnerLock(projectionDirectory, platform = process.platform) {
+export function acquireProjectionRunnerLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
     if (!isProjectionRunnerLockPlatformSupported(platform)) {
         throw new ProjectionRunnerLockUnsupportedError(platform);
     }
@@ -116,30 +204,96 @@ export function acquireProjectionRunnerLock(projectionDirectory, platform = proc
             throw error;
         throw new ProjectionRunnerLockUnavailableError(`projection runner lock database is not initialized: ${errorDetail(error)}`, { cause: error });
     }
-    let database;
+    assertBusyTimeout(busyTimeoutMs);
+    let guard;
     try {
-        database = new DatabaseSync(lockPath);
+        guard = openGuard(lockPath, busyTimeoutMs);
     }
     catch (error) {
         throw new ProjectionRunnerLockUnavailableError(`projection runner lock database could not be opened: ${errorDetail(error)}`, { cause: error });
     }
+    let reservation;
     try {
-        database.exec("PRAGMA busy_timeout=0");
+        reservation = openReservation(lockPath, busyTimeoutMs);
+    }
+    catch (error) {
+        if (reservation)
+            closeTransaction(reservation);
+        closeTransaction(guard);
+        return closeAfterFailedAcquire(guard, error);
+    }
+    return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
+}
+export function acquireProjectionRunnerTransferTarget(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
+    if (!isProjectionRunnerLockPlatformSupported(platform)) {
+        throw new ProjectionRunnerLockUnsupportedError(platform);
+    }
+    assertBusyTimeout(busyTimeoutMs);
+    const lockPath = projectionRunnerLockPath(projectionDirectory);
+    let guard;
+    try {
+        guard = openGuard(lockPath, busyTimeoutMs);
+    }
+    catch (error) {
+        if (guard)
+            closeTransaction(guard);
+        throw new ProjectionRunnerLockUnavailableError(`projection runner transfer acquisition failed: ${errorDetail(error)}`, { cause: error });
+    }
+    let closed = false;
+    return {
+        path: lockPath,
+        promote() {
+            if (closed)
+                throw new ProjectionRunnerLockUnavailableError("projection runner transfer target is closed");
+            let reservation;
+            try {
+                reservation = openReservation(lockPath, busyTimeoutMs);
+            }
+            catch (error) {
+                if (reservation)
+                    closeTransaction(reservation);
+                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer promotion failed: ${errorDetail(error)}`, { cause: error });
+            }
+            closed = true;
+            return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            const failure = closeTransaction(guard);
+            if (failure !== undefined) {
+                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer release failed: ${errorDetail(failure)}`, { cause: failure });
+            }
+        },
+    };
+}
+/** Acquire positive death evidence. Any active guard or transfer blocks this. */
+export function acquireProjectionRunnerSettlementLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
+    if (!isProjectionRunnerLockPlatformSupported(platform)) {
+        throw new ProjectionRunnerLockUnsupportedError(platform);
+    }
+    assertBusyTimeout(busyTimeoutMs);
+    const lockPath = projectionRunnerLockPath(projectionDirectory);
+    let database;
+    try {
+        database = new DatabaseSync(lockPath);
+        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
         database.exec("BEGIN EXCLUSIVE");
+        assertCurrentLockSchema(database);
         if (readJournalMode(database) !== "delete") {
             throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
         }
-        assertCurrentLockSchema(database);
     }
     catch (error) {
         try {
-            database.exec("ROLLBACK");
+            database.close();
         }
-        catch {
-            // A failure before BEGIN has no transaction; a failure after BEGIN is
-            // still released by closeAfterFailedAcquire if rollback cannot run.
+        catch { }
+        if (isSqliteBusy(error)) {
+            throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
         }
-        return closeAfterFailedAcquire(database, error);
+        throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock acquisition failed: ${errorDetail(error)}`, { cause: error });
     }
     let closed = false;
     return {
@@ -148,31 +302,17 @@ export function acquireProjectionRunnerLock(projectionDirectory, platform = proc
             if (closed)
                 return;
             closed = true;
-            let rollbackError;
-            try {
-                database.exec("ROLLBACK");
-            }
-            catch (error) {
-                rollbackError = error;
-            }
-            try {
-                database.close();
-            }
-            catch (error) {
-                rollbackError ??= error;
-            }
-            if (rollbackError !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner lock release failed: ${errorDetail(rollbackError)}`, { cause: rollbackError });
+            const failure = closeTransaction(database);
+            if (failure !== undefined) {
+                throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock release failed: ${errorDetail(failure)}`, { cause: failure });
             }
         },
     };
 }
 /**
- * Probe without creating the lock database. BEGIN DEFERRED itself acquires no
- * file lock, so the sqlite_schema SELECT is mandatory: SQLITE_BUSY there is
- * positive evidence of the runner's EXCLUSIVE transaction. Successful reads
- * hold a compatible SHARED transaction only long enough to verify DELETE
- * journal mode, then roll back. Every other failure remains unknown.
+ * Probe without creating the lock database. BEGIN EXCLUSIVE is the positive
+ * death test: SQLITE_BUSY proves a SHARED guard or RESERVED owner remains;
+ * success proves both are gone. Every other failure remains unknown.
  */
 export function observeProjectionRunnerLock(projectionDirectory, platform = process.platform) {
     if (!isProjectionRunnerLockPlatformSupported(platform)) {
@@ -185,7 +325,7 @@ export function observeProjectionRunnerLock(projectionDirectory, platform = proc
     const lockPath = projectionRunnerLockPath(projectionDirectory);
     let database;
     try {
-        database = new DatabaseSync(lockPath, { readOnly: true });
+        database = new DatabaseSync(lockPath);
     }
     catch (error) {
         return { state: "unknown", reason: "open-failed", detail: errorDetail(error) };
@@ -193,7 +333,7 @@ export function observeProjectionRunnerLock(projectionDirectory, platform = proc
     let transactionOpen = false;
     try {
         database.exec("PRAGMA busy_timeout=0");
-        database.exec("BEGIN DEFERRED");
+        database.exec("BEGIN EXCLUSIVE");
         transactionOpen = true;
         assertCurrentLockSchema(database);
         const journalMode = readJournalMode(database);

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

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../../errno.js";
 import { executionEventsPath, isProjectionId, projectionRoot, } from "./projection-core.js";
@@ -6,10 +6,10 @@ import { readProjectionAlias } from "./projection-alias.js";
 import { ProjectionStateError } from "../atomic-publish.js";
 import { foldPublicProjectionActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { readProjectionTellCounts } from "./tell/store.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 { observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 import { selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
 import { worktreeContainsCoordinate } from "../worktree-path.js";
@@ -63,10 +63,8 @@ function compareProjectionStatusRows(a, b) {
     }
     return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
-export function prioritizeProjectionStatusRows(rows, showAll) {
+export function prioritizeProjectionStatusRows(rows) {
     const ordered = [...rows].sort(compareProjectionStatusRows);
-    if (showAll)
-        return { rows: ordered };
     const visible = ordered.filter((row) => !isOmissibleProjectionStatusState(row.state));
     const byState = {
         failed: 0,
@@ -83,6 +81,9 @@ export function prioritizeProjectionStatusRows(rows, showAll) {
     const total = Object.values(byState).reduce((sum, count) => sum + count, 0);
     return total > 0 ? { rows: visible, omitted: { total, byState } } : { rows: visible };
 }
+export function requiresProjectionStatusDetails(state) {
+    return !isOmissibleProjectionStatusState(state);
+}
 class ProjectionStatusFileError extends Error {
     diagnostic;
     constructor(kind, filePath) {
@@ -168,6 +169,7 @@ function readIdentityFacts(projectionDir, diagnostics) {
             pid: identity.pid,
             akuma: identity.akuma,
             provider: identity.provider,
+            binding: identity.binding,
             mintedAt: identity.mintedAt,
             workspaceRoot: identity.workspaceRoot,
         };
@@ -175,18 +177,18 @@ function readIdentityFacts(projectionDir, diagnostics) {
     catch (error) {
         if (isErrnoException(error) && error.code === "ENOENT") {
             diagnostics.push({ kind: "missing-identity", detail: "heart identity missing" });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         if (error instanceof ProjectionGenerationStoreError) {
             diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         if (error instanceof ProjectionStateError) {
             diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         diagnostics.push({ kind: "unreadable-identity", detail: `heart identity unreadable: ${String(error)}` });
-        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
     }
 }
 function readHeartTellCounts(projectionDir, diagnostics) {
@@ -202,6 +204,22 @@ function readHeartTellCounts(projectionDir, diagnostics) {
         return emptyTellCounts();
     }
 }
+function readPendingTells(projectionDir, diagnostics) {
+    try {
+        // Kanshi is an operator surface: unconsumed tells are actionable facts, not
+        // a count to hide behind. This is one heart read and does not enumerate a
+        // second projection topology.
+        return readPendingTellWindow(projectionDir, Number.MAX_SAFE_INTEGER).window;
+    }
+    catch (error) {
+        if (error instanceof ProjectionGenerationStoreError || error instanceof ProjectionStateError) {
+            diagnostics.push({ kind: "unreadable-tells", detail: error.message });
+            return [];
+        }
+        diagnostics.push({ kind: "unreadable-tells", detail: `heart tells unreadable: ${String(error)}` });
+        return [];
+    }
+}
 function readStoredEvents(projectionDir, executionId, diagnostics) {
     let content;
     let truncated = false;
@@ -284,7 +302,7 @@ function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallb
 function terminalTimestamp(current) {
     return extractTerminalTimestamp(current?.verdict?.facts);
 }
-function readProjectionRow(projectionDir, id, alias, nowMs) {
+function readProjectionSummary(projectionDir, id, alias, nowMs) {
     const diagnostics = [];
     const snapshot = observeProjectionLifeSnapshot(projectionDir, {
         nowMs,
@@ -294,40 +312,73 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         return {
             id,
             ...(alias ? { alias } : {}),
+            projectionDir,
+            snapshot,
+            identityFacts: null,
+            diagnostics,
+            state: "incompatible",
+        };
+    }
+    const identityFacts = readIdentityFacts(projectionDir, diagnostics);
+    const life = snapshot.life;
+    const phase = life.phase;
+    const state = phase === "active" || phase === "quiescent" ? "out" : phase;
+    return {
+        id,
+        ...(alias ? { alias } : {}),
+        projectionDir,
+        snapshot,
+        identityFacts,
+        diagnostics,
+        state,
+    };
+}
+function readProjectionRow(summary, nowMs, readDetails) {
+    const { id, alias, projectionDir, snapshot } = summary;
+    const diagnostics = [...summary.diagnostics];
+    if (snapshot.compatibility === "incompatible") {
+        return {
+            id,
+            observedAtMs: nowMs,
+            ...(alias ? { alias } : {}),
             state: "incompatible",
             observation: snapshot,
             tellCounts: emptyTellCounts(),
             diagnostics,
         };
     }
-    const identityFacts = readIdentityFacts(projectionDir, diagnostics);
-    const tellCounts = identityFacts.identity
-        ? readHeartTellCounts(projectionDir, diagnostics)
-        : emptyTellCounts();
+    const identityFacts = summary.identityFacts;
     if (!identityFacts.identity) {
         const diagnostic = diagnostics.map((entry) => entry.detail).find((detail) => detail !== undefined)
             ?? "projection identity could not be observed";
         return {
             id,
+            observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: "unknown",
             observation: {
                 compatibility: "current",
                 lifecycle: { phase: "unknown", diagnostic },
             },
-            tellCounts,
+            tellCounts: emptyTellCounts(),
             diagnostics,
         };
     }
     const life = snapshot.life;
-    const current = snapshot.records
-        ? selectCurrentGeneration(snapshot.records)
-        : null;
+    const current = snapshot.records ? selectCurrentGeneration(snapshot.records) : null;
     const adoptedAt = current?.adoption?.facts.adoptedAt;
     const adoptedAtMs = typeof adoptedAt === "string"
         ? Date.parse(adoptedAt)
         : Number.NaN;
-    const activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt);
+    const tellCounts = readDetails
+        ? readHeartTellCounts(projectionDir, diagnostics)
+        : emptyTellCounts();
+    const pendingTells = readDetails
+        ? readPendingTells(projectionDir, diagnostics)
+        : [];
+    const activityFacts = readDetails
+        ? readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt)
+        : {};
     const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
     const terminalAt = terminalTimestamp(current);
     const durationAnchorMs = current?.verdict
@@ -348,11 +399,13 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         : undefined;
     return {
         id,
+        observedAtMs: nowMs,
         ...(alias ? { alias } : {}),
         state,
         observation: { compatibility: "current", lifecycle: life },
         akuma: identityFacts.akuma,
         provider: identityFacts.provider,
+        binding: identityFacts.binding,
         pid: identityFacts.pid,
         mintedAt: identityFacts.mintedAt,
         ...(terminalAt ? { terminalAt } : {}),
@@ -362,29 +415,11 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
         ...(terminalFailure ? { terminalFailure } : {}),
         tellCounts,
+        ...(pendingTells.length > 0 ? { pendingTells } : {}),
         diagnostics,
     };
 }
-export async function readProjectionStatusBoard(cwd, nowMs, options = {}) {
-    const root = await projectionRoot(cwd);
-    try {
-        if (!fs.lstatSync(root).isDirectory())
-            return null;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    let entries;
-    try {
-        entries = fs.readdirSync(root);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
+async function readProjectionStatusAliases(cwd, root) {
     const aliases = new Map();
     const aliasRoot = path.join(path.dirname(path.dirname(root)), ".keiyaku", "projection-alias");
     try {
@@ -400,34 +435,122 @@ export async function readProjectionStatusBoard(cwd, nowMs, options = {}) {
         if (!(isErrnoException(error) && error.code === "ENOENT"))
             throw error;
     }
-    const rows = [];
-    for (const akuma of entries.sort()) {
-        if (akuma.startsWith("."))
+    return aliases;
+}
+function readProjectionTopologyEntries(directory) {
+    try {
+        if (!fs.lstatSync(directory).isDirectory())
+            return null;
+        return fs.readdirSync(directory).sort();
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function readProjectionRootTopology(cwd) {
+    const root = await projectionRoot(cwd);
+    const akumas = readProjectionTopologyEntries(root);
+    return akumas ? { root, akumas } : null;
+}
+function readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs) {
+    const akumaDir = path.join(root, akuma);
+    const hexes = readProjectionTopologyEntries(akumaDir);
+    if (!hexes)
+        return null;
+    const summaries = [];
+    for (const hex of hexes) {
+        const id = `${akuma}/${hex}`;
+        const dir = path.join(akumaDir, hex);
+        if (!isProjectionId(id))
             continue;
-        const akumaDir = path.join(root, akuma);
         try {
-            if (!fs.lstatSync(akumaDir).isDirectory())
+            if (!fs.lstatSync(dir).isDirectory())
                 continue;
         }
         catch {
             continue;
         }
-        for (const hex of fs.readdirSync(akumaDir).sort()) {
-            const id = `${akuma}/${hex}`;
-            const dir = path.join(akumaDir, hex);
-            if (!isProjectionId(id))
-                continue;
-            try {
-                if (!fs.lstatSync(dir).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            rows.push(readProjectionRow(dir, id, aliases.get(id), nowMs));
-        }
+        summaries.push(readProjectionSummary(dir, id, aliases.get(id), nowMs));
+    }
+    return summaries;
+}
+function isNonterminalProjectionStatusSummary(summary) {
+    return summary.snapshot.compatibility === "current"
+        && requiresProjectionStatusDetails(summary.state);
+}
+export async function readOperationalProjectionStatusBoard(cwd, nowMs) {
+    const topology = await readProjectionRootTopology(cwd);
+    if (!topology)
+        return null;
+    const { root, akumas } = topology;
+    const aliases = await readProjectionStatusAliases(cwd, root);
+    const summaries = [];
+    for (const akuma of akumas) {
+        if (akuma.startsWith("."))
+            continue;
+        const scoped = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+        // Seeing an entry and then being unable to observe its namespace is not an
+        // observable zero. Keep the whole aggregate surface unavailable.
+        if (scoped === null)
+            return null;
+        summaries.push(...scoped);
+    }
+    const rows = summaries.map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)));
+    // A published root is an observable surface even when it currently has no
+    // rows. The caller must distinguish that fact from an unavailable root.
+    return prioritizeProjectionStatusRows(rows);
+}
+export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
+    if (!isProjectionId(projectionId))
+        return null;
+    const root = await projectionRoot(cwd);
+    try {
+        if (!fs.lstatSync(root).isDirectory())
+            return null;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const [akuma, hex] = projectionId.split("/");
+    const dir = path.join(root, akuma, hex);
+    try {
+        if (!fs.lstatSync(dir).isDirectory())
+            return null;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const aliases = await readProjectionStatusAliases(cwd, root);
+    return readProjectionRow(readProjectionSummary(dir, projectionId, aliases.get(projectionId), nowMs), nowMs, true);
+}
+export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
+    if (!isProjectionId(`${akuma}/00000000`))
+        return null;
+    const root = await projectionRoot(cwd);
+    try {
+        if (!fs.lstatSync(root).isDirectory())
+            return null;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return null;
+        throw error;
     }
-    return rows.length > 0 ? prioritizeProjectionStatusRows(rows, options.showAll === true) : null;
+    const aliases = await readProjectionStatusAliases(cwd, root);
+    const summaries = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+    if (summaries === null)
+        return null;
+    const rows = summaries
+        .filter(isNonterminalProjectionStatusSummary)
+        .map((summary) => readProjectionRow(summary, nowMs, true))
+        .sort(compareProjectionStatusRows);
+    return rows.length > 0 ? { rows } : null;
 }
 /**
  * Renew-only lifecycle guard. Immutable identity is checked before lifecycle,