@astrosheep/keiyaku 2.8.0 → 2.8.1

package/build/core/projection/mint.js

@@ -20,11 +20,21 @@ function assertMintSlug(slug) {
     if (!normalized) {
         throw new ProjectionStateError("projection slug cannot be empty");
     }
-    if (normalized.includes("/") || normalized.includes("\0")) {
+    if (!/^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/.test(normalized)) {
         throw new ProjectionStateError(`invalid projection slug: ${slug}`);
     }
     return normalized;
 }
+function removeEmptyAkumaRoot(dir) {
+    try {
+        fs.rmdirSync(dir);
+    }
+    catch (error) {
+        if (isErrnoException(error) && ["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+            return;
+        throw error;
+    }
+}
 /**
  * Validate mint inputs that can fail, then reserve one private staging directory.
  * Dot-prefixed staging is never a published projection address.
@@ -43,14 +53,19 @@ function reserveProjectionDirectory(input) {
     }
     const root = projectionRoot(input.cwd);
     fs.mkdirSync(root, { recursive: true });
+    const akumaRoot = path.join(root, slug);
+    const createdAkumaRoot = !fs.existsSync(akumaRoot);
+    fs.mkdirSync(akumaRoot, { recursive: true });
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const hex = (input.randomHex?.(attempt) ?? randomHex8()).toLowerCase();
         if (!/^[0-9a-f]{8}$/.test(hex)) {
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
         }
-        const id = `${slug}-${hex}`;
+        const id = `${slug}/${hex}`;
         const dir = projectionDir(input.cwd, id);
-        const stagingDir = path.join(root, `.mint-${id}`);
+        const stagingDir = path.join(akumaRoot, `.mint-${hex}`);
         if (fs.existsSync(dir))
             continue;
         try {
@@ -60,6 +75,8 @@ function reserveProjectionDirectory(input) {
             if (isErrnoException(error) && error.code === "EEXIST") {
                 continue;
             }
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw error;
         }
         if (fs.existsSync(dir)) {
@@ -68,6 +85,8 @@ function reserveProjectionDirectory(input) {
         }
         return { id, dir, stagingDir };
     }
+    if (createdAkumaRoot)
+        removeEmptyAkumaRoot(akumaRoot);
     throw new ProjectionMintCollisionError(`exhausted ${maxAttempts} projection id attempts under ${PROJECTION_ROOT_SEGMENTS.join("/")} (PROJECTION_MINT_COLLISION)`);
 }
 /** Build the identity fields shared by both authority variants. */
@@ -107,6 +126,7 @@ function publishReservedProjection(pact, reserved) {
         if (!published) {
             // Failure removes only this mint's staging.
             fs.rmSync(reserved.stagingDir, { recursive: true, force: true });
+            removeEmptyAkumaRoot(path.dirname(reserved.stagingDir));
         }
     }
 }

package/build/core/projection-alias.js

@@ -0,0 +1,123 @@
+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 { projectionCoordinateRoot } from "./projection-coordinate.js";
+import { isProjectionId } from "./projection-core.js";
+export const PROJECTION_ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const MAX_ALIAS_REF_BYTES = 1024;
+export function isProjectionAlias(value) {
+    return PROJECTION_ALIAS_PATTERN.test(value);
+}
+export function assertProjectionAlias(value) {
+    if (!isProjectionAlias(value)) {
+        throw new ProjectionStateError("projection alias must match ^[a-z0-9][a-z0-9-]{0,63}$");
+    }
+    return value;
+}
+export function projectionAliasRoot(cwd) {
+    return path.join(projectionCoordinateRoot(cwd), ".keiyaku", "projection-alias");
+}
+export function projectionAliasPath(cwd, alias) {
+    assertProjectionAlias(alias);
+    return path.join(projectionAliasRoot(cwd), alias);
+}
+function invalidAliasRef(filePath) {
+    return new ProjectionStateError(`invalid projection alias ref: ${filePath}`);
+}
+function readBoundedRegularAliasRef(filePath) {
+    let before;
+    try {
+        before = fs.lstatSync(filePath);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    if (!before.isFile() || before.size > MAX_ALIAS_REF_BYTES)
+        throw invalidAliasRef(filePath);
+    let fd;
+    try {
+        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ELOOP")
+            throw invalidAliasRef(filePath);
+        throw error;
+    }
+    try {
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile() || opened.size > MAX_ALIAS_REF_BYTES)
+            throw invalidAliasRef(filePath);
+        const bytes = Buffer.alloc(opened.size);
+        const count = fs.readSync(fd, bytes, 0, bytes.length, 0);
+        if (count !== bytes.length)
+            throw invalidAliasRef(filePath);
+        return bytes.toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Undefined means no ref; malformed refs fail closed with their exact sidecar path. */
+export function readProjectionAlias(cwd, alias) {
+    const filePath = projectionAliasPath(cwd, alias);
+    const content = readBoundedRegularAliasRef(filePath);
+    if (content === undefined)
+        return undefined;
+    if (!content.endsWith("\n") || content.indexOf("\n") !== content.length - 1)
+        throw invalidAliasRef(filePath);
+    const id = content.slice(0, -1);
+    if (!isProjectionId(id))
+        throw invalidAliasRef(filePath);
+    return id;
+}
+/** Atomically replace one alias ref. Aliases intentionally have no multi-ref transaction. */
+export 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);
+    fs.mkdirSync(root, { recursive: true });
+    const target = projectionAliasPath(cwd, alias);
+    let temp;
+    try {
+        for (let attempt = 0; attempt < 16; attempt += 1) {
+            const candidate = path.join(root, `.tmp.${randomHex8()}`);
+            try {
+                const fd = fs.openSync(candidate, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+                temp = candidate;
+                try {
+                    fs.writeFileSync(fd, `${id}\n`, "utf8");
+                    fs.fsyncSync(fd);
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                break;
+            }
+            catch (error) {
+                if (isErrnoException(error) && error.code === "EEXIST")
+                    continue;
+                throw error;
+            }
+        }
+        if (!temp)
+            throw new ProjectionStateError(`failed to create projection alias temp: ${target}`);
+        fs.renameSync(temp, target);
+        const directoryFd = fs.openSync(root, fs.constants.O_RDONLY);
+        try {
+            fs.fsyncSync(directoryFd);
+        }
+        finally {
+            fs.closeSync(directoryFd);
+        }
+    }
+    finally {
+        if (temp)
+            fs.rmSync(temp, { force: true });
+    }
+    return previous;
+}

package/build/core/projection-coordinate.js

@@ -2,13 +2,13 @@ import { spawnSync } from "node:child_process";
 import * as path from "node:path";
 import { ProjectionStateError } from "./atomic-publish.js";
 /**
- * Select the filesystem authority for repository projection state.
+ * 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 function projectionCoordinateRoot(cwd) {
+export function resolveProjectionCoordinate(cwd) {
     const result = spawnSync("git", ["rev-parse", "--is-bare-repository", "--path-format=absolute", "--git-common-dir"], {
         cwd,
         encoding: "utf8",
@@ -24,12 +24,28 @@ export function projectionCoordinateRoot(cwd) {
     }
     if (result.status !== 0) {
         const detail = result.stderr.trim();
-        if (detail.includes("not a git repository"))
-            return cwd;
+        if (detail.includes("not a git repository")) {
+            return { physicalRoot: cwd, authority: { kind: "user" } };
+        }
         throw new ProjectionStateError(`cannot resolve projection repository coordinate${detail ? `: ${detail}` : ` (git exited ${String(result.status)})`}`);
     }
     const [bare, commonDir] = result.stdout.trim().split(/\r?\n/);
-    if (bare !== "false" || !commonDir || !path.isAbsolute(commonDir))
-        return cwd;
-    return path.dirname(commonDir);
+    if (bare !== "false" || !commonDir || !path.isAbsolute(commonDir)) {
+        return { physicalRoot: cwd, authority: { kind: "user" } };
+    }
+    const physicalRoot = path.dirname(commonDir);
+    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 function projectionCoordinateRoot(cwd) {
+    return resolveProjectionCoordinate(cwd).physicalRoot;
 }

package/build/core/projection-core.js

@@ -3,16 +3,22 @@ import * as path from "node:path";
 import { isErrnoException } from "../errno.js";
 import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "./atomic-publish.js";
-import { readProjectionIdentity } from "./projection-identity.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "./atomic-publish.js";
 export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, isTellCausallyConsumed, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./projection-tells.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 function projectionDir(cwd, id) {
-    return path.join(projectionRoot(cwd), id);
+    if (!isProjectionId(id))
+        throw new ProjectionStateError(`invalid projection id: ${id}`);
+    const [akuma, hex] = id.split("/");
+    return path.join(projectionRoot(cwd), akuma, hex);
 }
 export function encodeProjectionJson(value) {
     return `${JSON.stringify(value)}\n`;
@@ -32,51 +38,6 @@ export function isPublishedProjection(dir) {
         return false;
     }
 }
-/** readdir-based address resolution. Atomic mint rename makes every visible non-dot directory published. */
-export function resolveProjectionPrefix(cwd, prefix, commissionId) {
-    const needle = prefix.trim();
-    if (!needle) {
-        return { status: "none" };
-    }
-    const root = projectionRoot(cwd);
-    let entries;
-    try {
-        entries = fs.readdirSync(root);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return { status: "none" };
-        }
-        throw error;
-    }
-    const publishedIds = entries
-        .filter((id) => {
-        if (id.startsWith("."))
-            return false;
-        const directory = path.join(root, id);
-        return isPublishedProjection(directory);
-    })
-        .sort();
-    const addressed = publishedIds.filter((id) => {
-        if (id === needle || id.startsWith(needle))
-            return true;
-        const suffix = /-([0-9a-f]{8})$/.exec(id)?.[1];
-        return suffix === needle;
-    });
-    const candidates = commissionId === undefined
-        ? addressed
-        : addressed.filter((id) => {
-            const identity = readProjectionIdentity(path.join(root, id));
-            return identity.binding.kind === "commission" && identity.binding.commissionId === commissionId;
-        });
-    if (candidates.length === 1) {
-        return { status: "resolved", id: candidates[0] };
-    }
-    if (candidates.length === 0) {
-        return { status: "none" };
-    }
-    return { status: "ambiguous", candidates };
-}
 const PROJECTION_EXECUTION_ID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
 function assertProjectionExecutionId(executionId) {
     if (!PROJECTION_EXECUTION_ID_PATTERN.test(executionId)) {

package/build/core/projection-mint.js

@@ -19,11 +19,21 @@ function assertMintSlug(slug) {
     if (!normalized) {
         throw new ProjectionStateError("projection slug cannot be empty");
     }
-    if (normalized.includes("/") || normalized.includes("\0")) {
+    if (!/^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/.test(normalized)) {
         throw new ProjectionStateError(`invalid projection slug: ${slug}`);
     }
     return normalized;
 }
+function removeEmptyAkumaRoot(dir) {
+    try {
+        fs.rmdirSync(dir);
+    }
+    catch (error) {
+        if (isErrnoException(error) && ["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+            return;
+        throw error;
+    }
+}
 /**
  * Validate mint inputs that can fail, then reserve one private staging directory.
  * Dot-prefixed staging is never a published projection address.
@@ -42,14 +52,19 @@ function reserveProjectionDirectory(input) {
     }
     const root = projectionRoot(input.cwd);
     fs.mkdirSync(root, { recursive: true });
+    const akumaRoot = path.join(root, slug);
+    const createdAkumaRoot = !fs.existsSync(akumaRoot);
+    fs.mkdirSync(akumaRoot, { recursive: true });
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const hex = (input.randomHex?.(attempt) ?? randomHex8()).toLowerCase();
         if (!/^[0-9a-f]{8}$/.test(hex)) {
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
         }
-        const id = `${slug}-${hex}`;
+        const id = `${slug}/${hex}`;
         const dir = projectionDir(input.cwd, id);
-        const stagingDir = path.join(root, `.mint-${id}`);
+        const stagingDir = path.join(akumaRoot, `.mint-${hex}`);
         if (fs.existsSync(dir))
             continue;
         try {
@@ -59,6 +74,8 @@ function reserveProjectionDirectory(input) {
             if (isErrnoException(error) && error.code === "EEXIST") {
                 continue;
             }
+            if (createdAkumaRoot)
+                removeEmptyAkumaRoot(akumaRoot);
             throw error;
         }
         if (fs.existsSync(dir)) {
@@ -67,6 +84,8 @@ function reserveProjectionDirectory(input) {
         }
         return { id, dir, stagingDir };
     }
+    if (createdAkumaRoot)
+        removeEmptyAkumaRoot(akumaRoot);
     throw new ProjectionMintCollisionError(`exhausted ${maxAttempts} projection id attempts under ${PROJECTION_ROOT_SEGMENTS.join("/")} (PROJECTION_MINT_COLLISION)`);
 }
 /** Build the pact fields shared by both authority variants. */
@@ -104,6 +123,8 @@ function publishReservedProjection(pact, reserved) {
     finally {
         if (!published) {
             fs.rmSync(reserved.stagingDir, { recursive: true, force: true });
+            const parent = path.dirname(reserved.stagingDir);
+            removeEmptyAkumaRoot(parent);
         }
     }
 }

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

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 export const PROJECTION_RUNNER_LOCK_DATABASE = "leash";
 const SQLITE_BUSY = 5;
-const SUPPORTED_PLATFORMS = new Set(["darwin", "linux"]);
+const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"]);
 export class ProjectionRunnerLockUnavailableError extends Error {
     code = "PROJECTION_RUNNER_LOCK_UNAVAILABLE";
     constructor(message, options) {

package/build/core/projection-status.js

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../errno.js";
-import { executionEventsPath, projectionRoot, } from "./projection-core.js";
+import { executionEventsPath, isProjectionId, projectionRoot, } from "./projection-core.js";
+import { readProjectionAlias } from "./projection-alias.js";
 import { ProjectionStateError } from "./atomic-publish.js";
 import { foldAgentActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
@@ -12,6 +13,73 @@ import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { selectCurrentGeneration } from "./projection-life-protocol.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "./stored-agent-event.js";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
+export const DEFAULT_PROJECTION_STATUS_ROW_BUDGET = 20;
+const STATUS_GROUP = {
+    "startup-timeout": 0,
+    lost: 0,
+    unknown: 0,
+    minting: 1,
+    out: 1,
+    failed: 2,
+    dead: 2,
+    done: 3,
+    dismissed: 4,
+};
+function isOmissibleProjectionStatusState(state) {
+    return state === "failed" || state === "dead" || state === "done" || state === "dismissed";
+}
+function rowSortTime(row) {
+    if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
+        return row.activityAtMs;
+    }
+    if (row.mintedAt !== undefined) {
+        const mintedAtMs = Date.parse(row.mintedAt);
+        if (Number.isFinite(mintedAtMs))
+            return mintedAtMs;
+    }
+    return Number.NEGATIVE_INFINITY;
+}
+function compareProjectionStatusRows(a, b) {
+    const groupDifference = STATUS_GROUP[a.state] - STATUS_GROUP[b.state];
+    if (groupDifference !== 0)
+        return groupDifference;
+    const aTime = rowSortTime(a);
+    const bTime = rowSortTime(b);
+    if (aTime !== bTime) {
+        if (aTime === Number.NEGATIVE_INFINITY)
+            return 1;
+        if (bTime === Number.NEGATIVE_INFINITY)
+            return -1;
+        return bTime - aTime;
+    }
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+export function prioritizeProjectionStatusRows(rows, showAll) {
+    const ordered = [...rows].sort(compareProjectionStatusRows);
+    if (showAll)
+        return { rows: ordered };
+    const protectedCount = ordered.filter((row) => STATUS_GROUP[row.state] < 2).length;
+    let terminalBudget = Math.max(0, DEFAULT_PROJECTION_STATUS_ROW_BUDGET - protectedCount);
+    const visible = [];
+    const byState = {
+        failed: 0,
+        dead: 0,
+        done: 0,
+        dismissed: 0,
+    };
+    for (const row of ordered) {
+        if (STATUS_GROUP[row.state] < 2 || terminalBudget > 0) {
+            visible.push(row);
+            if (STATUS_GROUP[row.state] >= 2)
+                terminalBudget -= 1;
+            continue;
+        }
+        if (isOmissibleProjectionStatusState(row.state))
+            byState[row.state] += 1;
+    }
+    const total = Object.values(byState).reduce((sum, count) => sum + count, 0);
+    return total > 0 ? { rows: visible, omitted: { total, byState } } : { rows: visible };
+}
 class ProjectionStatusFileError extends Error {
     diagnostic;
     constructor(kind, filePath) {
@@ -198,7 +266,7 @@ function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallb
             : {}),
     };
 }
-function readProjectionRow(projectionDir, id, nowMs) {
+function readProjectionRow(projectionDir, id, alias, nowMs) {
     const diagnostics = [];
     const identityFacts = readIdentityFacts(projectionDir, diagnostics);
     const tellCounts = identityFacts.identity
@@ -232,6 +300,7 @@ function readProjectionRow(projectionDir, id, nowMs) {
     const state = phase === "active" || phase === "quiescent" ? "out" : phase;
     return {
         id,
+        ...(alias ? { alias } : {}),
         state,
         akuma: identityFacts.akuma,
         provider: identityFacts.provider,
@@ -243,7 +312,7 @@ function readProjectionRow(projectionDir, id, nowMs) {
         diagnostics,
     };
 }
-export function readProjectionStatusBoard(cwd, nowMs) {
+export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
     const root = projectionRoot(cwd);
     try {
         if (!fs.lstatSync(root).isDirectory())
@@ -263,17 +332,47 @@ export function readProjectionStatusBoard(cwd, nowMs) {
             return null;
         throw error;
     }
-    const rows = entries
-        .filter((entry) => !entry.startsWith("."))
-        .filter((entry) => {
+    const aliases = new Map();
+    const aliasRoot = path.join(path.dirname(path.dirname(root)), ".keiyaku", "projection-alias");
+    try {
+        for (const alias of fs.readdirSync(aliasRoot).sort()) {
+            if (alias.startsWith("."))
+                continue;
+            const id = readProjectionAlias(cwd, alias);
+            if (id)
+                aliases.set(id, alias);
+        }
+    }
+    catch (error) {
+        if (!(isErrnoException(error) && error.code === "ENOENT"))
+            throw error;
+    }
+    const rows = [];
+    for (const akuma of entries.sort()) {
+        if (akuma.startsWith("."))
+            continue;
+        const akumaDir = path.join(root, akuma);
         try {
-            return fs.lstatSync(path.join(root, entry)).isDirectory();
+            if (!fs.lstatSync(akumaDir).isDirectory())
+                continue;
         }
         catch {
-            return false;
+            continue;
         }
-    })
-        .sort()
-        .map((id) => readProjectionRow(path.join(root, id), id, nowMs));
-    return rows.length > 0 ? { rows } : null;
+        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));
+        }
+    }
+    return rows.length > 0 ? prioritizeProjectionStatusRows(rows, options.showAll === true) : null;
 }

package/build/core/response-artifact-id.js

@@ -0,0 +1,5 @@
+/** Neutral response-artifact identity grammar. Sole production regex for rsp_<ULID>. */
+export const RESPONSE_ARTIFACT_ID_RE = /^rsp_[0-9A-HJKMNP-TV-Z]{26}$/;
+export function isResponseArtifactId(value) {
+    return RESPONSE_ARTIFACT_ID_RE.test(value);
+}

package/build/core/status.js

@@ -528,7 +528,7 @@ export async function readKanshiBoard(cwd, now, opts) {
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
     return {
         contracts: filteredContracts,
-        projections: readProjectionStatusBoard(cwd, now),
+        projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,