project-tiny-context-harness 0.2.85 → 0.6.0

package/dist/lib/plan-acceptance-validator.js

@@ -1,209 +0,0 @@
-import path from "node:path";
-import { pathExists } from "./fs.js";
-import { validateAcceptanceArtifactDiagnostics } from "./plan-acceptance-artifacts.js";
-import { assertExternalReviewerFields } from "./plan-acceptance-evidence.js";
-import { AC_STATUSES, MATRIX_STATUSES, NON_COMPLETE_AC, NON_COMPLETE_MATRIX, assertStructuredNa, assertSurfaceConformance, contextDeltaRequired, findJsonFile, findRows, hasExplicitNoTestScope, isOutOfScope, isSurfaceConformanceRow, overallStatus, readJson, statusOf } from "./plan-acceptance-json.js";
-import { assertReferencedPathsExist, hasRealPageEvidence, isBlankish, isUiFacing, primitiveText, repoRelative, resolveInputDir, valuesAsArray, weakProofHit } from "./plan-validator-common.js";
-import { validateSuperpowersState } from "./superpowers-task-validator.js";
-export async function validatePlanAcceptance(projectRoot, args = []) {
-    const info = [];
-    const warnings = [];
-    const hygiene = [];
-    const errors = [];
-    const targetDir = await resolveInputDir(projectRoot, args[0], "tmp/ty-context/plan-acceptance");
-    if (!(await pathExists(targetDir))) {
-        return { info, warnings, hygiene, errors: [`plan acceptance directory is missing: ${repoRelative(projectRoot, targetDir)}`] };
-    }
-    if (await pathExists(path.join(targetDir, "task-state.json"))) {
-        const stateReport = await validateSuperpowersState(projectRoot, [targetDir]);
-        return {
-            info: [
-                `checked state-backed plan acceptance ${repoRelative(projectRoot, targetDir)}`,
-                ...stateReport.info,
-                ...(stateReport.errors.length === 0 ? ["Plan acceptance state-backed artifact consistency passed"] : [])
-            ],
-            warnings: stateReport.warnings,
-            hygiene: stateReport.hygiene,
-            errors: stateReport.errors
-        };
-    }
-    const matrixFile = await findJsonFile(targetDir, "plan-conformance-matrix");
-    const verdictFile = await findJsonFile(targetDir, "final-acceptance-verdict");
-    if (!matrixFile) {
-        errors.push(`plan acceptance directory is missing *-plan-conformance-matrix.json`);
-    }
-    if (!verdictFile) {
-        errors.push(`plan acceptance directory is missing *-final-acceptance-verdict.json`);
-    }
-    if (!matrixFile || !verdictFile) {
-        return { info, warnings, hygiene, errors };
-    }
-    const matrix = await readJson(matrixFile, errors);
-    const verdict = await readJson(verdictFile, errors);
-    if (matrix === undefined || verdict === undefined) {
-        return { info, warnings, hygiene, errors };
-    }
-    const matrixRows = findRows(matrix, ["plan_items", "items", "matrix", "entries", "plan_conformance"]);
-    const verdictRows = findRows(verdict, ["acceptance_items", "ac_verdicts", "verdicts", "items", "entries", "acs"]);
-    await validateMatrixRows(projectRoot, matrixRows, overallStatus(matrix), errors);
-    await validateVerdictRows(projectRoot, verdictRows, overallStatus(verdict), errors);
-    validateCrossReferences(matrixRows, verdictRows, errors);
-    validateContextFactReferences(matrix, verdict, matrixRows, verdictRows, errors);
-    await validateAcceptanceArtifactDiagnostics(projectRoot, targetDir, matrixRows, verdictRows, overallStatus(verdict), errors, warnings, hygiene);
-    info.push(`checked plan acceptance ${repoRelative(projectRoot, targetDir)} matrix_rows=${matrixRows.length} verdict_rows=${verdictRows.length}`);
-    if (errors.length === 0) {
-        info.push("Plan acceptance artifact consistency passed");
-    }
-    return { info, warnings, hygiene, errors };
-}
-async function validateMatrixRows(projectRoot, rows, overall, errors) {
-    if (rows.length === 0) {
-        errors.push("plan-conformance matrix has no trace rows");
-    }
-    for (const [index, row] of rows.entries()) {
-        const label = `plan-conformance matrix row ${index + 1}`;
-        const status = statusOf(row);
-        if (!MATRIX_STATUSES.has(status)) {
-            errors.push(`${label} has unsupported status: ${status || "<empty>"}`);
-        }
-        if (status === "out_of_scope_NA") {
-            assertStructuredNa(row, label, errors);
-        }
-        if (overall === "complete" && NON_COMPLETE_MATRIX.has(status)) {
-            errors.push(`${label} is ${status} but overall_status is complete`);
-        }
-        if (status === "complete" && !isBlankish(row.missing_paths)) {
-            errors.push(`${label} is complete but missing_paths is not empty`);
-        }
-        if (status === "complete") {
-            if (isBlankish(row.plan_requirement)) {
-                errors.push(`${label} is complete but plan_requirement is empty`);
-            }
-            if (isBlankish(row.expected_surfaces)) {
-                errors.push(`${label} is complete but expected_surfaces is empty`);
-            }
-            if (isBlankish(row.implemented_paths)) {
-                errors.push(`${label} is complete but implemented_paths is empty`);
-            }
-            if (isBlankish(row.tests) && !hasExplicitNoTestScope(row)) {
-                errors.push(`${label} is complete but tests is empty and no explicit no-test scope is recorded`);
-            }
-            if (isBlankish(row.runtime_evidence) && isBlankish(row.artifact_evidence) && isBlankish(row.real_page_evidence)) {
-                errors.push(`${label} is complete but has no runtime, artifact or real-page evidence`);
-            }
-            if (isBlankish(row.scope_assessment)) {
-                errors.push(`${label} is complete but scope_assessment is empty`);
-            }
-            if (isBlankish(row.drift)) {
-                errors.push(`${label} is complete but drift is empty`);
-            }
-            assertExternalReviewerFields(label, row, primitiveText([row.runtime_evidence, row.artifact_evidence, row.real_page_evidence, row.fresh_evidence]), errors);
-            const weak = weakProofHit(primitiveText(row));
-            if (weak) {
-                errors.push(`${label} is complete but contains weak-proof language matching /${weak}/`);
-            }
-            if (isUiFacing(primitiveText([row.expected_surfaces, row.plan_requirement, row.conformance_type]))) {
-                const realPageEvidence = primitiveText([
-                    row.real_page_evidence,
-                    row.user_path_evidence,
-                    row.fresh_evidence,
-                    row.runtime_evidence,
-                    row.artifact_evidence
-                ]);
-                if (!hasRealPageEvidence(realPageEvidence)) {
-                    errors.push(`${label} is UI/surface-facing but lacks real_page_evidence`);
-                }
-            }
-            if (isSurfaceConformanceRow(row)) {
-                assertSurfaceConformance(row, label, errors);
-            }
-            await assertReferencedPathsExist(projectRoot, label, primitiveText([
-                row.implemented_paths,
-                row.tests,
-                row.runtime_evidence,
-                row.artifact_evidence,
-                row.real_page_evidence,
-                row.negative_surface_checks,
-                row.context_fact_refs
-            ]), errors);
-        }
-    }
-}
-async function validateVerdictRows(projectRoot, rows, overall, errors) {
-    if (rows.length === 0) {
-        errors.push("final acceptance verdict has no AC rows");
-    }
-    for (const [index, row] of rows.entries()) {
-        const label = `final acceptance verdict row ${index + 1}`;
-        const status = statusOf(row);
-        if (!AC_STATUSES.has(status)) {
-            errors.push(`${label} has unsupported status: ${status || "<empty>"}`);
-        }
-        if (status === "out_of_scope_NA") {
-            assertStructuredNa(row, label, errors);
-        }
-        if (overall === "complete" && NON_COMPLETE_AC.has(status)) {
-            errors.push(`${label} is ${status} but overall_status is complete`);
-        }
-        if (status === "complete" && isBlankish(row.fresh_evidence)) {
-            errors.push(`${label} is complete but fresh_evidence is empty`);
-        }
-        if (status === "complete" && isBlankish(row.required_evidence)) {
-            errors.push(`${label} is complete but required_evidence is empty`);
-        }
-        if (status === "complete" && isBlankish(row.decision)) {
-            errors.push(`${label} is complete but decision is empty`);
-        }
-        if (status === "complete" && !isBlankish(row.missing_evidence)) {
-            errors.push(`${label} is complete but missing_evidence is not empty`);
-        }
-        if (status === "complete" && !isBlankish(row.contradictions)) {
-            errors.push(`${label} is complete but contradictions is not empty`);
-        }
-        if (status === "complete") {
-            const text = primitiveText(row);
-            assertExternalReviewerFields(label, row, primitiveText(row.fresh_evidence), errors);
-            const weak = weakProofHit(text);
-            if (weak) {
-                errors.push(`${label} is complete but contains weak-proof language matching /${weak}/`);
-            }
-            if (isUiFacing(text) && !isOutOfScope(row) && !hasRealPageEvidence(primitiveText(row.fresh_evidence))) {
-                errors.push(`${label} is UI-facing but lacks fresh real-page evidence or explicit N/A`);
-            }
-            await assertReferencedPathsExist(projectRoot, label, primitiveText([row.fresh_evidence, row.context_fact_refs]), errors);
-        }
-    }
-}
-function validateCrossReferences(matrixRows, verdictRows, errors) {
-    const planIds = new Set(matrixRows.map((row) => String(row.plan_item_id ?? row.id ?? "")).filter(Boolean));
-    const acIds = new Set(verdictRows.map((row) => String(row.ac_id ?? row.id ?? row.acceptance_item ?? "")).filter(Boolean));
-    let checked = 0;
-    for (const [index, row] of matrixRows.entries()) {
-        for (const acId of valuesAsArray(row.acceptance_ids ?? row.ac_ids)) {
-            checked += 1;
-            if (!acIds.has(acId)) {
-                errors.push(`plan-conformance matrix row ${index + 1} references unknown AC id: ${acId}`);
-            }
-        }
-    }
-    for (const [index, row] of verdictRows.entries()) {
-        for (const planId of valuesAsArray(row.related_plan_item_ids ?? row.plan_item_ids)) {
-            checked += 1;
-            if (!planIds.has(planId)) {
-                errors.push(`final acceptance verdict row ${index + 1} references unknown plan item id: ${planId}`);
-            }
-        }
-    }
-    if (matrixRows.length > 0 && verdictRows.length > 0 && checked === 0) {
-        errors.push("plan acceptance artifacts must include acceptance_ids or related_plan_item_ids cross references");
-    }
-}
-function validateContextFactReferences(matrix, verdict, matrixRows, verdictRows, errors) {
-    if (!contextDeltaRequired(matrix) && !contextDeltaRequired(verdict)) {
-        return;
-    }
-    const rows = [...matrixRows, ...verdictRows];
-    if (!rows.some((row) => !isBlankish(row.context_fact_refs))) {
-        errors.push("Context Delta is required but matrix/verdict rows do not cite context_fact_refs");
-    }
-}

package/dist/lib/plan-contract-validator.d.ts

@@ -1,2 +0,0 @@
-import type { ValidatorReport } from "./validators.js";
-export declare function validatePlanContract(projectRoot: string, args?: string[]): Promise<ValidatorReport>;

package/dist/lib/plan-contract-validator.js

@@ -1,127 +0,0 @@
-import { cell, hasRealPageEvidence, isBlankish, isRuntimeFacing, isUiFacing, parseRequiredTable, readRequiredFile, repoRelative, resolveInputFile, weakProofHit, assertReferencedPathsExist } from "./plan-validator-common.js";
-const SOURCE_HEADERS = [
-    "Source item",
-    "Durable constraint",
-    "Type",
-    "Existing Context Hit",
-    "Context action",
-    "Owning Context",
-    "Coverage status"
-];
-const BINDING_HEADERS = [
-    "Context fact",
-    "Implementation obligation",
-    "Expected surfaces",
-    "Implemented paths",
-    "Forbidden shortcuts",
-    "Verification path",
-    "Binding status"
-];
-const SOURCE_STATUSES = new Set([
-    "covered",
-    "new_context_required",
-    "context_updated",
-    "task_local_only",
-    "out_of_scope_explicit",
-    "needs_user_decision",
-    "under_scoped"
-]);
-const BINDING_STATUSES = new Set([
-    "bound",
-    "partial",
-    "missing",
-    "blocked",
-    "out_of_scope_explicit",
-    "needs_user_decision",
-    "contradicted_by_current_state"
-]);
-const UNRESOLVED_SOURCE = new Set(["new_context_required", "needs_user_decision", "under_scoped"]);
-const NON_BOUND = new Set(["partial", "missing", "blocked", "needs_user_decision", "contradicted_by_current_state"]);
-export async function validatePlanContract(projectRoot, args = []) {
-    const info = [];
-    const errors = [];
-    const planPath = await resolveInputFile(projectRoot, args[0], "plan.md");
-    const content = await readRequiredFile(projectRoot, planPath, "plan contract", errors);
-    if (content === undefined) {
-        return { info, errors };
-    }
-    const sourceTable = parseRequiredTable(content, "Source-to-Context Coverage", SOURCE_HEADERS, "Source-to-Context Coverage", errors);
-    if (sourceTable?.headers.includes("implementation constraint")) {
-        errors.push("Source-to-Context Coverage must not include Implementation constraint; use Context-to-Implementation Binding instead");
-    }
-    const bindingTable = parseRequiredTable(content, "Context-to-Implementation Binding", BINDING_HEADERS, "Context-to-Implementation Binding", errors);
-    if (sourceTable) {
-        for (const row of sourceTable.rows) {
-            const status = cell(row, "Coverage status");
-            const label = `Source-to-Context Coverage row ${row.index}`;
-            if (!SOURCE_STATUSES.has(status)) {
-                errors.push(`${label} has unsupported Coverage status: ${status || "<empty>"}`);
-            }
-            if (UNRESOLVED_SOURCE.has(status)) {
-                errors.push(`${label} is unresolved (${status}) and cannot pass final plan-contract validation`);
-            }
-            if (status === "covered" && isBlankish(cell(row, "Existing Context Hit"))) {
-                errors.push(`${label} is covered but has no Existing Context Hit`);
-            }
-            if (status === "context_updated" && isBlankish(cell(row, "Owning Context"))) {
-                errors.push(`${label} is context_updated but has no Owning Context`);
-            }
-            await assertReferencedPathsExist(projectRoot, label, `${cell(row, "Existing Context Hit")} ${cell(row, "Owning Context")}`, errors);
-        }
-    }
-    if (bindingTable) {
-        for (const row of bindingTable.rows) {
-            const status = cell(row, "Binding status");
-            const label = `Context-to-Implementation Binding row ${row.index}`;
-            const expectedSurfaces = cell(row, "Expected surfaces");
-            const implementedPaths = cell(row, "Implemented paths");
-            const verificationPath = cell(row, "Verification path");
-            const evidenceText = `${implementedPaths} ${verificationPath}`;
-            if (!BINDING_STATUSES.has(status)) {
-                errors.push(`${label} has unsupported Binding status: ${status || "<empty>"}`);
-            }
-            if (NON_BOUND.has(status)) {
-                errors.push(`${label} is ${status} and cannot pass final plan-contract validation`);
-            }
-            if (status === "bound") {
-                if (isBlankish(expectedSurfaces)) {
-                    errors.push(`${label} is bound but has no Expected surfaces`);
-                }
-                if (isBlankish(implementedPaths)) {
-                    errors.push(`${label} is bound but has no Implemented paths`);
-                }
-                if (isBlankish(verificationPath)) {
-                    errors.push(`${label} is bound but has no Verification path`);
-                }
-                const weak = weakProofHit(`${cell(row, "Context fact")} ${cell(row, "Implementation obligation")} ${expectedSurfaces} ${evidenceText}`);
-                if (weak) {
-                    errors.push(`${label} is bound but contains weak-proof language matching /${weak}/`);
-                }
-                if (isUiFacing(`${expectedSurfaces} ${cell(row, "Implementation obligation")}`) && !hasRealPageEvidence(evidenceText)) {
-                    errors.push(`${label} is UI/surface-facing but lacks real page, route, browser or screenshot evidence`);
-                }
-                if (isRuntimeFacing(expectedSurfaces) && !isRuntimeFacing(evidenceText)) {
-                    errors.push(`${label} expects runtime/API/worker coverage but implemented evidence does not name that surface`);
-                }
-                assertForbiddenShortcutsNotUsed(row, evidenceText, label, errors);
-            }
-            await assertReferencedPathsExist(projectRoot, label, `${cell(row, "Context fact")} ${implementedPaths} ${verificationPath}`, errors);
-        }
-    }
-    info.push(`checked plan contract ${repoRelative(projectRoot, planPath)} source_rows=${sourceTable?.rows.length ?? 0} binding_rows=${bindingTable?.rows.length ?? 0}`);
-    if (errors.length === 0) {
-        info.push("Plan contract validation passed");
-    }
-    return { info, errors };
-}
-function assertForbiddenShortcutsNotUsed(row, evidenceText, label, errors) {
-    const shortcuts = cell(row, "Forbidden shortcuts")
-        .split(/[,;\n]/)
-        .map((item) => item.trim())
-        .filter((item) => item && !isBlankish(item));
-    for (const shortcut of shortcuts) {
-        if (evidenceText.toLowerCase().includes(shortcut.toLowerCase())) {
-            errors.push(`${label} is bound but its evidence uses forbidden shortcut: ${shortcut}`);
-        }
-    }
-}

package/dist/lib/plan-validator-common.d.ts

@@ -1,24 +0,0 @@
-export interface PlanTableRow {
-    index: number;
-    line: number;
-    cells: Record<string, string>;
-    text: string;
-}
-export interface ParsedPlanTable {
-    rows: PlanTableRow[];
-    headers: string[];
-}
-export declare function resolveInputFile(projectRoot: string, value: string | undefined, defaultPath: string): Promise<string>;
-export declare function resolveInputDir(projectRoot: string, value: string | undefined, defaultPath: string): Promise<string>;
-export declare function repoRelative(projectRoot: string, file: string): string;
-export declare function readRequiredFile(projectRoot: string, file: string, label: string, errors: string[]): Promise<string | undefined>;
-export declare function parseRequiredTable(content: string, heading: string, expectedHeaders: string[], label: string, errors: string[]): ParsedPlanTable | undefined;
-export declare function cell(row: PlanTableRow, header: string): string;
-export declare function isBlankish(value: unknown): boolean;
-export declare function weakProofHit(text: string): string | undefined;
-export declare function assertReferencedPathsExist(projectRoot: string, label: string, text: string, errors: string[]): Promise<void>;
-export declare function primitiveText(value: unknown): string;
-export declare function valuesAsArray(value: unknown): string[];
-export declare function hasRealPageEvidence(text: string): boolean;
-export declare function isUiFacing(text: string): boolean;
-export declare function isRuntimeFacing(text: string): boolean;

package/dist/lib/plan-validator-common.js

@@ -1,196 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { pathExists, readText } from "./fs.js";
-const PATH_PATTERN = /(?:`([^`]+)`)|((?:\.\/)?(?:project_context|packages|tests|tmp|src|app|pages|components|\.codex|tools|examples)\/[A-Za-z0-9._@+/-]+(?:\.(?:md|ts|tsx|js|mjs|json|yaml|yml|toml|png|jpe?g|webp|html|css|scss|py|go|rs|java|cs|sh|ps1))?)/g;
-const WEAK_PROOF_PATTERNS = [
-    /\bchecked path(?:s)?\b/i,
-    /\bsampled(?:[_ -]?only)?\b/i,
-    /\bnot live-proven\b/i,
-    /\blacks?\b/i,
-    /\bmissing\b/i,
-    /\bgap\b/i,
-    /\bpartial\b/i,
-    /\bblocked\b/i,
-    /\bunconfigured\b/i,
-    /\bnot visible by default\b/i
-];
-export async function resolveInputFile(projectRoot, value, defaultPath) {
-    const raw = value ?? defaultPath;
-    const absolute = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(projectRoot, raw);
-    let candidate = absolute;
-    try {
-        const stat = await fs.stat(absolute);
-        if (stat.isDirectory()) {
-            candidate = path.join(absolute, defaultPath);
-        }
-    }
-    catch {
-        if (!path.extname(absolute)) {
-            candidate = path.join(absolute, defaultPath);
-        }
-    }
-    return candidate;
-}
-export async function resolveInputDir(projectRoot, value, defaultPath) {
-    return path.isAbsolute(value ?? defaultPath)
-        ? path.resolve(value ?? defaultPath)
-        : path.resolve(projectRoot, value ?? defaultPath);
-}
-export function repoRelative(projectRoot, file) {
-    return path.relative(projectRoot, file).split(path.sep).join("/");
-}
-export async function readRequiredFile(projectRoot, file, label, errors) {
-    if (!isInside(projectRoot, file)) {
-        errors.push(`${label} must stay inside the project root: ${file}`);
-        return undefined;
-    }
-    if (!(await pathExists(file))) {
-        errors.push(`${label} is missing: ${repoRelative(projectRoot, file)}`);
-        return undefined;
-    }
-    return readText(file);
-}
-export function parseRequiredTable(content, heading, expectedHeaders, label, errors) {
-    const section = sectionBody(content, heading);
-    if (section === undefined) {
-        errors.push(`plan contract is missing section: ${heading}`);
-        return undefined;
-    }
-    const lines = section.split(/\r?\n/);
-    for (let index = 0; index < lines.length; index += 1) {
-        if (!lines[index].includes("|")) {
-            continue;
-        }
-        const headers = splitTableLine(lines[index]);
-        const normalized = headers.map(normalizeHeader);
-        if (!expectedHeaders.every((header) => normalized.includes(normalizeHeader(header)))) {
-            continue;
-        }
-        const rows = [];
-        for (let rowIndex = index + 1; rowIndex < lines.length; rowIndex += 1) {
-            const line = lines[rowIndex];
-            if (!line.includes("|")) {
-                break;
-            }
-            if (isSeparatorLine(line)) {
-                continue;
-            }
-            const values = splitTableLine(line);
-            const cells = {};
-            for (const [cellIndex, header] of normalized.entries()) {
-                cells[header] = values[cellIndex]?.trim() ?? "";
-            }
-            rows.push({
-                index: rows.length + 1,
-                line: rowIndex + 1,
-                cells,
-                text: Object.values(cells).join(" ")
-            });
-        }
-        const missing = expectedHeaders.filter((header) => !normalized.includes(normalizeHeader(header)));
-        if (missing.length > 0) {
-            errors.push(`${label} table is missing column(s): ${missing.join(", ")}`);
-        }
-        return { rows, headers: normalized };
-    }
-    errors.push(`${label} section must include a markdown table with columns: ${expectedHeaders.join(" | ")}`);
-    return undefined;
-}
-export function cell(row, header) {
-    return row.cells[normalizeHeader(header)] ?? "";
-}
-export function isBlankish(value) {
-    if (Array.isArray(value)) {
-        return value.length === 0 || value.every(isBlankish);
-    }
-    if (value === undefined || value === null) {
-        return true;
-    }
-    const text = String(value).trim().toLowerCase();
-    return text === "" || text === "-" || text === "n/a" || text === "na" || text === "none" || text === "[]" || text === "not applicable";
-}
-export function weakProofHit(text) {
-    return WEAK_PROOF_PATTERNS.find((pattern) => pattern.test(text))?.source;
-}
-export async function assertReferencedPathsExist(projectRoot, label, text, errors) {
-    for (const reference of extractPathReferences(text)) {
-        const absolute = path.resolve(projectRoot, reference);
-        if (!isInside(projectRoot, absolute)) {
-            errors.push(`${label} references a path outside the project root: ${reference}`);
-            continue;
-        }
-        if (!(await pathExists(absolute))) {
-            errors.push(`${label} references missing path: ${reference}`);
-        }
-    }
-}
-export function primitiveText(value) {
-    if (value === undefined || value === null) {
-        return "";
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        return String(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map(primitiveText).join(" ");
-    }
-    if (typeof value === "object") {
-        return Object.values(value).map(primitiveText).join(" ");
-    }
-    return "";
-}
-export function valuesAsArray(value) {
-    if (Array.isArray(value)) {
-        return value.flatMap(valuesAsArray);
-    }
-    if (isBlankish(value)) {
-        return [];
-    }
-    return String(value)
-        .split(/[,;\n]/)
-        .map((item) => item.trim())
-        .filter(Boolean);
-}
-export function hasRealPageEvidence(text) {
-    return /\b(real[- ]page|browser|route|screen|screenshot|url|localhost|https?:\/\/|page)\b/i.test(text);
-}
-export function isUiFacing(text) {
-    return /\b(ui|browser|page|screen|console|frontend|route|surface)\b/i.test(text);
-}
-export function isRuntimeFacing(text) {
-    return /\b(runtime|worker|api|schema|endpoint|service|queue|daemon|runner)\b/i.test(text);
-}
-function sectionBody(content, heading) {
-    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const match = new RegExp(`^##\\s+${escaped}\\s*$`, "im").exec(content);
-    if (!match) {
-        return undefined;
-    }
-    const rest = content.slice(match.index + match[0].length);
-    const next = /^##\s+/m.exec(rest);
-    return next ? rest.slice(0, next.index) : rest;
-}
-function splitTableLine(line) {
-    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cellValue) => cellValue.trim());
-}
-function isSeparatorLine(line) {
-    return splitTableLine(line).every((value) => /^:?-{3,}:?$/.test(value.trim()));
-}
-function normalizeHeader(value) {
-    return value.replace(/`/g, "").trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
-}
-function extractPathReferences(text) {
-    const references = new Set();
-    for (const match of text.matchAll(PATH_PATTERN)) {
-        const raw = (match[1] ?? match[2] ?? "").trim();
-        if (!raw || raw.includes("*") || /^https?:\/\//i.test(raw)) {
-            continue;
-        }
-        references.add(raw.replace(/\\/g, "/").replace(/^\.\//, "").replace(/[),.;:]+$/, ""));
-    }
-    return [...references];
-}
-function isInside(root, target) {
-    const relative = path.relative(root, target);
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}

package/dist/lib/superpowers-task-ac010.d.ts

@@ -1,6 +0,0 @@
-import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface Ac010BootstrapResult {
-    invalidated_ac_ids: string[];
-    errors: string[];
-}
-export declare function evaluateAc010Bootstrap(state: SuperpowersTaskState, acStatuses: Record<string, string>): Ac010BootstrapResult;

package/dist/lib/superpowers-task-ac010.js

@@ -1,26 +0,0 @@
-const SUMMARY_ONLY = /\b(AC[-_ ]?010|final[-_ ]?gate|summary|final[-_ ]?acceptance[-_ ]?verdict|final[-_ ]?summary|matrix|validator)\b/i;
-export function evaluateAc010Bootstrap(state, acStatuses) {
-    const invalidated = [];
-    const errors = [];
-    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
-        if (!isSummaryAc(acId, ac)) {
-            continue;
-        }
-        if (acStatuses[acId] !== "complete" && ac.status !== "complete") {
-            continue;
-        }
-        const incomplete = Object.keys(state.graph.acceptance_criteria).filter((otherId) => otherId !== acId && acIsRequired(otherId) && acStatuses[otherId] !== "complete" && acStatuses[otherId] !== "out_of_scope_NA");
-        if (incomplete.length === 0) {
-            continue;
-        }
-        invalidated.push(acId);
-        errors.push(`${acId} final_gate_cannot_bootstrap_from_summary_only: summary AC cannot prove incomplete ACs ${incomplete.join(", ")}`);
-    }
-    return { invalidated_ac_ids: invalidated, errors };
-}
-function isSummaryAc(acId, ac) {
-    return /^AC-?0?10$/i.test(acId) || SUMMARY_ONLY.test([ac.scope ?? "", ac.assertion_command ?? "", ...(ac.final_evidence_expected ?? [])].join("\n"));
-}
-function acIsRequired(acId) {
-    return !/^AC-?0?10$/i.test(acId);
-}

package/dist/lib/superpowers-task-assertion-normalizers.d.ts

@@ -1,3 +0,0 @@
-import { type AssertionResult, type NegativeEvidenceScan } from "./superpowers-task-state-schema.js";
-export declare function normalizeAssertionResult(value: unknown): AssertionResult | undefined;
-export declare function normalizeNegativeEvidenceScan(value: unknown): NegativeEvidenceScan | undefined;