project-tiny-context-harness 0.2.80 → 0.2.82

package/dist/lib/superpowers-task-assertion-normalizers.js

@@ -0,0 +1,70 @@
+import { normalizeProofLayerId } from "./superpowers-task-fields.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+export function normalizeAssertionResult(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        schema_version: String(value.schema_version ?? ""),
+        status: String(value.status ?? ""),
+        runner: String(value.runner ?? ""),
+        exit_code: numberValue(value.exit_code),
+        target_ac_ids: stringArray(value.target_ac_ids),
+        target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
+        owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
+        route: value.route === undefined ? undefined : String(value.route),
+        action: value.action === undefined ? undefined : String(value.action),
+        positive_assertions: checkArray(value.positive_assertions),
+        negative_assertions: checkArray(value.negative_assertions),
+        artifacts: stringArray(value.artifacts)
+    };
+}
+export function normalizeNegativeEvidenceScan(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        schema_version: String(value.schema_version ?? ""),
+        status: String(value.status ?? ""),
+        target_ac_ids: stringArray(value.target_ac_ids),
+        target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
+        invalid_completion_signals_checked: stringArray(value.invalid_completion_signals_checked),
+        owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
+        route: value.route === undefined ? undefined : String(value.route),
+        forbidden_findings: findingArray(value.forbidden_findings),
+        required_findings: checkArray(value.required_findings),
+        artifacts: stringArray(value.artifacts)
+    };
+}
+function checkArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((item) => ({
+        id: String(item.id ?? ""),
+        status: String(item.status ?? ""),
+        actual: item.actual === undefined ? undefined : String(item.actual),
+        expected: item.expected === undefined ? undefined : String(item.expected),
+        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text)
+    }));
+}
+function findingArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((item) => ({
+        id: String(item.id ?? ""),
+        status: String(item.status ?? ""),
+        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text),
+        actual: item.actual === undefined ? undefined : String(item.actual)
+    }));
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item) => String(item)).filter(Boolean);
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : Number.NaN;
+}

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,243 @@
+import { MACHINE_VERIFIABLE_LAYER_NAMES, normalizeProofLayerId, normalizeProofLayerName } from "./superpowers-task-fields.js";
+export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
+export const MACHINE_VERIFIABLE_PROOF_LAYERS = new Set(MACHINE_VERIFIABLE_LAYER_NAMES);
+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) {
+    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+    return normalizeProofLayerName(raw);
+}
+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}`);
+    }
+    const assertionTargetLayers = assertion.target_proof_layers.map(normalizeProofLayerId);
+    const normalizedLayerId = normalizeProofLayerId(layerId);
+    if (!assertionTargetLayers.includes(normalizedLayerId) && !assertionTargetLayers.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}`);
+    }
+    const targetLayers = (scan.target_proof_layers ?? []).map(normalizeProofLayerId);
+    const normalizedLayerId = normalizeProofLayerId(layerId);
+    if (targetLayers.length === 0) {
+        findings.push(`${label} negative evidence scan target proof layers are missing; expected ${normalizedLayerId}`);
+    }
+    else if (!targetLayers.includes(normalizedLayerId) && !targetLayers.includes(proofLayerName(layerId))) {
+        findings.push(`${label} negative evidence scan target proof layers ${targetLayers.join(", ") || "(none)"} do not include ${normalizedLayerId}`);
+    }
+    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 === "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 === "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-delivery.js

@@ -1,23 +1,6 @@
 import { computeScopeConflicts } from "./superpowers-task-compile.js";
+import { ACCEPTANCE_SCOPES, isSelectedScopeFitSlice, PLAN_DELIVERY_SCOPES, PRODUCT_DELIVERY_SCOPES, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
-const PRODUCT_DELIVERY_SCOPES = new Set([
-    "system_capability_build",
-    "representative_sample_validation",
-    "full_population_operation",
-    "mixed_scope_requires_boundary"
-]);
-const PLAN_DELIVERY_SCOPES = new Set([
-    "system_capability_build",
-    "representative_sample_validation",
-    "full_population_operation",
-    "out_of_scope_backlog"
-]);
-const ACCEPTANCE_SCOPES = new Set([
-    "system_capability_build",
-    "representative_sample_validation",
-    "full_population_operation",
-    "full_population_not_required"
-]);
 export function validateDeliveryContract(state, errors) {
     const product = state.delivery?.product_architecture_scope;
     if (!isRecord(product)) {
@@ -29,6 +12,17 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, "Product / Architecture Source representative_samples_validate", product.representative_samples_validate);
         requireArray(errors, "Product / Architecture Source representative_samples_do_not_validate", product.representative_samples_do_not_validate);
         requireArray(errors, "Product / Architecture Source out_of_scope_backlog", product.out_of_scope_backlog);
+        requireEnum(errors, "Product / Architecture Source scope_fit_decision", product.scope_fit_decision, SCOPE_FIT_DECISIONS);
+        requireText(errors, "Product / Architecture Source selected_scope_fit_slice", product.selected_scope_fit_slice);
+        if (typeof product.selected_scope_fit_slice === "string" && product.selected_scope_fit_slice && !isSelectedScopeFitSlice(product.selected_scope_fit_slice)) {
+            errors.push(`Product / Architecture Source selected_scope_fit_slice must be none or SFC-###: ${product.selected_scope_fit_slice}`);
+        }
+        requireText(errors, "Product / Architecture Source owner_boundary", product.owner_boundary);
+        requireText(errors, "Product / Architecture Source primary_capability_path", product.primary_capability_path);
+        requireArray(errors, "Product / Architecture Source non_completing_outcomes", product.non_completing_outcomes);
+        requireText(errors, "Product / Architecture Source assertion_policy", product.assertion_policy);
+        requireText(errors, "Product / Architecture Source source_authority", product.source_authority);
+        requireText(errors, "Product / Architecture Source product_goal", product.product_goal);
     }
     for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
         requireEnum(errors, `${planId} delivery_scope`, item.delivery_scope, PLAN_DELIVERY_SCOPES);
@@ -36,6 +30,15 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, `${planId} representative_samples`, item.representative_samples);
         requireText(errors, `${planId} full_population_boundary`, item.full_population_boundary);
         requireArray(errors, `${planId} non_required_population`, item.non_required_population);
+        requireText(errors, `${planId} owner_boundary`, item.owner_boundary);
+        requireText(errors, `${planId} primary_capability_path`, item.primary_capability_path);
+        requireText(errors, `${planId} trigger_contract`, item.trigger_contract);
+        requireText(errors, `${planId} state_transition_contract`, item.state_transition_contract);
+        requireText(errors, `${planId} observable_result_contract`, item.observable_result_contract);
+        requireText(errors, `${planId} assertion_support`, item.assertion_support);
+        requireArray(errors, `${planId} required_assertion_commands`, item.required_assertion_commands);
+        requireArray(errors, `${planId} invalid_implementation_shortcuts`, item.invalid_implementation_shortcuts);
+        requireArray(errors, `${planId} implementation_paths`, item.implementation_paths);
     }
     for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
         requireEnum(errors, `${acId} acceptance_scope`, ac.acceptance_scope, ACCEPTANCE_SCOPES);
@@ -43,6 +46,15 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, `${acId} ac_does_not_validate`, ac.ac_does_not_validate);
         requireText(errors, `${acId} sample_boundary`, ac.sample_boundary);
         requireBoolean(errors, `${acId} full_population_required`, ac.full_population_required);
+        requireArray(errors, `${acId} related_plan_items`, ac.related_plan_items);
+        requireArray(errors, `${acId} required_proof_layers`, ac.required_proof_layers);
+        requireText(errors, `${acId} assertion_command`, ac.assertion_command);
+        requireArray(errors, `${acId} assertion_artifacts`, ac.assertion_artifacts);
+        requireArray(errors, `${acId} positive_assertions`, ac.positive_assertions);
+        requireArray(errors, `${acId} negative_assertions`, ac.negative_assertions);
+        requireBoolean(errors, `${acId} machine_blocking`, ac.machine_blocking);
+        requireArray(errors, `${acId} invalid_completion_signals`, ac.invalid_completion_signals);
+        requireBoolean(errors, `${acId} assertion_result_required`, ac.assertion_result_required);
     }
 }
 export function validateScopeConflicts(state, errors) {

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

@@ -11,3 +11,4 @@ export declare function deriveObjects(state: SuperpowersTaskState): {
     progress: Record<string, unknown>;
 };
 export declare function derivedMatchesState(workdir: string, state: SuperpowersTaskState): Promise<string[]>;
+export declare function deriveEvidenceIndex(state: SuperpowersTaskState): Record<string, unknown>;