project-tiny-context-harness 0.2.80 → 0.2.81

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

@@ -0,0 +1,20 @@
+import { type SuperpowersEvidenceRecord, type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
+export type AssertionStatus = "passed" | "failed" | "missing" | "stale" | "not_applicable";
+export interface ProofLayerAssertionEvaluation {
+    assertion_status: AssertionStatus;
+    blocking_assertion_failures: string[];
+    negative_evidence_findings: string[];
+}
+export declare const MACHINE_VERIFIABLE_PROOF_LAYERS: Set<string>;
+export declare const UI_BROWSER_ASSERTION_TYPES: Set<string>;
+export declare function proofLayerName(layerId: string): string;
+export declare function proofLayerAcId(layerId: string): string;
+export declare function isMachineVerifiableLayer(layerId: string): boolean;
+export declare function isUiBrowserLayer(layerId: string): boolean;
+export declare function evaluateAcEvidence(state: SuperpowersTaskState, acId: string): ProofLayerAssertionEvaluation;
+export declare function evaluateProofLayer(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
+export declare function evaluateProofLayerAssertions(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
+export declare function assertionFailuresForState(state: SuperpowersTaskState): string[];
+export declare function evaluateAssertionEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];
+export declare function evaluateNegativeEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];

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

@@ -0,0 +1,242 @@
+export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
+export const MACHINE_VERIFIABLE_PROOF_LAYERS = new Set([
+    "ui_browser",
+    "api_schema",
+    "runtime",
+    "worker_runtime",
+    "data_artifact",
+    "integration",
+    "security_redaction",
+    "test",
+    "all_provider_all_runner",
+    "cleanup_stale_scan"
+]);
+export const UI_BROWSER_ASSERTION_TYPES = new Set(["browser_assertion", "playwright_assertion", "ui_browser_assertion"]);
+const DEFAULT_UI_FORBIDDEN_FINAL_STATES = ["未验证", "不可用", "暂不可用", "页面无明显变化"];
+const GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS = [
+    /\bfinal[-_ ]?(?:result[-_ ]?)?card\b/i,
+    /\b(?:plan[-_ ]?conformance[-_ ]?)?matrix\b/i,
+    /\b(?:final[-_ ]?acceptance[-_ ]?)?verdict\b/i,
+    /\bvalidator[-_ ]?pass\b/i,
+    /\bauditor[-_ ]?pass\b/i,
+    /\bsubagent[-_ ]?summary\b/i,
+    /\bagent[-_ ]?summary\b/i,
+    /\bprose[-_ ]?summary\b/i,
+    /\bfile[-_ ]?exists\b/i,
+    /\bartifact[-_ ]?exists\b/i,
+    /\btest[-_ ]?name[-_ ]?only\b/i,
+    /\bdiagnostic[-_ ]?(?:surface|page)?\b/i,
+    /\blocal[-_ ]?audit\b/i,
+    /\bcomponent[-_ ]?screenshot\b/i,
+    /\bstorybook\b/i,
+    /\bdom[-_ ]?snippet\b/i,
+    /\bsample[-_ ]?for[-_ ]?full[-_ ]?population\b/i
+];
+export function proofLayerName(layerId) {
+    return layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+}
+export function proofLayerAcId(layerId) {
+    return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
+}
+export function isMachineVerifiableLayer(layerId) {
+    return MACHINE_VERIFIABLE_PROOF_LAYERS.has(proofLayerName(layerId));
+}
+export function isUiBrowserLayer(layerId) {
+    return proofLayerName(layerId) === "ui_browser";
+}
+export function evaluateAcEvidence(state, acId) {
+    const ac = state.graph.acceptance_criteria[acId];
+    if (!ac) {
+        return {
+            assertion_status: "missing",
+            blocking_assertion_failures: [`AC ${acId} missing from task graph`],
+            negative_evidence_findings: []
+        };
+    }
+    const evaluations = ac.required_proof_layers.map((layer) => evaluateProofLayer(state, `${acId}.${layer}`));
+    const applicable = evaluations.filter((item) => item.assertion_status !== "not_applicable");
+    const blocking_assertion_failures = applicable.flatMap((item) => item.blocking_assertion_failures);
+    const negative_evidence_findings = applicable.flatMap((item) => item.negative_evidence_findings);
+    const statuses = applicable.map((item) => item.assertion_status);
+    const assertion_status = applicable.length === 0
+        ? "not_applicable"
+        : statuses.includes("failed")
+            ? "failed"
+            : statuses.includes("stale")
+                ? "stale"
+                : statuses.includes("missing")
+                    ? "missing"
+                    : "passed";
+    return { assertion_status, blocking_assertion_failures, negative_evidence_findings };
+}
+export function evaluateProofLayer(state, layerId) {
+    return evaluateProofLayerAssertions(state, layerId);
+}
+export function evaluateProofLayerAssertions(state, layerId) {
+    if (!isMachineVerifiableLayer(layerId)) {
+        return { assertion_status: "not_applicable", blocking_assertion_failures: [], negative_evidence_findings: [] };
+    }
+    const layer = state.graph.proof_layers[layerId];
+    const evidenceById = new Map((state.evidence ?? []).map((item) => [item.evidence_id, item]));
+    const evidenceRecords = (layer?.evidence_ids ?? []).map((id) => evidenceById.get(id)).filter((item) => Boolean(item));
+    if (!layer || evidenceRecords.length === 0) {
+        return {
+            assertion_status: "missing",
+            blocking_assertion_failures: [`proof layer ${layerId} missing assertion result`],
+            negative_evidence_findings: []
+        };
+    }
+    const blocking = [];
+    const negative = [];
+    for (const evidence of evidenceRecords) {
+        blocking.push(...evaluateAssertionEvidence(evidence, layerId));
+        negative.push(...evaluateNegativeEvidence(evidence, layerId));
+    }
+    const combined = [...blocking, ...negative];
+    if (combined.length === 0) {
+        return { assertion_status: "passed", blocking_assertion_failures: [], negative_evidence_findings: [] };
+    }
+    const text = combined.join("\n");
+    const status = /missing assertion result/i.test(text)
+        ? "missing"
+        : /\bstale\b/i.test(text)
+            ? "stale"
+            : "failed";
+    return { assertion_status: status, blocking_assertion_failures: blocking, negative_evidence_findings: negative };
+}
+export function assertionFailuresForState(state) {
+    return Object.keys(state.graph?.proof_layers ?? {}).flatMap((layerId) => {
+        const evaluation = evaluateProofLayerAssertions(state, layerId);
+        return [...evaluation.blocking_assertion_failures, ...evaluation.negative_evidence_findings];
+    });
+}
+export function evaluateAssertionEvidence(evidence, layerId) {
+    const failures = [];
+    const acId = proofLayerAcId(layerId);
+    const layerName = proofLayerName(layerId);
+    const assertion = evidence.assertion_result;
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    const invalidEvidence = invalidEvidenceReason(evidence, layerName);
+    if (invalidEvidence) {
+        failures.push(`${label} invalid evidence forbidden shortcut ${evidence.type || "(missing)"} cannot satisfy ${layerName}: ${invalidEvidence}`);
+    }
+    if (!assertion) {
+        failures.push(`${label} missing assertion result; ${layerName} proof not machine-backed`);
+        return failures;
+    }
+    if (assertion.schema_version !== "assertion-result-v1") {
+        failures.push(`${label} assertion_result.schema_version must be assertion-result-v1`);
+    }
+    if (assertion.status !== "passed") {
+        failures.push(`${label} assertion_result.status=${assertion.status}; expected passed`);
+    }
+    if (assertion.exit_code !== 0) {
+        failures.push(`${label} assertion exit_code=${assertion.exit_code}; expected 0`);
+    }
+    if (evidence.command_exit_code !== undefined && evidence.command_exit_code !== 0) {
+        failures.push(`${label} command_exit_code=${evidence.command_exit_code}; expected 0`);
+    }
+    if (!assertion.target_ac_ids.includes(acId)) {
+        failures.push(`${label} assertion target ACs ${assertion.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
+    }
+    if (!assertion.target_proof_layers.includes(layerId) && !assertion.target_proof_layers.includes(layerName)) {
+        failures.push(`${label} assertion target_proof_layers ${assertion.target_proof_layers.join(", ") || "(none)"} do not include ${layerId} or ${layerName}`);
+    }
+    failures.push(...checkAssertions(`${label} positive assertion`, assertion.positive_assertions));
+    failures.push(...checkAssertions(`${label} negative assertion`, assertion.negative_assertions));
+    if ((assertion.artifacts?.length ?? 0) === 0 && evidence.artifact_paths.length === 0) {
+        failures.push(`${label} assertion-backed evidence must include artifacts`);
+    }
+    if (isUiBrowserLayer(layerId)) {
+        failures.push(...validateUiBrowserAssertion(evidence, assertion, layerId));
+    }
+    return failures;
+}
+function validateUiBrowserAssertion(evidence, assertion, layerId) {
+    const failures = [];
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    if (!UI_BROWSER_ASSERTION_TYPES.has(evidence.type)) {
+        const apiOnly = /\bapi\b/i.test(evidence.type) ? "; API-only cannot satisfy UI Path AC" : "";
+        failures.push(`${label} ui_browser evidence type ${evidence.type || "(missing)"} is not allowed${apiOnly}`);
+    }
+    if (!assertion.owner_surface) {
+        failures.push(`${label} missing owner_surface`);
+    }
+    if (!assertion.route) {
+        failures.push(`${label} missing route`);
+    }
+    if (!assertion.action) {
+        failures.push(`${label} missing action-level UI proof`);
+    }
+    const artifacts = [...(assertion.artifacts ?? []), ...evidence.artifact_paths];
+    if (!artifacts.some((artifact) => /\.(png|jpe?g|zip|json)$/i.test(artifact) || /\b(trace|screenshot|report)\b/i.test(artifact))) {
+        failures.push(`${label} ui_browser assertion must include screenshot, trace or report artifact`);
+    }
+    const negativeCoverage = assertion.negative_assertions.map((item) => `${item.id} ${item.forbidden_text ?? ""}`).join("\n");
+    for (const forbidden of DEFAULT_UI_FORBIDDEN_FINAL_STATES) {
+        if (!negativeCoverage.includes(forbidden)) {
+            failures.push(`${label} missing negative assertion coverage for forbidden final state ${forbidden}`);
+        }
+    }
+    if (!evidence.negative_evidence_scan) {
+        failures.push(`${label} missing negative_evidence_scan for ui_browser layer`);
+    }
+    return failures;
+}
+function checkAssertions(prefix, checks) {
+    return checks
+        .filter((check) => check.status !== "passed")
+        .map((check) => `${prefix} ${check.id || "(unnamed)"} status=${check.status}; expected passed${check.forbidden_text ? ` forbidden_text=${check.forbidden_text}` : ""}`);
+}
+export function evaluateNegativeEvidence(evidence, layerId) {
+    const scan = evidence.negative_evidence_scan;
+    if (!scan) {
+        return [];
+    }
+    const acId = proofLayerAcId(layerId);
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    const findings = [];
+    if (scan.schema_version !== "negative-evidence-scan-v1") {
+        findings.push(`${label} negative_evidence_scan.schema_version must be negative-evidence-scan-v1`);
+    }
+    if (scan.status !== "passed") {
+        findings.push(`${label} negative evidence scan status=${scan.status}; expected passed`);
+    }
+    if (!scan.target_ac_ids.includes(acId)) {
+        findings.push(`${label} negative evidence scan target ACs ${scan.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
+    }
+    for (const finding of scan.forbidden_findings ?? []) {
+        if (finding.status === "found") {
+            findings.push(`${label} negative evidence found forbidden text ${finding.forbidden_text ?? finding.id}: ${finding.actual ?? ""}`.trim());
+        }
+    }
+    for (const required of scan.required_findings ?? []) {
+        if (required.status !== "passed") {
+            findings.push(`${label} negative evidence required finding ${required.id} status=${required.status}; expected passed`);
+        }
+    }
+    if ((scan.artifacts ?? []).length === 0) {
+        findings.push(`${label} negative evidence scan must include artifacts`);
+    }
+    return findings;
+}
+function invalidEvidenceReason(evidence, layerName) {
+    const evidenceText = [evidence.type, evidence.command, ...evidence.artifact_paths, ...evidence.proves, ...evidence.does_not_prove].join("\n");
+    const genericShortcut = GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS.find((pattern) => pattern.test(evidenceText));
+    if (genericShortcut) {
+        return `matches invalid completion evidence ${genericShortcut}`;
+    }
+    if ((layerName === "runtime" || layerName === "worker_runtime" || layerName === "integration" || layerName === "ui_browser") && /\b(unit|mock|viewmodel)\b/i.test(evidence.type)) {
+        return "unit, mock or viewmodel evidence is auxiliary only for runtime, worker, integration and UI layers";
+    }
+    if (layerName === "ui_browser" && /\b(api|schema)\b/i.test(evidence.type)) {
+        return "API-only evidence cannot satisfy UI Path AC";
+    }
+    if (layerName === "ui_browser" && /^screenshot$/i.test(evidence.type)) {
+        return "screenshot-only evidence cannot satisfy UI Path AC";
+    }
+    if ((layerName === "runtime" || layerName === "worker_runtime" || layerName === "data_artifact" || layerName === "security_redaction") && /\b(ui|browser|playwright|screenshot)\b/i.test(evidence.type)) {
+        return "UI-only evidence cannot satisfy runtime, data or security proof layers";
+    }
+    return undefined;
+}

package/dist/lib/superpowers-task-compile-diagnostics.d.ts

@@ -0,0 +1,5 @@
+export type CompileReportCategory = "blocking_missing_source" | "blocking_missing_plan" | "blocking_missing_checklist" | "blocking_unparseable_object" | "blocking_scope_conflict" | "blocking_missing_assertion_spec" | "blocking_missing_owner_boundary" | "blocking_missing_primary_path" | "blocking_missing_observable_result" | "blocking_missing_invalid_evidence" | "warning_weak_acceptance_wording" | "hygiene_non_canonical_field_order";
+export declare function compileError(message: string, category: CompileReportCategory, file: string, line: number, field: string, whyBlocking: string, requiredFix: string): string;
+export declare function compileReportSuffix(category: CompileReportCategory, file: string, line: number, field: string, whyBlocking: string, requiredFix: string): string;
+export declare function missingCategory(label: string): CompileReportCategory;
+export declare function throwCompileErrors(errors: string[]): void;

package/dist/lib/superpowers-task-compile-diagnostics.js

@@ -0,0 +1,20 @@
+export function compileError(message, category, file, line, field, whyBlocking, requiredFix) {
+    return `${message}${compileReportSuffix(category, file, line, field, whyBlocking, requiredFix)}`;
+}
+export function compileReportSuffix(category, file, line, field, whyBlocking, requiredFix) {
+    return ` [category=${category}; file=${file}; line=${line}; invalid_or_missing_field=${field}; why_blocking=${whyBlocking}; required_fix=${requiredFix}; rerun_compile_enough=true]`;
+}
+export function missingCategory(label) {
+    if (/^PI-\d+/i.test(label)) {
+        return "blocking_missing_plan";
+    }
+    if (/^AC-\d+/i.test(label)) {
+        return "blocking_missing_checklist";
+    }
+    return "blocking_missing_source";
+}
+export function throwCompileErrors(errors) {
+    if (errors.length > 0) {
+        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
+    }
+}

package/dist/lib/superpowers-task-compile-guards.d.ts

@@ -0,0 +1,2 @@
+import { type SuperpowersAcceptanceCriterion, type SuperpowersPlanItem, type SuperpowersProductArchitectureScope } from "./superpowers-task-state-schema.js";
+export declare function validateCompiledSources(product: SuperpowersProductArchitectureScope, planItems: Record<string, SuperpowersPlanItem>, acceptanceCriteria: Record<string, SuperpowersAcceptanceCriterion>): void;

package/dist/lib/superpowers-task-compile-guards.js

@@ -0,0 +1,66 @@
+import { MACHINE_VERIFIABLE_PROOF_LAYERS } from "./superpowers-task-assertions.js";
+import { compileError, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
+const ALLOWED_PROOF_LAYERS = new Set(["code", ...MACHINE_VERIFIABLE_PROOF_LAYERS]);
+export function validateCompiledSources(product, planItems, acceptanceCriteria) {
+    const errors = [];
+    const planIds = new Set(Object.keys(planItems));
+    const acIds = new Set(Object.keys(acceptanceCriteria));
+    for (const [planId, item] of Object.entries(planItems)) {
+        validatePlanItem(planId, item, acIds, acceptanceCriteria, errors);
+    }
+    for (const [acId, ac] of Object.entries(acceptanceCriteria)) {
+        validateAcceptanceCriterion(product, acId, ac, planIds, planItems, errors);
+    }
+    throwCompileErrors(errors);
+}
+function validatePlanItem(planId, item, acIds, acceptanceCriteria, errors) {
+    for (const acId of item.related_acs) {
+        if (!acIds.has(acId)) {
+            errors.push(compileError(`${planId} references unknown related_acs ${acId}`, "blocking_unparseable_object", item.source_file, item.source_start_line, "related_acs", "dangling plan-to-AC references make the graph ambiguous", "fix related_acs to existing AC ids"));
+        }
+    }
+    if (item.delivery_scope !== "out_of_scope_backlog" && item.implementation_paths.length === 0) {
+        errors.push(compileError(`${planId} missing implementation_paths`, "blocking_missing_primary_path", item.source_file, item.source_start_line, "implementation_paths", "plan conformance needs an implementation owner path", "add implementation_paths or mark the item out_of_scope_backlog"));
+    }
+    if (item.owner_surfaces.length > 0) {
+        const related = item.related_acs.length > 0 ? item.related_acs : Object.keys(acceptanceCriteria);
+        const hasUiLayer = related.some((acId) => acceptanceCriteria[acId]?.required_proof_layers.includes("ui_browser"));
+        if (!hasUiLayer) {
+            errors.push(compileError(`${planId} owner_surfaces requires a ui_browser proof layer`, "blocking_missing_owner_boundary", item.source_file, item.source_start_line, "owner_surfaces", "owner-surface work must have browser proof on the owner route", "add ui_browser to a related AC required_proof_layers"));
+        }
+    }
+}
+function validateAcceptanceCriterion(product, acId, ac, planIds, planItems, errors) {
+    for (const planId of ac.related_plan_items) {
+        if (!planIds.has(planId)) {
+            errors.push(compileError(`${acId} references unknown related_plan_items ${planId}`, "blocking_unparseable_object", ac.source_file, ac.source_start_line, "related_plan_items", "dangling AC-to-plan references make the graph ambiguous", "fix related_plan_items to existing PI ids"));
+        }
+    }
+    for (const layer of ac.required_proof_layers) {
+        if (!ALLOWED_PROOF_LAYERS.has(layer)) {
+            errors.push(compileError(`${acId} has invalid required_proof_layers ${layer}`, "blocking_unparseable_object", ac.source_file, ac.source_start_line, "required_proof_layers", "unknown proof layers cannot be evaluated", "use code or a supported machine-verifiable proof layer"));
+        }
+    }
+    if (ac.ac_validates.length === 0) {
+        errors.push(compileError(`${acId} missing observable acceptance result`, "blocking_missing_observable_result", ac.source_file, ac.source_start_line, "ac_validates", "ACs need an observable result before evidence can prove completion", "add concrete ac_validates outcomes"));
+    }
+    const machineRequirements = (ac.assertion_requirements ?? []).filter((item) => item.machine_blocking);
+    if (machineRequirements.some((item) => item.positive_assertions.length === 0)) {
+        errors.push(compileError(`${acId} machine-verifiable proof layer lacks positive assertion requirements`, "blocking_missing_assertion_spec", ac.source_file, ac.source_start_line, "assertion_requirements", "machine-verifiable ACs need observable positive assertions", "add ac_validates, required_test_ids, test_cases or final_evidence_expected"));
+    }
+    if (machineRequirements.some((item) => item.negative_assertions.length === 0)) {
+        errors.push(compileError(`${acId} machine-verifiable proof layer lacks negative assertion requirements`, "blocking_missing_invalid_evidence", ac.source_file, ac.source_start_line, "invalid_evidence", "negative assertions prevent forbidden completion shortcuts", "add ac_does_not_validate, fail_conditions or invalid_evidence"));
+    }
+    const relatedPlans = ac.related_plan_items.map((planId) => planItems[planId]).filter(Boolean);
+    if (ac.full_population_required === true && relatedPlans.length > 0 && relatedPlans.every((item) => item.delivery_scope === "representative_sample_validation")) {
+        errors.push(compileError(`${acId} full-population AC is backed only by representative sample plan items`, "blocking_scope_conflict", ac.source_file, ac.source_start_line, "full_population_required", "sample-only plan items cannot prove full-population acceptance", "add a full_population_operation plan item or change the AC boundary"));
+    }
+    const productNonCompleting = product.representative_samples_do_not_validate.join("\n");
+    if (productNonCompleting && !containsAny(ac.ac_does_not_validate, product.representative_samples_do_not_validate)) {
+        errors.push(compileError(`${acId} does not represent Product non-completing outcomes`, "blocking_missing_invalid_evidence", ac.source_file, ac.source_start_line, "ac_does_not_validate", "Product non-completing outcomes must remain visible in AC invalid evidence", "add matching ac_does_not_validate or invalid_evidence entries"));
+    }
+}
+function containsAny(values, needles) {
+    const text = values.join("\n").toLowerCase();
+    return needles.some((needle) => text.includes(needle.toLowerCase()));
+}

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

@@ -1,11 +1,14 @@
 import path from "node:path";
-import { readText } from "./fs.js";
+import { pathExists, readText } from "./fs.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { compileError, compileReportSuffix, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
+import { validateCompiledSources } from "./superpowers-task-compile-guards.js";
 import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState, refreshSourceHashes } from "./superpowers-task-state.js";
 import { DEFAULT_LAYERS, parseAcceptanceCriteria, parsePlanItems, parseProductArchitectureScope } from "./superpowers-task-source-compile.js";
 export async function compileSuperpowersTask(workdir) {
     const state = await loadSuperpowersState(workdir);
     await refreshSourceHashes(workdir, state);
+    await assertRequiredSourcesExist(workdir, state);
     const productSource = await readText(path.join(workdir, state.sources.product_architecture_source.path));
     const technicalPlan = await readText(path.join(workdir, state.sources.technical_realization_plan.path));
     const checklist = await readText(path.join(workdir, state.sources.acceptance_checklist.path));
@@ -15,6 +18,7 @@ export async function compileSuperpowersTask(workdir) {
     };
     const planItems = parsePlanItems(technicalPlan, state.sources.technical_realization_plan.path);
     const acceptanceCriteria = parseAcceptanceCriteria(checklist, state.sources.acceptance_checklist.path);
+    validateCompiledSources(state.delivery.product_architecture_scope, planItems, acceptanceCriteria);
     const acIds = Object.keys(acceptanceCriteria);
     for (const [planId, item] of Object.entries(planItems)) {
         if (item.related_acs.length === 0) {
@@ -46,6 +50,22 @@ export async function compileSuperpowersTask(workdir) {
     });
     return state;
 }
+async function assertRequiredSourcesExist(workdir, state) {
+    const errors = [];
+    const checks = [
+        ["product_architecture_source", "blocking_missing_source", "Product / Architecture Source"],
+        ["technical_realization_plan", "blocking_missing_plan", "Technical Realization Plan"],
+        ["acceptance_checklist", "blocking_missing_checklist", "Acceptance Checklist"]
+    ];
+    for (const [key, category, label] of checks) {
+        const source = state.sources[key];
+        const file = source?.path ?? `${key}.md`;
+        if (!source || !(await pathExists(path.join(workdir, file)))) {
+            errors.push(compileError(`${label} input is missing: ${file}`, category, file, 1, key, "all three authority inputs are required", "restore the missing source file and rerun compile"));
+        }
+    }
+    throwCompileErrors(errors);
+}
 export function computeScopeConflicts(state) {
     const conflicts = [];
     const product = state.delivery?.product_architecture_scope;
@@ -56,18 +76,18 @@ export function computeScopeConflicts(state) {
         product?.full_population_required === false;
     for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
         if (productRequiresFullPopulation && item.delivery_scope !== "full_population_operation" && item.delivery_scope !== "out_of_scope_backlog") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${planId} delivery_scope=${item.delivery_scope || "missing"}`);
+            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${planId} delivery_scope=${item.delivery_scope || "missing"}${compileReportSuffix("blocking_scope_conflict", item.source_file, item.source_start_line, "delivery_scope", "Product source and plan delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
         }
         if (productIsCapabilityOnly && item.delivery_scope === "full_population_operation" && productScope !== "mixed_scope_requires_boundary") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${planId} delivery_scope=full_population_operation`);
+            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${planId} delivery_scope=full_population_operation${compileReportSuffix("blocking_scope_conflict", item.source_file, item.source_start_line, "delivery_scope", "Product source and plan delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
         }
     }
     for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
         if (productRequiresFullPopulation && (ac.acceptance_scope === "full_population_not_required" || ac.full_population_required === false)) {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${acId} full_population_required=false`);
+            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${acId} full_population_required=false${compileReportSuffix("blocking_scope_conflict", ac.source_file, ac.source_start_line, "full_population_required", "Product source and checklist full-population requirements disagree", "align the source, plan and checklist delivery scope")}`);
         }
         if (productIsCapabilityOnly && (ac.acceptance_scope === "full_population_operation" || ac.full_population_required === true) && productScope !== "mixed_scope_requires_boundary") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${acId} acceptance_scope=full_population_operation`);
+            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${acId} acceptance_scope=full_population_operation${compileReportSuffix("blocking_scope_conflict", ac.source_file, ac.source_start_line, "acceptance_scope", "Product source and checklist delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
         }
     }
     return [...new Set(conflicts)];

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

@@ -0,0 +1,2 @@
+import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function validatePlanCompletionConformance(state: SuperpowersTaskState, errors: string[]): void;

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

@@ -0,0 +1,24 @@
+import { primitiveText } from "./plan-validator-common.js";
+export function validatePlanCompletionConformance(state, errors) {
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        if (item.status !== "complete") {
+            continue;
+        }
+        if (item.implementation_paths.length === 0 && item.delivery_scope !== "out_of_scope_backlog") {
+            errors.push(`plan item ${planId} is complete but has no implementation_paths`);
+        }
+        if ((item.owner_surfaces ?? []).length > 0 && !item.required_proof_layers.some((layer) => layer.endsWith(".ui_browser"))) {
+            errors.push(`plan item ${planId} is complete but owner_surfaces has no related ui_browser proof layer`);
+        }
+        if ((item.required_tests ?? []).length === 0 && item.explicit_no_test_scope !== true) {
+            errors.push(`plan item ${planId} is complete but required_tests is empty and no explicit_no_test_scope is recorded`);
+        }
+        const shortcuts = item.non_completing_shortcuts ?? [];
+        const evidenceText = primitiveText(state.evidence.filter((evidence) => evidence.proves.some((layer) => item.required_proof_layers.includes(layer))));
+        for (const shortcut of shortcuts) {
+            if (shortcut && evidenceText.toLowerCase().includes(shortcut.toLowerCase())) {
+                errors.push(`plan item ${planId} is complete but evidence uses forbidden shortcut: ${shortcut}`);
+            }
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
+import { evaluateProofLayerAssertions } from "./superpowers-task-assertions.js";
 export async function deriveSuperpowersArtifacts(workdir) {
     const state = await loadSuperpowersState(workdir);
     const derived = deriveObjects(state);
@@ -23,8 +24,10 @@ export function deriveObjects(state) {
     const matrixRows = Object.entries(state.graph.plan_items).map(([planItemId, item]) => {
         const relatedAcs = item.related_acs;
         const requiredLayers = item.required_proof_layers;
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
+        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
         const evidenceIds = evidenceForLayers(state, requiredLayers);
+        const invalidEvidence = invalidEvidenceSignals(assertionSummary);
         return {
             plan_item_id: planItemId,
             plan_requirement: item.requirement,
@@ -51,16 +54,24 @@ export function deriveObjects(state) {
             required_proof_layers: requiredLayers,
             satisfied_proof_layers: requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied"),
             missing_required_layers: missingLayers,
+            assertion_status: assertionSummary.assertion_status,
+            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
+            negative_evidence_findings: assertionSummary.negative_evidence_findings,
+            invalid_evidence: invalidEvidence,
+            forbidden_shortcuts_hit: invalidEvidence.filter((item) => /forbidden shortcut|cannot satisfy/i.test(item)),
             evidence_ids: evidenceIds,
             scope_assessment: missingLayers.length === 0 ? "full" : "partial",
-            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers"
+            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers",
+            decision: missingLayers.length === 0 ? "accept" : "continue"
         };
     });
     const verdictRows = Object.entries(state.graph.acceptance_criteria).map(([acId, ac]) => {
         const requiredLayers = ac.required_proof_layers.map((layer) => `${acId}.${layer}`);
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
+        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
         const evidenceIds = evidenceForLayers(state, requiredLayers);
         const status = missingLayers.length === 0 && requiredLayers.length > 0 ? "complete" : evidenceIds.length > 0 ? "partial" : ac.status;
+        const invalidCompletionSignals = invalidEvidenceSignals(assertionSummary);
         return {
             ac_id: acId,
             related_plan_item_ids: ac.related_plan_items,
@@ -76,6 +87,11 @@ export function deriveObjects(state) {
             fresh_evidence: evidenceText(state, evidenceIds),
             missing_evidence: [],
             missing_required_layers: missingLayers,
+            assertion_status: assertionSummary.assertion_status,
+            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
+            negative_evidence_findings: assertionSummary.negative_evidence_findings,
+            invalid_completion_signals: invalidCompletionSignals,
+            required_next_evidence: requiredNextEvidence(missingLayers, assertionSummary),
             contradictions: [],
             context_fact_refs: [],
             evidence_ids: evidenceIds,
@@ -88,6 +104,16 @@ export function deriveObjects(state) {
     const allComplete = verdictRows.length > 0 && verdictRows.every((row) => row.status === "complete");
     const progress = {
         ...state.progress,
+        acceptance_progress: {
+            status: allComplete ? "complete" : "partial",
+            complete_count: verdictRows.filter((row) => row.status === "complete").length,
+            required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length
+        },
+        engineering_implementation_progress: progressStatus(Object.values(state.graph.plan_items).map((item) => item.status)),
+        runtime_proof_progress: progressStatus(Object.values(state.graph.proof_layers).map((layer) => layer.status)),
+        proof_layer_milestones: Object.entries(state.graph.proof_layers).map(([layerId, layer]) => ({ layer_id: layerId, status: layer.status, evidence_ids: layer.evidence_ids })),
+        artifact_budget: { evidence_records: state.evidence.length, artifact_count: state.evidence.reduce((sum, item) => sum + item.artifact_paths.length, 0) },
+        workflow_overhead: { slices: state.slices.length, blockers: state.blockers.length },
         complete_count: verdictRows.filter((row) => row.status === "complete").length,
         partial_count: verdictRows.filter((row) => row.status === "partial").length,
         acceptance_required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length,
@@ -103,6 +129,16 @@ export function deriveObjects(state) {
         progress
     };
 }
+function invalidEvidenceSignals(summary) {
+    return [...summary.blocking_assertion_failures, ...summary.negative_evidence_findings].filter((item) => /invalid evidence|forbidden shortcut|cannot satisfy|negative evidence|forbidden text/i.test(item));
+}
+function requiredNextEvidence(missingLayers, summary) {
+    return [...missingLayers.map((layerId) => `fresh assertion-backed evidence for ${layerId}`), ...summary.blocking_assertion_failures, ...summary.negative_evidence_findings];
+}
+function progressStatus(statuses) {
+    const complete = statuses.filter((status) => status === "complete" || status === "satisfied").length;
+    return { status: statuses.length > 0 && complete === statuses.length ? "complete" : complete > 0 ? "partial" : "not_started", complete, total: statuses.length };
+}
 export async function derivedMatchesState(workdir, state) {
     const errors = [];
     const expected = deriveObjects(state);
@@ -123,15 +159,35 @@ async function assertDerivedJson(workdir, basename, expected, errors) {
 function evidenceForLayers(state, layerIds) {
     return [...new Set(layerIds.flatMap((layerId) => state.graph.proof_layers[layerId]?.evidence_ids ?? []))];
 }
+function assertionSummaryForLayers(state, layerIds) {
+    const evaluations = layerIds.map((layerId) => evaluateProofLayerAssertions(state, layerId));
+    const applicable = evaluations.filter((item) => item.assertion_status !== "not_applicable");
+    const blocking_assertion_failures = applicable.flatMap((item) => item.blocking_assertion_failures);
+    const negative_evidence_findings = applicable.flatMap((item) => item.negative_evidence_findings);
+    const statuses = applicable.map((item) => item.assertion_status);
+    const assertion_status = applicable.length === 0
+        ? "not_applicable"
+        : statuses.includes("failed")
+            ? "failed"
+            : statuses.includes("stale")
+                ? "stale"
+                : statuses.includes("missing")
+                    ? "missing"
+                    : "passed";
+    return { assertion_status, blocking_assertion_failures, negative_evidence_findings };
+}
 function evidenceText(state, evidenceIds, type) {
     return evidenceIds
         .map((evidenceId) => state.evidence.find((item) => item.evidence_id === evidenceId))
-        .filter((item) => item && (!type || item.type === type || (type === "artifact" && item.artifact_paths.length > 0)))
+        .filter((item) => item && (!type || evidenceTypeMatches(item.type, type) || (type === "artifact" && item.artifact_paths.length > 0)))
         .map((item) => {
         const artifacts = item?.artifact_paths.join(", ");
         return `${item?.type} ${item?.command ?? ""} ${artifacts}`.trim();
     });
 }
+function evidenceTypeMatches(actual, expected) {
+    return actual === expected || actual.includes(expected) || (expected === "browser" && /\b(playwright|ui_browser|browser)_assertion\b/.test(actual));
+}
 function auditorStatus(state) {
     const auditor = state.gates.auditor;
     if (auditor && typeof auditor === "object" && !Array.isArray(auditor) && typeof auditor.auditor_status === "string") {