@use-the-fork/spindle 0.0.0-stage → 0.0.1

package/build/SubagentDrivenDevelopment/Persistence/TicketRepository.js

@@ -0,0 +1,147 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import matter from "gray-matter";
+import { Service } from "../../Foundation/Service.js";
+import { validateAuthor, validateTicketId, validateCategory, } from "../Policies/InputValidation.js";
+import { Records } from "../../Support/Records.js";
+const isRecord = Records.isRecord;
+export class TicketRepository extends Service {
+    pathSafety;
+    ledgerRepository;
+    constructor(app, pathSafety, ledgerRepository) {
+        super(app);
+        this.pathSafety = pathSafety;
+        this.ledgerRepository = ledgerRepository;
+    }
+    readTickets(workspace) {
+        const feature = basename(workspace);
+        const ledger = this.ledgerRepository.readLedger({
+            feature,
+            workspace,
+            spec: join(workspace, "spec.md"),
+            ledger: join(workspace, "sdd.json"),
+        });
+        const progressById = new Map(ledger.tickets.map((ticket) => [ticket.id, ticket]));
+        const directory = join(workspace, "tickets");
+        const tickets = [];
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (!entry.name.endsWith(".md"))
+                continue;
+            const id = entry.name.slice(0, -3);
+            validateTicketId(id);
+            const path = join(directory, entry.name);
+            this.pathSafety.assertTicketPath(workspace, path);
+            const raw = readFileSync(path, "utf8");
+            const parsed = matter(raw);
+            const data = parsed.data;
+            if (!isRecord(data) || data.id !== id)
+                throw new Error(`Ticket ${id} has invalid YAML front matter.`);
+            if (["title", "reporter", "category", "status", "blocked_by", "blocker"].some((key) => Object.hasOwn(data, key))) {
+                throw new Error(`Ticket ${id} tracking metadata must be stored in sdd.json.`);
+            }
+            const progress = progressById.get(id);
+            if (!progress)
+                throw new Error(`Ticket ${id} has no ledger record.`);
+            const { title, reporter, category, status, blockedBy, blocker } = progress;
+            if (typeof title !== "string" || !title.trim())
+                throw new Error(`Ticket ${id} title is invalid.`);
+            if (typeof reporter !== "string" || !reporter.trim())
+                throw new Error(`Ticket ${id} reporter is invalid.`);
+            validateCategory(category);
+            if (status !== "open" && status !== "in-progress" && status !== "closed") {
+                throw new Error(`Ticket ${id} status is invalid.`);
+            }
+            if (!Array.isArray(blockedBy) || !blockedBy.every((blocked) => typeof blocked === "string")) {
+                throw new Error(`Ticket ${id} dependencies must be a list of ticket IDs.`);
+            }
+            if (new Set(blockedBy).size !== blockedBy.length)
+                throw new Error(`Ticket ${id} has duplicate dependencies.`);
+            for (const blocked of blockedBy)
+                validateTicketId(blocked);
+            tickets.push({
+                metadata: { ...data },
+                id,
+                title,
+                reporter,
+                category,
+                status,
+                blocked_by: [...blockedBy],
+                ...(blocker ? { blocker } : {}),
+                body: parsed.content,
+                path,
+                raw,
+            });
+        }
+        return tickets;
+    }
+    metadata(ticket) {
+        return {
+            ...ticket.metadata,
+            id: ticket.id,
+        };
+    }
+    requireTicket(tickets, id) {
+        const ticket = tickets.find((item) => item.id === id);
+        if (!ticket)
+            throw new Error(`Ticket not found: ${id}.`);
+        return ticket;
+    }
+    normalizeDependencies(values) {
+        const dependencies = values.flatMap((value) => value.split(",")).map((value) => value.trim());
+        if (dependencies.some((value) => !value))
+            throw new Error("Dependency IDs must not be empty.");
+        for (const dependency of dependencies)
+            validateTicketId(dependency);
+        if (new Set(dependencies).size !== dependencies.length) {
+            throw new Error("Dependency IDs must not contain duplicates.");
+        }
+        return dependencies;
+    }
+    validateDependencyGraph(tickets) {
+        const byId = new Map(tickets.map((item) => [item.id, item]));
+        const visiting = new Set();
+        const visited = new Set();
+        const visit = (id) => {
+            if (visiting.has(id))
+                throw new Error(`Ticket dependency cycle detected at ${id}.`);
+            if (visited.has(id))
+                return;
+            const ticket = byId.get(id);
+            if (!ticket)
+                return;
+            visiting.add(id);
+            for (const dependency of ticket.blocked_by) {
+                if (!byId.has(dependency))
+                    throw new Error(`Ticket ${id} references missing dependency ${dependency}.`);
+                visit(dependency);
+            }
+            visiting.delete(id);
+            visited.add(id);
+        };
+        for (const ticket of tickets)
+            visit(ticket.id);
+    }
+    appendAudit(body, author, details) {
+        const heading = /^## Comments[ \t]*\r?$/m.exec(body);
+        if (!heading)
+            throw new Error("Ticket must contain a ## Comments section.");
+        const start = heading.index + heading[0].length;
+        const nextHeading = /^#{1,2}[ \t]+/m.exec(body.slice(start));
+        const end = nextHeading ? start + nextHeading.index : body.length;
+        const content = body.slice(0, end).replace(/\s+$/, "");
+        const laterSections = body.slice(end);
+        const entry = `**${new Date().toISOString()} - ${author.trim()}**\n\n${details}`;
+        return `${content}\n\n${entry}\n${laterSections ? `\n${laterSections}` : ""}`;
+    }
+    serializeTicket(ticket, body) {
+        return matter.stringify(body, this.metadata(ticket));
+    }
+    validateTicketCreateOptions(options) {
+        if (!options.title.trim())
+            throw new Error("Title must not be empty.");
+        if (!options.reporter.trim())
+            throw new Error("Reporter must not be empty.");
+        validateCategory(options.category);
+        validateAuthor(options.author);
+    }
+}

package/build/SubagentDrivenDevelopment/Persistence/WorkspaceTransaction.js

@@ -0,0 +1,282 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, closeSync, openSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { Service } from "../../Foundation/Service.js";
+import { lstatIfPresent, waitBriefly, LOCK_TIMEOUT_MS, } from "./FileSystem.js";
+import { Records } from "../../Support/Records.js";
+const isRecord = Records.isRecord;
+export class WorkspaceTransaction extends Service {
+    pathSafety;
+    activeWorkspaces = new Set();
+    run(workspace, operation) {
+        const release = this.acquireTicketLock(workspace);
+        this.activeWorkspaces.add(workspace);
+        try {
+            this.recoverWrites(workspace);
+            return operation();
+        }
+        finally {
+            this.activeWorkspaces.delete(workspace);
+            release();
+        }
+    }
+    constructor(app, pathSafety) {
+        super(app);
+        this.pathSafety = pathSafety;
+    }
+    acquireTicketLock(workspace) {
+        const lockPath = join(workspace, ".sdd-tickets.lock");
+        const root = realpathSync(this.app.workspaceRoot);
+        const relativeLock = relative(root, lockPath);
+        if (this.pathSafety.isIgnored(root, relativeLock)) {
+            throw new Error(`Ticket lock path is ignored: ${relativeLock}`);
+        }
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        while (true) {
+            try {
+                const descriptor = openSync(lockPath, "wx", 0o600);
+                try {
+                    writeSync(descriptor, JSON.stringify({ pid: process.pid }));
+                }
+                catch (error) {
+                    closeSync(descriptor);
+                    unlinkSync(lockPath);
+                    throw error;
+                }
+                return () => {
+                    try {
+                        closeSync(descriptor);
+                    }
+                    finally {
+                        unlinkSync(lockPath);
+                    }
+                };
+            }
+            catch (error) {
+                if (typeof error !== "object" ||
+                    error === null ||
+                    !("code" in error) ||
+                    error.code !== "EEXIST")
+                    throw error;
+                if (this.staleLockReason(lockPath)) {
+                    const lockEntry = lstatIfPresent(lockPath);
+                    if (!lockEntry?.isFile() || lockEntry.isSymbolicLink()) {
+                        throw new Error(`Ticket lock path is not a regular file and was preserved: ${lockPath}.`);
+                    }
+                    unlinkSync(lockPath);
+                    continue;
+                }
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for ticket updates; inspect ${lockPath} before retrying.`);
+                }
+                waitBriefly();
+            }
+        }
+    }
+    recoverWrites(workspace) {
+        const journalPath = join(workspace, ".sdd-write-recovery.json");
+        const entry = lstatIfPresent(journalPath);
+        if (!entry)
+            return;
+        if (!entry.isFile() || entry.isSymbolicLink())
+            throw new Error("Ticket recovery journal is not a regular file.");
+        const value = JSON.parse(readFileSync(journalPath, "utf8"));
+        if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.writes)) {
+            throw new Error("Ticket recovery journal has an unsupported format.");
+        }
+        const writes = value.writes;
+        const targets = new Set();
+        const pending = [];
+        for (const write of writes) {
+            if (!isRecord(write) ||
+                typeof write.path !== "string" ||
+                !(write.before === null || typeof write.before === "string") ||
+                typeof write.after !== "string" ||
+                !(write.path === "sdd.json" || /^tickets\/T-\d{4,}\.md$/.test(write.path)))
+                throw new Error("Ticket recovery journal contains an invalid write target.");
+            if (targets.has(write.path))
+                throw new Error("Ticket recovery journal contains duplicate write targets.");
+            targets.add(write.path);
+            const target = join(workspace, write.path);
+            const root = realpathSync(this.app.workspaceRoot);
+            const relativeTarget = relative(root, target);
+            if (this.pathSafety.isIgnored(root, relativeTarget)) {
+                throw new Error(`Ticket write target is ignored: ${relativeTarget}`);
+            }
+            if (write.path !== "sdd.json")
+                this.pathSafety.assertTicketPath(workspace, target);
+            else {
+                const ledgerEntry = lstatIfPresent(target);
+                if (!ledgerEntry?.isFile() || ledgerEntry.isSymbolicLink()) {
+                    throw new Error("Feature ledger must be a regular file during ticket recovery.");
+                }
+            }
+            const current = lstatIfPresent(target) ? readFileSync(target, "utf8") : null;
+            if (current !== write.before && current !== write.after) {
+                throw new Error(`Ticket recovery found conflicting external content at ${write.path}; preserved all files.`);
+            }
+            if (current !== write.after)
+                pending.push({ target, after: write.after });
+        }
+        for (const write of pending)
+            this.atomicWrite(write.target, write.after);
+        unlinkSync(journalPath);
+    }
+    applyWrites(workspace, writes) {
+        if (!this.activeWorkspaces.has(workspace)) {
+            throw new Error("Workflow writes require the workspace transaction lock.");
+        }
+        const journalPath = join(workspace, ".sdd-write-recovery.json");
+        if (lstatIfPresent(journalPath)) {
+            throw new Error("A pending ticket write recovery journal must be resolved first.");
+        }
+        for (const write of writes) {
+            if (!(write.path === "sdd.json" || /^tickets\/T-\d{4,}\.md$/.test(write.path))) {
+                throw new Error(`Unsafe ticket write target: ${write.path}.`);
+            }
+            const root = realpathSync(this.app.workspaceRoot);
+            const target = join(workspace, write.path);
+            const relativeTarget = relative(root, target);
+            if (this.pathSafety.isIgnored(root, relativeTarget)) {
+                throw new Error(`Ticket write target is ignored: ${relativeTarget}`);
+            }
+        }
+        const root = realpathSync(this.app.workspaceRoot);
+        const relativeJournal = relative(root, journalPath);
+        if (this.pathSafety.isIgnored(root, relativeJournal)) {
+            throw new Error(`Ticket recovery path is ignored: ${relativeJournal}`);
+        }
+        this.atomicWrite(journalPath, `${JSON.stringify({ version: 1, writes }, null, 2)}\n`);
+        this.recoverWrites(workspace);
+    }
+    atomicWrite(path, contents) {
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        const existing = lstatIfPresent(path);
+        const mode = existing ? existing.mode & 0o777 : 0o666 & ~process.umask();
+        try {
+            writeFileSync(temporary, contents, { flag: "wx", mode: mode | 0o200 });
+            if ((mode | 0o200) !== mode)
+                chmodSync(temporary, mode);
+            renameSync(temporary, path);
+        }
+        catch (error) {
+            rmSync(temporary, { force: true });
+            throw error;
+        }
+    }
+    writeWorkflowState(feature, ticket, ticketAfter, ledger) {
+        this.applyWrites(feature.workspace, [
+            {
+                path: relative(feature.workspace, ticket.path),
+                before: ticket.raw,
+                after: ticketAfter,
+            },
+            {
+                path: "sdd.json",
+                before: readFileSync(feature.ledger, "utf8"),
+                after: `${JSON.stringify(ledger, null, 2)}\n`,
+            },
+        ]);
+    }
+    writeLedger(feature, ledger) {
+        this.applyWrites(feature.workspace, [
+            {
+                path: "sdd.json",
+                before: readFileSync(feature.ledger, "utf8"),
+                after: `${JSON.stringify(ledger, null, 2)}\n`,
+            },
+        ]);
+    }
+    acquireCreationLock(scratch) {
+        const lockPath = join(scratch, ".sdd-create.lock");
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        while (true) {
+            try {
+                const descriptor = openSync(lockPath, "wx", 0o600);
+                try {
+                    writeSync(descriptor, JSON.stringify({ pid: process.pid, createdAt: Date.now() }));
+                }
+                catch (error) {
+                    closeSync(descriptor);
+                    unlinkSync(lockPath);
+                    throw error;
+                }
+                return () => {
+                    try {
+                        closeSync(descriptor);
+                    }
+                    finally {
+                        unlinkSync(lockPath);
+                    }
+                };
+            }
+            catch (error) {
+                if (typeof error !== "object" ||
+                    error === null ||
+                    !("code" in error) ||
+                    error.code !== "EEXIST") {
+                    throw error;
+                }
+                const staleLock = this.staleLockReason(lockPath);
+                if (staleLock) {
+                    throw new Error(`Stale feature creation lock at ${lockPath}: ${staleLock}. Verify its owner has stopped, then remove the lock and any abandoned .sdd-create-* staging directory before retrying.`);
+                }
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for another feature workspace creation; inspect ${lockPath} and remove it only after confirming its owner stopped.`);
+                }
+                waitBriefly();
+            }
+        }
+    }
+    staleLockReason(lockPath) {
+        try {
+            const entry = lstatIfPresent(lockPath);
+            if (!entry)
+                return undefined;
+            if (!entry.isFile())
+                return "the lock path is not a regular file";
+            let owner;
+            try {
+                owner = JSON.parse(readFileSync(lockPath, "utf8"));
+            }
+            catch {
+                return Date.now() - entry.mtimeMs >= LOCK_TIMEOUT_MS
+                    ? "the lock contents are malformed and old"
+                    : undefined;
+            }
+            if (typeof owner.pid === "number" && Number.isSafeInteger(owner.pid) && owner.pid > 0) {
+                try {
+                    process.kill(owner.pid, 0);
+                    return undefined;
+                }
+                catch (error) {
+                    if (typeof error === "object" &&
+                        error !== null &&
+                        "code" in error &&
+                        error.code === "EPERM") {
+                        return undefined;
+                    }
+                    if (typeof error === "object" &&
+                        error !== null &&
+                        "code" in error &&
+                        error.code !== "ESRCH") {
+                        return undefined;
+                    }
+                    return "the recorded owner process is no longer running";
+                }
+            }
+            return Date.now() - entry.mtimeMs >= LOCK_TIMEOUT_MS
+                ? "the lock has no live process owner"
+                : undefined;
+        }
+        catch (error) {
+            if (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+}

package/build/SubagentDrivenDevelopment/Policies/AcceptancePolicy.js

@@ -0,0 +1,100 @@
+import { Service } from "../../Foundation/Service.js";
+import { requiredTicketReviewers } from "./RequiredReviewers.js";
+export class AcceptancePolicy extends Service {
+    assignmentPolicy;
+    checkPolicy;
+    findingPolicy;
+    reviewPolicy;
+    constructor(app, assignmentPolicy, checkPolicy, findingPolicy, reviewPolicy) {
+        super(app);
+        this.assignmentPolicy = assignmentPolicy;
+        this.checkPolicy = checkPolicy;
+        this.findingPolicy = findingPolicy;
+        this.reviewPolicy = reviewPolicy;
+    }
+    acceptBlockers(feature, ledger, ticket, progress, identity) {
+        const blockers = this.checkPolicy.reviewCheckBlockers(feature, ticket, progress, identity);
+        blockers.push(...this.findingPolicy.findingBlockers(progress, identity));
+        for (const decision of progress.requirementsDecisions ?? []) {
+            if (decision.status === "rejected" &&
+                decision.requirementsSnapshot === identity.requirementsSnapshot) {
+                blockers.push(`Requirements decision ${decision.id} was rejected; acceptance requires an approved decision and fresh review.`);
+            }
+        }
+        const implementationBlocker = this.assignmentPolicy.implementationReportBlocker(feature, progress.assignment);
+        if (implementationBlocker)
+            blockers.push(implementationBlocker);
+        const assignments = progress.reviewAssignments ?? [];
+        const requiredReviewers = requiredTicketReviewers(ledger, progress);
+        if (new Set(assignments.map((assignment) => assignment.id)).size !== assignments.length ||
+            new Set(assignments.map((assignment) => assignment.report)).size !== assignments.length) {
+            blockers.push("Initial review assignments must have distinct IDs and report destinations.");
+        }
+        const hasCorrections = (progress.correctionAttempts?.length ?? 0) > 0;
+        for (const { agent, details } of requiredReviewers) {
+            const coverage = assignments.filter((assignment) => assignment.agent === agent && assignment.scope === "initial");
+            if (coverage.length === 0) {
+                blockers.push(`Required initial review coverage for '${agent}' is missing.`);
+            }
+            else if (coverage.length > 1) {
+                blockers.push(`Required initial review coverage for '${agent}' is duplicated.`);
+            }
+            else if (coverage[0].objective !== details) {
+                blockers.push(`Review assignment for '${agent}' does not match its pinned objective.`);
+            }
+            else if (hasCorrections &&
+                (coverage[0].status !== "submitted" ||
+                    coverage[0].result === "unavailable" ||
+                    this.reviewPolicy.reviewReportIntegrityBlocker(feature, coverage[0]))) {
+                blockers.push(`Required initial review coverage for '${agent}' is missing or its registered report is unavailable.`);
+            }
+        }
+        if (hasCorrections) {
+            const currentAttempt = progress.correctionAttempts.at(-1);
+            const correctiveAssignments = currentAttempt.reviewAssignments ?? [];
+            if (correctiveAssignments.length !== requiredReviewers.length) {
+                blockers.push("Complete corrective review coverage for the latest attempt is missing.");
+            }
+            for (const { agent, details } of requiredReviewers) {
+                const coverage = correctiveAssignments.filter((assignment) => assignment.agent === agent &&
+                    assignment.scope === "corrective" &&
+                    assignment.attempt === currentAttempt.number);
+                if (coverage.length !== 1) {
+                    blockers.push(`Required corrective review coverage for '${agent}' is missing or duplicated.`);
+                    continue;
+                }
+                if (coverage[0].objective !== details) {
+                    blockers.push(`Corrective review assignment for '${agent}' does not match its pinned objective.`);
+                }
+                if (coverage[0].status !== "submitted" || coverage[0].result !== "passed") {
+                    blockers.push(`Corrective review assignment ${coverage[0].id} is not passing.`);
+                    continue;
+                }
+                const blocker = this.reviewPolicy.reviewAssignmentBlocker(feature, progress, coverage[0], identity);
+                if (blocker)
+                    blockers.push(blocker);
+            }
+            for (const assignment of correctiveAssignments) {
+                if (!requiredReviewers.some((reviewer) => reviewer.agent === assignment.agent)) {
+                    blockers.push(`Corrective review assignment ${assignment.id} is not part of the pinned review policy.`);
+                }
+            }
+        }
+        else {
+            for (const assignment of assignments) {
+                if (!requiredReviewers.some((reviewer) => reviewer.agent === assignment.agent)) {
+                    blockers.push(`Review assignment ${assignment.id} is not part of the pinned review policy.`);
+                    continue;
+                }
+                if (assignment.status === "pending") {
+                    blockers.push(`Review assignment ${assignment.id} is pending.`);
+                    continue;
+                }
+                const blocker = this.reviewPolicy.reviewAssignmentBlocker(feature, progress, assignment, identity);
+                if (blocker)
+                    blockers.push(blocker);
+            }
+        }
+        return [...new Set(blockers)];
+    }
+}

package/build/SubagentDrivenDevelopment/Policies/AssignmentPolicy.js

@@ -0,0 +1,36 @@
+import { Service } from "../../Foundation/Service.js";
+export class AssignmentPolicy extends Service {
+    reportEvidence;
+    constructor(app, reportEvidence) {
+        super(app);
+        this.reportEvidence = reportEvidence;
+    }
+    implementationReportBlocker(feature, assignment) {
+        if (!assignment || assignment.status !== "submitted" || !assignment.reportSha256) {
+            return "Review is blocked because no submitted implementation report is registered.";
+        }
+        try {
+            const currentDigest = this.reportEvidence.readReportDigest(feature, assignment.report);
+            if (currentDigest !== assignment.reportSha256) {
+                return "The registered implementation report content changed after submission.";
+            }
+        }
+        catch {
+            return "The registered implementation report is missing or unavailable.";
+        }
+        return undefined;
+    }
+    resumeBlocker(feature, progress) {
+        if (progress.execution === "claimed" && (!progress.owner || !progress.baseSha)) {
+            return "Claim has no recorded owner or baseline; implementation is unavailable.";
+        }
+        if (progress.execution === "implementing" && !progress.assignment) {
+            return "Implementation is marked in progress without a recorded assignment.";
+        }
+        if (progress.execution === "reviewing" ||
+            (progress.execution === "implementing" && progress.assignment?.status === "submitted")) {
+            return this.implementationReportBlocker(feature, progress.assignment);
+        }
+        return undefined;
+    }
+}

package/build/SubagentDrivenDevelopment/Policies/CheckPolicy.js

@@ -0,0 +1,93 @@
+import { Service } from "../../Foundation/Service.js";
+export class CheckPolicy extends Service {
+    gitEvidence;
+    constructor(app, gitEvidence) {
+        super(app);
+        this.gitEvidence = gitEvidence;
+    }
+    hasCurrentCheckCoverage(feature, ticket, progress) {
+        const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+        return this.checkBlockers(feature, ticket, progress, identity).length === 0;
+    }
+    checkBlockers(feature, ticket, progress, identity) {
+        const checks = progress.checks;
+        if (!checks)
+            return [];
+        return checks.required
+            .filter((requirement) => !requirement.removedAt)
+            .flatMap((requirement) => {
+            const records = checks.records.filter((record) => record.command === requirement.command);
+            const preservedIntegrationEvidence = this.gitEvidence.integrationPreservesEvidence(progress, identity);
+            const current = records.filter((record) => {
+                if (record.snapshot === identity.snapshot &&
+                    record.codeSnapshot === identity.codeSnapshot &&
+                    record.requirementsSnapshot === identity.requirementsSnapshot) {
+                    return true;
+                }
+                if (preservedIntegrationEvidence &&
+                    record.snapshot === progress.acceptedEvidence?.snapshot &&
+                    record.codeSnapshot === progress.acceptedEvidence?.codeSnapshot &&
+                    record.requirementsSnapshot === progress.acceptedEvidence?.requirementsSnapshot) {
+                    return true;
+                }
+                if (!record.coveredPaths ||
+                    !record.coverageSnapshot ||
+                    record.requirementsSnapshot !== identity.requirementsSnapshot) {
+                    return false;
+                }
+                try {
+                    const scopedIdentity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, checks, record.coveredPaths);
+                    return scopedIdentity.codeSnapshot === record.coverageSnapshot;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const latest = current.at(-1);
+            if (!latest) {
+                const state = records.length > 0 ? "stale" : "missing";
+                return [`Required check ${requirement.command} is ${state} for the current content.`];
+            }
+            if (latest.result !== "passed") {
+                const suffix = latest.details ? ` Details: ${latest.details}` : "";
+                return [`Required check ${requirement.command} is ${latest.result}.${suffix}`];
+            }
+            return [];
+        });
+    }
+    reviewCheckBlockers(feature, ticket, progress, identity) {
+        const activeRequirements = progress.checks?.required.filter((requirement) => !requirement.removedAt) ?? [];
+        if (activeRequirements.length === 0) {
+            return ["Review requires at least one currently required passing check."];
+        }
+        return this.checkBlockers(feature, ticket, progress, identity);
+    }
+    deliveryCheckBlockers(delivery, identity) {
+        const records = delivery.checks?.records ?? [];
+        const hasPassingCheck = records.some((record) => record.result === "passed" &&
+            record.snapshot === identity.snapshot &&
+            record.codeSnapshot === identity.codeSnapshot &&
+            record.requirementsSnapshot === identity.requirementsSnapshot);
+        const evidenceBlockers = hasPassingCheck
+            ? []
+            : ["At least one relevant test/check must pass for the current feature snapshot."];
+        return [
+            ...evidenceBlockers,
+            ...(delivery.checks?.required ?? [])
+                .filter((requirement) => !requirement.removedAt)
+                .flatMap((requirement) => {
+                const matchingRecords = records.filter((record) => record.command === requirement.command &&
+                    record.snapshot === identity.snapshot &&
+                    record.codeSnapshot === identity.codeSnapshot &&
+                    record.requirementsSnapshot === identity.requirementsSnapshot);
+                const latest = matchingRecords.at(-1);
+                if (!latest)
+                    return [`Required delivery check ${requirement.command} is missing or stale.`];
+                if (latest.result !== "passed") {
+                    return [`Required delivery check ${requirement.command} is ${latest.result}.`];
+                }
+                return [];
+            }),
+        ];
+    }
+}