@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/scope.js

@@ -1,4 +1,8 @@
-const ILLEGAL_PATTERN_TOKENS = ["!", "{", "}", "?", "[", "]"];
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createGit, wrapGitError } from "../git/core.js";
 export class ScopePatternError extends Error {
     code = "INVALID_SCOPE_PATTERN";
     constructor(message) {
@@ -6,158 +10,203 @@ export class ScopePatternError extends Error {
         this.name = "ScopePatternError";
     }
 }
-function normalizeSeparators(value) {
-    return value.replace(/\\/g, "/").replace(/\/+/g, "/");
-}
-function assertAllowedPattern(pattern) {
-    const found = ILLEGAL_PATTERN_TOKENS.find((token) => pattern.includes(token));
-    if (found) {
-        throw new ScopePatternError(`scope pattern '${pattern}' uses unsupported token '${found}'`);
+/**
+ * Gitignore trailing spaces are ignored unless escaped with a backslash.
+ * Preserve `\ ` (and longer odd-backslash runs) while stripping only unescaped
+ * trailing SPACE characters. Tabs and other trailing whitespace stay as written.
+ */
+function stripUnescapedTrailingSpaces(value) {
+    let end = value.length;
+    while (end > 0 && value[end - 1] === " ") {
+        let backslashes = 0;
+        for (let index = end - 2; index >= 0 && value[index] === "\\"; index -= 1) {
+            backslashes += 1;
+        }
+        if (backslashes % 2 === 1)
+            break;
+        end -= 1;
     }
+    return value.slice(0, end);
+}
+/**
+ * Drop cosmetic framing whitespace without destroying escaped trailing spaces.
+ * Leading whitespace is always cosmetic for scope entry; trailing SPACE follows
+ * gitignore escape rules.
+ */
+function canonicalizeScopePatternInput(pattern) {
+    return stripUnescapedTrailingSpaces(pattern.replace(/^\s+/, ""));
 }
+/** True when a raw Scope Add / list line has no pattern after gitignore blank rules. */
+export function isBlankScopePatternLine(line) {
+    return canonicalizeScopePatternInput(line).length === 0;
+}
+/**
+ * Canonicalize a scope gitignore pattern for exclude matching and persistence.
+ * Strips only a cosmetic leading `./` (including after `!`); preserves meaningful
+ * leading `/` anchoring, gitignore backslash escapes, and escaped trailing spaces.
+ */
 export function normalizeScopePattern(pattern) {
-    const trimmed = normalizeSeparators(pattern.trim()).replace(/^\.\/+/, "").replace(/^\/+/, "");
-    if (!trimmed) {
-        throw new ScopePatternError("scope pattern cannot be empty");
+    if (pattern.includes("\0") || pattern.includes("\n") || pattern.includes("\r")) {
+        throw new ScopePatternError("scope pattern must fit on one line and cannot contain NUL");
     }
-    assertAllowedPattern(trimmed);
-    if (trimmed.endsWith("/")) {
-        return `${trimmed}**`;
+    const trimmed = canonicalizeScopePatternInput(pattern);
+    if (!trimmed)
+        throw new ScopePatternError("scope pattern cannot be empty");
+    const negative = trimmed.startsWith("!");
+    let body = negative ? trimmed.slice(1) : trimmed;
+    while (body.startsWith("./")) {
+        body = body.slice(2);
     }
-    return trimmed;
+    if (!body)
+        throw new ScopePatternError("scope pattern cannot be empty");
+    return negative ? `!${body}` : body;
 }
-export function normalizeScopePath(path) {
-    const normalized = normalizeSeparators(path.trim()).replace(/^\.\/+/, "").replace(/^\/+/, "");
-    if (!normalized) {
-        throw new ScopePatternError("scope path cannot be empty");
+/**
+ * Normalize a path to Git diff form for exact waiver comparison:
+ * either slash convention, collapse separators, and strip cosmetic `./` or `/`.
+ * Leading and trailing spaces are significant path bytes and must remain unchanged.
+ */
+export function normalizeScopePath(filePath) {
+    let normalized = filePath.replace(/\\/g, "/").replace(/\/+/g, "/");
+    while (normalized.startsWith("./")) {
+        normalized = normalized.slice(2);
     }
+    normalized = normalized.replace(/^\/+/, "");
+    if (!normalized || normalized === ".")
+        throw new ScopePatternError("scope path cannot be empty");
+    if (normalized.includes("\0"))
+        throw new ScopePatternError("scope path cannot contain NUL");
     return normalized;
 }
-function splitPattern(pattern) {
-    return normalizeScopePattern(pattern).split("/");
+function runCheckIgnore(gitDir, workTree, cwd, paths) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("git", [
+            `--git-dir=${gitDir}`,
+            `--work-tree=${workTree}`,
+            "check-ignore",
+            "--no-index",
+            "-z",
+            "--stdin",
+        ], {
+            cwd,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: "0",
+                GCM_INTERACTIVE: "Never",
+                GIT_CONFIG_GLOBAL: "/dev/null",
+                GIT_CONFIG_NOSYSTEM: "1",
+                LC_ALL: "C",
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.stdin.on("error", reject);
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code !== 0 && code !== 1) {
+                reject(wrapGitError("check-ignore --no-index -z --stdin", {
+                    message: `git check-ignore exited with status ${code ?? "unknown"}`,
+                    stderr: Buffer.concat(stderr).toString("utf8"),
+                    stdout: Buffer.concat(stdout).toString("utf8"),
+                }, cwd));
+                return;
+            }
+            resolve(new Set(Buffer.concat(stdout)
+                .toString("utf8")
+                .split("\0")
+                .filter(Boolean)));
+        });
+        child.stdin.end(`${paths.join("\0")}\0`);
+    });
 }
-function splitPath(path) {
-    return normalizeScopePath(path).split("/");
+export async function pathsMatchingScope(cwd, patterns, filePaths) {
+    const normalizedPatterns = patterns.map(normalizeScopePattern);
+    const normalizedPaths = filePaths.map(normalizeScopePath);
+    if (normalizedPatterns.length === 0 || normalizedPaths.length === 0)
+        return new Set();
+    const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-scope-"));
+    const gitDir = path.join(temporaryRoot, "scope.git");
+    const workTree = path.join(temporaryRoot, "worktree");
+    try {
+        await Promise.all([fs.mkdir(gitDir), fs.mkdir(workTree)]);
+        await createGit(gitDir).init(true);
+        await fs.writeFile(path.join(gitDir, "info", "exclude"), `${normalizedPatterns.join("\n")}\n`, "utf8");
+        return await runCheckIgnore(gitDir, workTree, cwd, normalizedPaths);
+    }
+    finally {
+        await fs.rm(temporaryRoot, { recursive: true, force: true });
+    }
+}
+export function isNegativeScopePattern(pattern) {
+    return normalizeScopePattern(pattern).startsWith("!");
+}
+/**
+ * Parse only the subset whose path language can be proved statically: literal
+ * segments, `*` segments, and `**` segments. Anything using richer gitignore
+ * syntax is left to Git and produces no advisory warning.
+ */
+function staticScopeSegments(pattern) {
+    const positive = normalizeScopePattern(pattern);
+    if (positive.startsWith("!") || positive.startsWith("#"))
+        return null;
+    const body = positive.startsWith("/") ? positive.slice(1) : positive;
+    if (!body || body.endsWith("/"))
+        return null;
+    const parsed = [];
+    for (const segment of body.split("/")) {
+        if (!segment || segment === "." || segment === "..")
+            return null;
+        if (segment === "*")
+            parsed.push({ kind: "one" });
+        else if (segment === "**")
+            parsed.push({ kind: "many" });
+        else if (/[*?\[\]\\]/.test(segment))
+            return null;
+        else
+            parsed.push({ kind: "literal", value: segment });
+    }
+    return parsed;
 }
-function segmentMatchesPattern(patternSegment, pathSegment) {
-    if (patternSegment === "**")
+function ordinarySegmentsIntersect(a, b) {
+    if (a.kind === "many" || b.kind === "many")
         return true;
-    if (patternSegment === "*")
+    if (a.kind === "one" || b.kind === "one")
         return true;
-    let regexSource = "^";
-    for (const char of patternSegment) {
-        if (char === "*") {
-            regexSource += ".*";
-            continue;
-        }
-        regexSource += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-    }
-    regexSource += "$";
-    return new RegExp(regexSource).test(pathSegment);
+    return a.value === b.value;
 }
-function segmentPatternsOverlap(a, b) {
-    const memo = new Map();
-    const visit = (aIndex, bIndex) => {
+/** Exact non-empty intersection for the finite segment-language subset above. */
+function staticSegmentLanguagesOverlap(a, b) {
+    const pending = [[0, 0]];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const [aIndex, bIndex] = pending.pop();
         const key = `${aIndex}:${bIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        let result = false;
-        if (aIndex === a.length && bIndex === b.length) {
-            result = true;
-        }
-        else if (aIndex < a.length && a[aIndex] === "*") {
-            result =
-                visit(aIndex + 1, bIndex) ||
-                    (bIndex < b.length && visit(aIndex, bIndex + 1));
-        }
-        else if (bIndex < b.length && b[bIndex] === "*") {
-            result =
-                visit(aIndex, bIndex + 1) ||
-                    (aIndex < a.length && visit(aIndex + 1, bIndex));
-        }
-        else if (aIndex < a.length && bIndex < b.length && a[aIndex] === b[bIndex]) {
-            result = visit(aIndex + 1, bIndex + 1);
-        }
-        memo.set(key, result);
-        return result;
-    };
-    return visit(0, 0);
-}
-function canPatternMatchEmpty(segments, index) {
-    for (let cursor = index; cursor < segments.length; cursor += 1) {
-        if (segments[cursor] !== "**")
-            return false;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (aIndex === a.length && bIndex === b.length)
+            return true;
+        const aSegment = a[aIndex];
+        const bSegment = b[bIndex];
+        if (aSegment?.kind === "many")
+            pending.push([aIndex + 1, bIndex]);
+        if (bSegment?.kind === "many")
+            pending.push([aIndex, bIndex + 1]);
+        if (!aSegment || !bSegment || !ordinarySegmentsIntersect(aSegment, bSegment))
+            continue;
+        pending.push([
+            aSegment.kind === "many" ? aIndex : aIndex + 1,
+            bSegment.kind === "many" ? bIndex : bIndex + 1,
+        ]);
     }
-    return true;
-}
-export function pathMatches(pattern, path) {
-    const patternSegments = splitPattern(pattern);
-    const pathSegments = splitPath(path);
-    const memo = new Map();
-    const visit = (patternIndex, pathIndex) => {
-        const key = `${patternIndex}:${pathIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        let result = false;
-        if (patternIndex === patternSegments.length && pathIndex === pathSegments.length) {
-            result = true;
-        }
-        else if (patternIndex === patternSegments.length) {
-            result = false;
-        }
-        else if (patternSegments[patternIndex] === "**") {
-            result =
-                visit(patternIndex + 1, pathIndex) ||
-                    (pathIndex < pathSegments.length && visit(patternIndex, pathIndex + 1));
-        }
-        else if (pathIndex < pathSegments.length) {
-            result =
-                segmentMatchesPattern(patternSegments[patternIndex], pathSegments[pathIndex]) &&
-                    visit(patternIndex + 1, pathIndex + 1);
-        }
-        memo.set(key, result);
-        return result;
-    };
-    return visit(0, 0);
+    return false;
 }
+/** Advisory only: negative patterns are exclusions, and are intentionally ignored here. */
 export function patternsOverlap(a, b) {
-    const aSegments = splitPattern(a);
-    const bSegments = splitPattern(b);
-    const memo = new Map();
-    const visit = (aIndex, bIndex) => {
-        const key = `${aIndex}:${bIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        let result = false;
-        if (aIndex === aSegments.length && bIndex === bSegments.length) {
-            result = true;
-        }
-        else if (aIndex === aSegments.length) {
-            result = canPatternMatchEmpty(bSegments, bIndex);
-        }
-        else if (bIndex === bSegments.length) {
-            result = canPatternMatchEmpty(aSegments, aIndex);
-        }
-        else if (aSegments[aIndex] === "**") {
-            result =
-                visit(aIndex + 1, bIndex) ||
-                    (bSegments[bIndex] !== "**" && visit(aIndex, bIndex + 1));
-        }
-        else if (bSegments[bIndex] === "**") {
-            result =
-                visit(aIndex, bIndex + 1) ||
-                    (aSegments[aIndex] !== "**" && visit(aIndex + 1, bIndex));
-        }
-        else {
-            result =
-                segmentPatternsOverlap(aSegments[aIndex], bSegments[bIndex]) &&
-                    visit(aIndex + 1, bIndex + 1);
-        }
-        memo.set(key, result);
-        return result;
-    };
-    return visit(0, 0);
+    const aSegments = staticScopeSegments(a);
+    const bSegments = staticScopeSegments(b);
+    return aSegments !== null && bSegments !== null && staticSegmentLanguagesOverlap(aSegments, bSegments);
 }

package/build/core/seal.js

@@ -5,7 +5,7 @@ import { createGit, wrapGitError } from "../git/core.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { renderContractView } from "./render.js";
-import { pathMatches } from "./scope.js";
+import { normalizeScopePath, pathsMatchingScope } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status.js";
 function findBind(entries) {
     const bind = entries.find((entry) => entry.kind === "bind");
@@ -46,14 +46,8 @@ export function effectiveScope(entries) {
     for (const entry of entries) {
         if (entry.kind !== "amend" || !entry.data.scopeDelta)
             continue;
-        const remove = new Set(entry.data.scopeDelta.remove);
-        for (let index = scope.length - 1; index >= 0; index -= 1) {
-            if (remove.has(scope[index]))
-                scope.splice(index, 1);
-        }
         for (const pattern of entry.data.scopeDelta.add) {
-            if (!scope.includes(pattern))
-                scope.push(pattern);
+            scope.push(pattern);
         }
     }
     return scope;
@@ -82,9 +76,8 @@ async function revList(cwd, from, to) {
 async function changedPaths(cwd, from, to) {
     const git = createGit(cwd);
     try {
-        return (await git.raw(["diff", "--name-only", `${from}..${to}`]))
-            .split(/\r?\n/)
-            .map((line) => line.trim())
+        return (await git.raw(["diff", "--name-only", "-z", `${from}..${to}`]))
+            .split("\0")
             .filter(Boolean);
     }
     catch (error) {
@@ -109,8 +102,10 @@ async function diffstat(cwd, from, to) {
         throw wrapGitError(`diff --numstat ${from}..${to}`, error, cwd);
     }
 }
-function scopeViolations(paths, scope) {
-    return paths.filter((changedPath) => changedPath !== KEIYAKU_FILE && !scope.some((pattern) => pathMatches(pattern, changedPath)));
+async function scopeViolations(cwd, paths, scope) {
+    const auditedPaths = paths.filter((changedPath) => changedPath !== KEIYAKU_FILE);
+    const matched = await pathsMatchingScope(cwd, scope, auditedPaths);
+    return auditedPaths.filter((changedPath) => !matched.has(changedPath));
 }
 function assertOperable(contractId, entries) {
     const state = deriveContractState(entries);
@@ -121,7 +116,7 @@ function assertOperable(contractId, entries) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot seal from state ${state.state}`);
     }
 }
-export async function captureSeal(cwd, entries, head = "HEAD") {
+export async function captureSeal(cwd, entries, head = "HEAD", waivePaths = []) {
     const open = findOpenArc(entries);
     if (!open)
         return null;
@@ -133,9 +128,11 @@ export async function captureSeal(cwd, entries, head = "HEAD") {
         diffstat(cwd, oldFence, newFence),
     ]);
     const scope = effectiveScope(entries);
-    const violations = scopeViolations(paths, scope);
-    if (violations.length > 0) {
-        throw new FlowError("INTERNAL_STATE", `scope audit failed for contract ${open.contract}: paths ${violations.join(", ")} outside ${scope.join(", ")}`);
+    const violations = await scopeViolations(cwd, paths, scope);
+    const waivedPaths = new Set(waivePaths.map(normalizeScopePath));
+    const unwaived = violations.filter((violation) => !waivedPaths.has(violation));
+    if (unwaived.length > 0) {
+        throw new FlowError("INTERNAL_STATE", `scope audit failed for contract ${open.contract}: paths ${unwaived.join(", ")} outside ${scope.join(", ")}`);
     }
     return {
         arc: open.data.arc,
@@ -143,7 +140,7 @@ export async function captureSeal(cwd, entries, head = "HEAD") {
         newFence,
         receipts,
         diffstat: stat,
-        scopeAudit: { violations, waived: false },
+        scopeAudit: { violations, waived: violations.length > 0 },
     };
 }
 async function renderUpdatedContract(ledgerCwd, renderCwd, contractId) {
@@ -159,7 +156,7 @@ export async function sealOpenArc(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertOperable(input.contractId, ledger.entries);
-    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries);
+    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries, "HEAD", input.waivePaths);
     if (!capture)
         return null;
     const at = new Date(input.nowMs).toISOString();

package/build/core/status.js

@@ -3,12 +3,22 @@ import * as path from "node:path";
 import { assertSettingsKnobUsable, loadKeiyakuSettings, } from "../config/settings.js";
 import { FlowError } from "../flow-error.js";
 import { SETTINGS_FILE } from "../keiyaku.js";
+import { isGitRepo } from "../git/branches.js";
 import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
-import { readLedger } from "./ledger.js";
+import { fullBranchRefSchema } from "./entry.js";
+import { listContractIds, readLedger } from "./ledger.js";
 import { readProjectionStatusBoard } from "./projection-status.js";
-import { queuePositionsFromEntries, queuedContracts, readQueue } from "./queue.js";
+import { deriveQueueReadModel, queueMembership, } from "./queue_v2.js";
 import { findOpenArc, getMaxArc, receiptsAfterFence } from "./seal.js";
 import { stableRepoRoot } from "./worktree-path.js";
+/** Prefix bare branch names and validate the full ref. Sole status/bind normalizer. */
+export function normalizeTargetRef(raw) {
+    const ref = raw.startsWith("refs/heads/") ? raw : `refs/heads/${raw}`;
+    if (!fullBranchRefSchema.safeParse(ref).success) {
+        throw new FlowError("INVALID_TARGET", `invalid target ref '${raw}' — pass a branch name or refs/heads/<name>`);
+    }
+    return ref;
+}
 function transitionFromEntry(current, entry) {
     if (current === "claimed" || current === "forfeited" || current === "corrupt") {
         return "corrupt";
@@ -16,6 +26,9 @@ function transitionFromEntry(current, entry) {
     switch (entry.kind) {
         case "bind":
             return "corrupt";
+        case "bootstrap":
+            // Placement legality is owned exclusively by deriveContractState.
+            return "corrupt";
         case "arc":
             return current === "bound" || current === "active" ? "active" : "corrupt";
         case "seal":
@@ -41,9 +54,20 @@ export function deriveContractState(entries) {
     if (entries.length === 0 || entries[0]?.kind !== "bind") {
         return { state: "corrupt", at: 0, reason: "ledger must start with bind" };
     }
+    const bind = entries[0];
     let state = "bound";
     for (let index = 1; index < entries.length; index += 1) {
         const entry = entries[index];
+        if (entry.kind === "bootstrap") {
+            if (index !== 1 || state !== "bound") {
+                return { state: "corrupt", at: index + 1, reason: "bootstrap must immediately follow bind" };
+            }
+            if (!bind.data.bootstrap) {
+                return { state: "corrupt", at: index + 1, reason: "bootstrap without bind plan" };
+            }
+            // Legal bootstrap is a durable fact and leaves the derived state bound.
+            continue;
+        }
         const next = transitionFromEntry(state, entry);
         if (next === "corrupt") {
             return { state: "corrupt", at: index + 1, reason: `invalid ${entry.kind} after ${state}` };
@@ -52,6 +76,14 @@ export function deriveContractState(entries) {
     }
     return { state };
 }
+export function deriveBootstrapDiagnostics(entries) {
+    const bind = entries.find((entry) => entry.kind === "bind");
+    if (!bind?.data.bootstrap)
+        return [];
+    if (entries.some((entry) => entry.kind === "bootstrap"))
+        return [];
+    return [{ kind: "plan-without-result" }];
+}
 export function isTerminalState(state) {
     return state.state === "claimed" || state.state === "forfeited";
 }
@@ -79,20 +111,16 @@ export function latestBase(entries) {
     }
     return entries.find((entry) => entry.kind === "bind")?.data.base;
 }
-export async function listContractIds(cwd) {
-    const git = createGit(cwd);
-    const refPrefix = "refs/keiyaku/active/";
-    try {
-        const output = await git.raw(["for-each-ref", "--format=%(refname)", refPrefix]);
-        return output
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line.startsWith(refPrefix))
-            .map((ref) => ref.slice(refPrefix.length));
-    }
-    catch (error) {
-        throw wrapGitError(`for-each-ref ${refPrefix}`, error, cwd);
-    }
+/** Commission settlement target from the bind entry. Schema guarantees refs/heads/<name>. */
+export function commissionTarget(entries) {
+    const bind = findBindEntry(entries);
+    if (!bind)
+        return undefined;
+    const ref = bind.data.target;
+    return {
+        ref,
+        branch: ref.slice("refs/heads/".length),
+    };
 }
 async function resolveCommit(cwd, ref) {
     const git = createGit(cwd);
@@ -366,8 +394,19 @@ async function computeClaimReconciliation(cwd, defaultBranch) {
     }
     return { defaultBranch: defaultBranch.branch, head: defaultBranch.head, unclaimedSegments: segments, receiptIssues: issues };
 }
-export async function readKanshiBoard(cwd, now) {
+export async function readKanshiBoard(cwd, now, opts) {
+    const targetFilter = opts?.target ?? null;
     const loadedSettings = await loadKeiyakuSettings(cwd);
+    if (!(await isGitRepo(cwd))) {
+        return {
+            contracts: [],
+            projections: null,
+            queueLength: 0,
+            diseases: loadedSettings.diseases,
+            claimReconciliation: null,
+            targetFilter,
+        };
+    }
     // Status is a pure reader: use the same resolver, but retain its ability to
     // open when the defaultBranch knob itself is diseased.
     let defaultBranch = null;
@@ -377,16 +416,16 @@ export async function readKanshiBoard(cwd, now) {
     catch {
         defaultBranch = null;
     }
-    const [contractIds, queueEntries] = await Promise.all([listContractIds(cwd), readQueue(cwd)]);
+    const contractIds = await listContractIds(cwd);
     const terminalById = new Map();
     const ledgers = [];
-    const queued = queuedContracts(queueEntries);
-    const queuePositions = queuePositionsFromEntries(queueEntries);
+    const readableLedgers = [];
     for (const id of contractIds) {
         try {
             const ledger = await readLedger(cwd, id);
             if (ledger) {
                 ledgers.push(ledger);
+                readableLedgers.push(ledger);
                 terminalById.set(id, isTerminalState(deriveContractState(ledger.entries)));
             }
         }
@@ -394,9 +433,15 @@ export async function readKanshiBoard(cwd, now) {
             ledgers.push({ id, error: error instanceof Error ? error : new Error(String(error)) });
         }
     }
+    const queueModel = deriveQueueReadModel(readableLedgers);
+    const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
     const contracts = [];
+    // Readable-ledger commission targets retained for post-assembly filter only.
+    const derivedTargetById = new Map();
     for (const item of ledgers) {
         if ("error" in item) {
+            // Unreadable ledgers have no derivable target and stay under every filter.
+            derivedTargetById.set(item.id, undefined);
             contracts.push({
                 id: item.id,
                 slug: contractSlugFromId(item.id),
@@ -408,10 +453,13 @@ export async function readKanshiBoard(cwd, now) {
                 baseDrift: { state: "unknown", label: "n/a (corrupt ledger)" },
                 after: [],
                 corruptReason: item.error.message,
+                bootstrapDiagnostics: [],
+                queueDiagnostics: [],
             });
             continue;
         }
         const bind = findBindEntry(item.entries);
+        derivedTargetById.set(item.contractId, commissionTarget(item.entries)?.ref);
         const base = latestBase(item.entries);
         const state = deriveContractState(item.entries);
         if (isTerminalState(state))
@@ -442,15 +490,18 @@ export async function readKanshiBoard(cwd, now) {
             const sealForecast = openArc ? `seals a${openArc.data.arc} (${receiptCount} receipts), ` : "";
             nextStep.hint = `run: keiyaku @${item.contractId} renew — ${sealForecast}follows ${baseDrift.defaultBranch} ▲${baseDrift.behindBy}`;
         }
+        const membership = queueMembership(queueModel, item.contractId);
+        const queuePosition = membership?.position ?? null;
+        const targetQueueLength = membership?.queueLength ?? 0;
         contracts.push({
             id: item.contractId,
             slug: contractSlugFromId(item.contractId),
             state,
-            queuePosition: queuePositions.get(item.contractId) ?? null,
+            queuePosition,
             queueHeadStalled: isQueueHeadStall({
                 entries: item.entries,
-                queuePosition: queuePositions.get(item.contractId) ?? null,
-                queueLength: queued.length,
+                queuePosition,
+                queueLength: targetQueueLength,
                 state,
             }),
             arcs: getMaxArc(item.entries),
@@ -461,16 +512,28 @@ export async function readKanshiBoard(cwd, now) {
             base,
             baseDrift,
             after,
+            bootstrapDiagnostics: deriveBootstrapDiagnostics(item.entries),
+            queueDiagnostics: membership ? [...membership.diagnostics] : [],
         });
     }
+    const filteredContracts = targetFilter === null
+        ? contracts
+        : contracts.filter((contract) => {
+            const derived = derivedTargetById.get(contract.id);
+            return derived === undefined || derived === targetFilter;
+        });
+    const queueLength = targetFilter === null
+        ? boardQueueLength
+        : (queueModel.targetQueues.find((queue) => queue.target === targetFilter)?.ordered.length ?? 0);
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
     return {
-        contracts,
+        contracts: filteredContracts,
         projections: readProjectionStatusBoard(cwd, now),
-        queueLength: queued.length,
+        queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,
         diseases: loadedSettings.diseases,
         claimReconciliation,
+        targetFilter,
     };
 }