project-tiny-context-harness 0.2.81 → 0.2.83

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>;

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

@@ -11,6 +11,7 @@ export async function deriveSuperpowersArtifacts(workdir) {
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.json"), stableJson(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.json"), stableJson(derived.verdict));
     await writeDerived(files, path.join(derivedDir, "progress-ledger.json"), stableJson(derived.progress));
+    await writeDerived(files, path.join(derivedDir, "evidence-index.json"), stableJson(deriveEvidenceIndex(state)));
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.md"), matrixMarkdown(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.md"), verdictMarkdown(derived.verdict));
     await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state));
@@ -38,6 +39,15 @@ export function deriveObjects(state) {
             representative_samples: item.representative_samples,
             full_population_boundary: item.full_population_boundary,
             non_required_population: item.non_required_population,
+            owner_boundary: item.owner_boundary,
+            primary_capability_path: item.primary_capability_path,
+            trigger_contract: item.trigger_contract,
+            state_transition_contract: item.state_transition_contract,
+            observable_result_contract: item.observable_result_contract,
+            assertion_support: item.assertion_support,
+            required_assertion_commands: item.required_assertion_commands,
+            invalid_implementation_shortcuts: item.invalid_implementation_shortcuts,
+            blockers: item.blockers ?? [],
             conformance_type: item.owner_surfaces.length > 0 ? "product_surface" : "implementation",
             owner_surface: item.owner_surfaces[0] ?? "",
             forbidden_primary_surfaces: item.forbidden_surfaces,
@@ -82,6 +92,13 @@ export function deriveObjects(state) {
             sample_boundary: ac.sample_boundary,
             full_population_required: ac.full_population_required,
             full_population_status: ac.full_population_required === true || ac.acceptance_scope === "full_population_operation" ? status : "not_in_scope",
+            assertion_command: ac.assertion_command ?? "",
+            assertion_artifacts: ac.assertion_artifacts ?? [],
+            positive_assertions: ac.positive_assertions ?? [],
+            negative_assertions: ac.negative_assertions ?? [],
+            machine_blocking: ac.machine_blocking ?? false,
+            invalid_completion_signals: ac.invalid_completion_signals ?? [],
+            assertion_result_required: ac.assertion_result_required ?? false,
             required_evidence: requiredLayers,
             required_proof_chain: requiredLayers,
             fresh_evidence: evidenceText(state, evidenceIds),
@@ -90,7 +107,7 @@ export function deriveObjects(state) {
             assertion_status: assertionSummary.assertion_status,
             blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
             negative_evidence_findings: assertionSummary.negative_evidence_findings,
-            invalid_completion_signals: invalidCompletionSignals,
+            invalid_evidence_findings: invalidCompletionSignals,
             required_next_evidence: requiredNextEvidence(missingLayers, assertionSummary),
             contradictions: [],
             context_fact_refs: [],
@@ -144,8 +161,59 @@ export async function derivedMatchesState(workdir, state) {
     const expected = deriveObjects(state);
     await assertDerivedJson(workdir, "plan-conformance-matrix", expected.matrix, errors);
     await assertDerivedJson(workdir, "final-acceptance-verdict", expected.verdict, errors);
+    await assertDerivedJson(workdir, "evidence-index", deriveEvidenceIndex(state), errors);
     return errors;
 }
+export function deriveEvidenceIndex(state) {
+    const evidenceById = Object.fromEntries((state.evidence ?? []).map((evidence) => [
+        evidence.evidence_id,
+        {
+            evidence_id: evidence.evidence_id,
+            schema_version: evidence.schema_version ?? "",
+            task_attempt_id: evidence.task_attempt_id ?? "",
+            source_bundle_hash: evidence.source_bundle_hash ?? "",
+            product_source_hash: evidence.product_source_hash ?? "",
+            technical_plan_hash: evidence.technical_plan_hash ?? "",
+            acceptance_checklist_hash: evidence.acceptance_checklist_hash ?? "",
+            type: evidence.type,
+            command_spec_id: evidence.command_spec_id ?? "",
+            command_run_id: evidence.command_run_id ?? "",
+            command: evidence.command ?? "",
+            command_exit_code: evidence.command_exit_code,
+            artifact_path: evidence.artifact_path ?? "",
+            artifact_sha256: evidence.artifact_sha256 ?? "",
+            artifact_mtime: evidence.artifact_mtime ?? "",
+            artifact_paths: evidence.artifact_paths,
+            target_ac_ids: evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [],
+            target_pi_ids: evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [],
+            target_proof_layers: evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? [],
+            proves: evidence.proves,
+            does_not_prove: evidence.does_not_prove,
+            assertion_result: evidence.assertion_result ?? null,
+            negative_evidence_scan: evidence.negative_evidence_scan ?? null,
+            freshness: evidence.freshness,
+            reviewability: evidence.reviewability,
+            redaction: evidence.redaction
+        }
+    ]));
+    const proofLayers = Object.fromEntries(Object.entries(state.graph.proof_layers ?? {}).map(([layerId, layer]) => {
+        const evaluation = evaluateProofLayerAssertions(state, layerId);
+        return [
+            layerId,
+            {
+                layer_id: layerId,
+                status: layer.status,
+                required: layer.required,
+                evidence_ids: layer.evidence_ids,
+                assertion_status: evaluation.assertion_status,
+                blocking_assertion_failures: evaluation.blocking_assertion_failures,
+                negative_evidence_findings: evaluation.negative_evidence_findings,
+                evidence: layer.evidence_ids.map((evidenceId) => evidenceById[evidenceId]).filter(Boolean)
+            }
+        ];
+    }));
+    return { proof_layers: proofLayers, evidence: evidenceById };
+}
 async function assertDerivedJson(workdir, basename, expected, errors) {
     const file = path.join(workdir, "derived", `${basename}.json`);
     if (!(await pathExists(file))) {
@@ -238,9 +306,16 @@ ${stableJson(progress)}
 `;
 }
 function evidenceMarkdown(state) {
+    const index = deriveEvidenceIndex(state);
+    const layers = Object.values(index.proof_layers);
     return [
         "# Evidence Index",
         "",
+        ...layers.map((item) => {
+            const evidenceIds = item.evidence_ids ?? [];
+            return `- ${item.layer_id}: ${item.assertion_status}; evidence ${evidenceIds.join(", ") || "(none)"}`;
+        }),
+        "",
         ...state.evidence.map((item) => `- ${item.evidence_id}: proves ${item.proves.join(", ")}; does_not_prove ${item.does_not_prove.join(", ")}`)
     ].join("\n");
 }

package/dist/lib/superpowers-task-evidence-kernel.d.ts

@@ -0,0 +1,12 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface TrustedEvidenceKernelResult {
+    product_goal_complete: boolean;
+    acceptance_target_status: "complete" | "partial" | "blocked" | "invalidated" | "under_specified";
+    errors: string[];
+    ac_statuses: Record<string, string>;
+    pi_statuses: Record<string, string>;
+    stale_evidence_ids: string[];
+    harness_task_final_verdict?: "passed" | "failed";
+}
+export declare function evaluateTrustedEvidenceKernel(workdir: string, providedState?: SuperpowersTaskState): Promise<TrustedEvidenceKernelResult>;
+export declare function applyTrustedEvidenceKernelResult(state: SuperpowersTaskState, result: TrustedEvidenceKernelResult): void;

package/dist/lib/superpowers-task-evidence-kernel.js

@@ -0,0 +1,351 @@
+import { deriveRequiredCommandSpecs, requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+import { evaluateAc010Bootstrap } from "./superpowers-task-ac010.js";
+import { evaluateCurrentAttemptArtifact } from "./superpowers-task-current-evidence.js";
+import { scanSuperpowersContradictions } from "./superpowers-task-contradictions.js";
+import { detectHarnessDrift } from "./superpowers-task-harness-drift.js";
+import { evaluateProtectedBaseline } from "./superpowers-task-protected-baseline.js";
+import { evaluateProofLayerAssertions, isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { findUnderSpecifiedAcs } from "./superpowers-task-under-specified.js";
+import { loadSuperpowersState, sourceRecords } from "./superpowers-task-state.js";
+export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
+    const state = providedState ?? (await loadSuperpowersState(workdir));
+    const errors = [];
+    const acStatuses = {};
+    const staleEvidenceIds = new Set();
+    const attempt = currentAttempt(state);
+    const currentSources = await sourceRecords(workdir);
+    if (!attempt) {
+        errors.push("missing current attempt: final-gate requires current_attempt_id with ExecutionAttempt");
+    }
+    else {
+        validateAttemptAgainstSources(state, attempt, currentSources, errors);
+    }
+    const expectedSpecs = deriveRequiredCommandSpecs(state);
+    validateRequiredSpecs(state, attempt, expectedSpecs, errors);
+    const underSpecified = new Map(findUnderSpecifiedAcs(state).map((item) => [item.ac_id, item.reasons]));
+    for (const reasons of underSpecified.values()) {
+        errors.push(...reasons);
+    }
+    const contradictionScan = await scanSuperpowersContradictions(workdir, state);
+    errors.push(...contradictionScan.errors);
+    const drift = detectHarnessDrift(state);
+    errors.push(...drift.errors);
+    const baseline = evaluateProtectedBaseline(state);
+    errors.push(...baseline.errors);
+    const evidenceById = new Map((state.evidence ?? []).map((evidence) => [evidence.evidence_id, evidence]));
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        const acErrors = [];
+        if (underSpecified.has(acId)) {
+            acStatuses[acId] = "under_specified";
+            continue;
+        }
+        const requiredLayers = ac.required_proof_layers ?? [];
+        const spec = specForAc(state, expectedSpecs, acId);
+        if ((ac.machine_blocking === true || ac.assertion_result_required === true) && !spec) {
+            acErrors.push(`${acId} missing required_command_spec`);
+        }
+        if (spec) {
+            acErrors.push(...validateCommandRunsForSpec(state, attempt, spec));
+        }
+        for (const layerName of requiredLayers) {
+            const layerId = `${acId}.${layerName}`;
+            const layer = state.graph.proof_layers?.[layerId];
+            if (!layer || layer.status !== "satisfied") {
+                acErrors.push(`${layerId} missing current satisfied proof layer`);
+                continue;
+            }
+            if (isMachineVerifiableLayer(layerId)) {
+                const evaluation = evaluateProofLayerAssertions(state, layerId);
+                acErrors.push(...evaluation.blocking_assertion_failures, ...evaluation.negative_evidence_findings);
+                for (const evidenceId of layer.evidence_ids ?? []) {
+                    const evidence = evidenceById.get(evidenceId);
+                    if (!evidence) {
+                        acErrors.push(`${layerId} references unregistered evidence ${evidenceId}`);
+                        continue;
+                    }
+                    acErrors.push(...validateEvidenceAgainstSpec(state, evidence, spec, layerId));
+                    acErrors.push(...(await evaluateCurrentAttemptArtifact(workdir, evidence, layerId)));
+                    if (isStaleEvidenceError(acErrors)) {
+                        staleEvidenceIds.add(evidence.evidence_id);
+                    }
+                }
+            }
+        }
+        errors.push(...acErrors);
+        acStatuses[acId] = statusForAcErrors(acErrors, requiredLayers.length);
+    }
+    const ac010 = evaluateAc010Bootstrap(state, acStatuses);
+    for (const acId of ac010.invalidated_ac_ids) {
+        acStatuses[acId] = "invalidated";
+    }
+    errors.push(...ac010.errors);
+    const piStatuses = recomputePlanStatuses(state, acStatuses);
+    const allAcsComplete = Object.keys(state.graph?.acceptance_criteria ?? {}).length > 0 &&
+        Object.values(acStatuses).every((status) => status === "complete" || status === "out_of_scope_NA");
+    const allPisComplete = Object.keys(state.graph?.plan_items ?? {}).length > 0 &&
+        Object.values(piStatuses).every((status) => status === "complete" || status === "out_of_scope_NA");
+    const uniqueErrors = unique(errors);
+    const productComplete = uniqueErrors.length === 0 && allAcsComplete && allPisComplete && drift.product_goal_complete !== false && baseline.product_goal_complete !== false;
+    return {
+        product_goal_complete: productComplete,
+        acceptance_target_status: productComplete ? "complete" : statusForGlobalErrors(uniqueErrors, acStatuses),
+        errors: uniqueErrors,
+        ac_statuses: acStatuses,
+        pi_statuses: piStatuses,
+        stale_evidence_ids: [...staleEvidenceIds],
+        harness_task_final_verdict: drift.harness_task_final_verdict
+    };
+}
+export function applyTrustedEvidenceKernelResult(state, result) {
+    for (const [acId, status] of Object.entries(result.ac_statuses)) {
+        const ac = state.graph.acceptance_criteria[acId];
+        if (ac) {
+            ac.status = status;
+        }
+    }
+    for (const [piId, status] of Object.entries(result.pi_statuses)) {
+        const pi = state.graph.plan_items[piId];
+        if (pi) {
+            pi.status = status;
+        }
+    }
+    state.final.product_goal_complete = result.product_goal_complete;
+    state.meta.product_goal_complete = result.product_goal_complete;
+    state.final.acceptance_target_status = result.acceptance_target_status;
+    state.meta.acceptance_target_status = result.acceptance_target_status;
+    state.final.audit_task_complete = true;
+    state.meta.audit_task_complete = true;
+    state.final.completion_basis = result.product_goal_complete
+        ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
+        : [];
+    state.final.next_required_actions = result.product_goal_complete ? [] : result.errors.slice(0, 12);
+    state.gates.final_gate = {
+        status: result.product_goal_complete ? "pass" : result.acceptance_target_status,
+        kernel: "trusted_evidence_kernel",
+        order: [
+            "load_three_inputs",
+            "recompute_source_hashes",
+            "load_task_state",
+            "load_current_attempt",
+            "load_command_run_records",
+            "load_registered_evidence_records",
+            "discard_stale_evidence",
+            "contradiction_scan",
+            "recompute_every_ac",
+            "recompute_every_pi",
+            "recompute_acceptance_target_status",
+            "recompute_product_goal_complete",
+            "regenerate_derived",
+            "append_event"
+        ],
+        errors: result.errors,
+        stale_evidence_ids: result.stale_evidence_ids,
+        harness_task_final_verdict: result.harness_task_final_verdict,
+        next_required_actions: state.final.next_required_actions
+    };
+}
+function validateAttemptAgainstSources(state, attempt, currentSources, errors) {
+    const productHash = currentSources.product_architecture_source?.sha256 ?? "";
+    const planHash = currentSources.technical_realization_plan?.sha256 ?? "";
+    const checklistHash = currentSources.acceptance_checklist?.sha256 ?? "";
+    for (const [key, source] of Object.entries(currentSources)) {
+        const expected = state.sources[key]?.sha256;
+        if (expected && source.sha256 !== expected) {
+            errors.push(`source hash mismatch for ${key}: expected ${expected}, actual ${source.sha256}; recompile graph before final-gate`);
+        }
+    }
+    if (attempt.product_source_hash !== productHash) {
+        errors.push("source hash mismatch: current attempt product_source_hash does not match product-architecture-source.md");
+    }
+    if (attempt.technical_plan_hash !== planHash) {
+        errors.push("source hash mismatch: current attempt technical_plan_hash does not match technical-realization-plan.md");
+    }
+    if (attempt.acceptance_checklist_hash !== checklistHash) {
+        errors.push("source hash mismatch: current attempt acceptance_checklist_hash does not match acceptance-checklist.md");
+    }
+    for (const field of [
+        "task_attempt_id",
+        "source_bundle_hash",
+        "product_source_hash",
+        "technical_plan_hash",
+        "acceptance_checklist_hash",
+        "git_head",
+        "git_status_short",
+        "tracked_diff_hash",
+        "relevant_untracked_hash",
+        "worktree_fingerprint",
+        "started_at",
+        "required_command_specs_hash",
+        "mode"
+    ]) {
+        if (!attempt[field]) {
+            errors.push(`current attempt missing required field ${field}`);
+        }
+    }
+}
+function validateRequiredSpecs(state, attempt, expectedSpecs, errors) {
+    const expectedByAc = new Map(expectedSpecs.map((spec) => [spec.ac_id, spec]));
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        if (ac.machine_blocking !== true && ac.assertion_result_required !== true) {
+            continue;
+        }
+        const expected = expectedByAc.get(acId);
+        const actual = (state.required_command_specs ?? []).find((spec) => spec.ac_id === acId);
+        if (!expected || !actual) {
+            errors.push(`${acId} missing required_command_spec`);
+            continue;
+        }
+        if (actual.command_spec_id !== expected.command_spec_id) {
+            errors.push(`${acId} command_spec_id mismatch; required command specs must be recompiled from Acceptance Checklist`);
+        }
+    }
+    if (attempt) {
+        const specsHash = requiredCommandSpecsHash(state.required_command_specs ?? []);
+        if (attempt.required_command_specs_hash !== specsHash) {
+            errors.push("required_command_specs_hash mismatch for current attempt");
+        }
+    }
+}
+function validateCommandRunsForSpec(state, attempt, spec) {
+    const errors = [];
+    for (const proofLayer of spec.proof_layers.filter((layer) => isMachineVerifiableLayer(`${spec.ac_id}.${layer}`))) {
+        const run = (state.command_runs ?? []).find((item) => item.task_attempt_id === state.current_attempt_id &&
+            item.command_spec_id === spec.command_spec_id &&
+            item.ac_id === spec.ac_id &&
+            item.proof_layer === proofLayer);
+        if (!run) {
+            errors.push(`${spec.ac_id}.${proofLayer} missing current attempt command-run record for command_spec_id ${spec.command_spec_id}`);
+            continue;
+        }
+        errors.push(...validateCommandRun(run, attempt));
+    }
+    return errors;
+}
+function validateCommandRun(run, attempt) {
+    const errors = [];
+    if (attempt && run.task_attempt_id !== attempt.task_attempt_id) {
+        errors.push(`${run.command_run_id} stale command run from ${run.task_attempt_id}; expected ${attempt.task_attempt_id}`);
+    }
+    if (run.exit_code !== 0) {
+        errors.push(`${run.command_run_id} command_exit_code=${run.exit_code}; expected 0`);
+    }
+    if (!run.command_line.trim()) {
+        errors.push(`${run.command_run_id} missing command_line`);
+    }
+    return errors;
+}
+function validateEvidenceAgainstSpec(state, evidence, spec, layerId) {
+    if (!spec) {
+        return [];
+    }
+    const errors = [];
+    const assertion = evidence.assertion_result;
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    const expectedPiIds = state.graph.acceptance_criteria[spec.ac_id]?.related_plan_items ?? [];
+    const targetPiIds = evidence.target_pi_ids ?? assertion?.target_pi_ids ?? [];
+    for (const piId of expectedPiIds) {
+        if (!targetPiIds.includes(piId)) {
+            errors.push(`${label} target_pi_ids ${targetPiIds.join(", ") || "(none)"} do not include ${piId}`);
+        }
+    }
+    if (assertion) {
+        const assertionIds = new Set(assertion.positive_assertions.map((item) => item.id));
+        for (const id of spec.positive_assertions ?? []) {
+            if (!assertionIds.has(id)) {
+                errors.push(`${label} missing positive assertion ${id}`);
+            }
+        }
+        const negativeIds = new Set(assertion.negative_assertions.map((item) => item.id));
+        for (const id of spec.negative_assertions ?? []) {
+            if (!negativeIds.has(id)) {
+                errors.push(`${label} missing negative assertion ${id}`);
+            }
+        }
+        const requiredTests = new Set(assertion.required_test_ids ?? []);
+        for (const testId of spec.required_test_ids ?? []) {
+            if (!requiredTests.has(testId)) {
+                errors.push(`${label} assertion_result.required_test_ids missing ${testId}`);
+            }
+        }
+        const invalidChecks = [
+            ...((assertion.invalid_completion_signals ?? []).map((item) => `${item.id} ${item.forbidden_text ?? ""}`)),
+            ...((assertion.negative_evidence_scan?.invalid_completion_signals_checked ?? []).map((item) => String(item)))
+        ].join("\n");
+        for (const signal of spec.invalid_completion_signals ?? []) {
+            if (!invalidChecks.includes(signal)) {
+                errors.push(`${label} invalid_completion_signals did not check ${signal}`);
+            }
+        }
+    }
+    return errors;
+}
+function specForAc(state, expectedSpecs, acId) {
+    const actual = (state.required_command_specs ?? []).find((spec) => spec.ac_id === acId);
+    if (actual) {
+        return actual;
+    }
+    return expectedSpecs.find((spec) => spec.ac_id === acId);
+}
+function statusForAcErrors(errors, requiredLayerCount) {
+    if (requiredLayerCount === 0) {
+        return "not_run";
+    }
+    const text = errors.join("\n");
+    if (!text) {
+        return "complete";
+    }
+    if (/under_specified/i.test(text)) {
+        return "under_specified";
+    }
+    if (/stale|failed|invalid|contradiction|negative evidence|forbidden|bootstrap/i.test(text)) {
+        return "invalidated";
+    }
+    if (/blocked|harness_drift|protected_baseline|source hash mismatch/i.test(text)) {
+        return "blocked";
+    }
+    return "partial";
+}
+function recomputePlanStatuses(state, acStatuses) {
+    const statuses = {};
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        const relatedStatuses = (item.related_acs ?? []).map((acId) => acStatuses[acId] ?? state.graph.acceptance_criteria[acId]?.status ?? "not_run");
+        if (relatedStatuses.length > 0 && relatedStatuses.every((status) => status === "complete" || status === "out_of_scope_NA")) {
+            statuses[planId] = "complete";
+        }
+        else if (relatedStatuses.some((status) => status === "under_specified" || status === "blocked")) {
+            statuses[planId] = "blocked";
+        }
+        else if (relatedStatuses.some((status) => status === "invalidated")) {
+            statuses[planId] = "invalidated";
+        }
+        else if (relatedStatuses.some((status) => status === "partial")) {
+            statuses[planId] = "partial";
+        }
+        else {
+            statuses[planId] = "not_started";
+        }
+    }
+    return statuses;
+}
+function statusForGlobalErrors(errors, acStatuses) {
+    const text = errors.join("\n");
+    if (Object.values(acStatuses).includes("under_specified") || /under_specified/i.test(text)) {
+        return "under_specified";
+    }
+    if (/harness_drift|protected_baseline|source hash mismatch|missing current attempt|required_command_specs_hash|harness_task_missing/i.test(text)) {
+        return "blocked";
+    }
+    if (/stale|failed|invalid|contradiction|negative evidence|forbidden|bootstrap/i.test(text)) {
+        return "invalidated";
+    }
+    return "partial";
+}
+function currentAttempt(state) {
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+}
+function isStaleEvidenceError(errors) {
+    return errors.some((error) => /stale evidence|source_bundle_hash mismatch|artifact_sha256 mismatch|artifact_mtime/i.test(error));
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/lib/superpowers-task-evidence-records.d.ts

@@ -0,0 +1,2 @@
+import { type SuperpowersEvidenceRecord } from "./superpowers-task-state-schema.js";
+export declare function readEvidenceRecords(value: unknown): SuperpowersEvidenceRecord[];

package/dist/lib/superpowers-task-evidence-records.js

@@ -0,0 +1,55 @@
+import { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
+import { normalizeProofLayerId } from "./superpowers-task-fields.js";
+import { asStringArray, isRecord } from "./superpowers-task-state-schema.js";
+export function readEvidenceRecords(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((item) => ({
+        evidence_id: String(item.evidence_id ?? item.evidenceId ?? ""),
+        schema_version: item.schema_version === undefined ? undefined : String(item.schema_version),
+        task_attempt_id: item.task_attempt_id === undefined ? undefined : String(item.task_attempt_id),
+        source_bundle_hash: item.source_bundle_hash === undefined ? undefined : String(item.source_bundle_hash),
+        product_source_hash: item.product_source_hash === undefined ? undefined : String(item.product_source_hash),
+        technical_plan_hash: item.technical_plan_hash === undefined ? undefined : String(item.technical_plan_hash),
+        acceptance_checklist_hash: item.acceptance_checklist_hash === undefined ? undefined : String(item.acceptance_checklist_hash),
+        git_head: item.git_head === undefined ? undefined : String(item.git_head),
+        worktree_fingerprint: item.worktree_fingerprint === undefined ? undefined : String(item.worktree_fingerprint),
+        command_spec_id: item.command_spec_id === undefined ? undefined : String(item.command_spec_id),
+        command_run_id: item.command_run_id === undefined ? undefined : String(item.command_run_id),
+        command_line: item.command_line === undefined ? undefined : String(item.command_line),
+        artifact_path: item.artifact_path === undefined ? undefined : String(item.artifact_path),
+        artifact_sha256: item.artifact_sha256 === undefined ? undefined : String(item.artifact_sha256),
+        artifact_mtime: item.artifact_mtime === undefined ? undefined : String(item.artifact_mtime),
+        target_ac_ids: asStringArray(item.target_ac_ids),
+        target_pi_ids: asStringArray(item.target_pi_ids),
+        target_proof_layers: asStringArray(item.target_proof_layers).map(normalizeProofLayerId),
+        slice_id: String(item.slice_id ?? item.sliceId ?? ""),
+        type: String(item.type ?? ""),
+        freshness: isRecord(item.freshness)
+            ? {
+                created_at: String(item.freshness.created_at ?? ""),
+                valid_for: String(item.freshness.valid_for ?? ""),
+                stale_after: item.freshness.stale_after === null ? null : item.freshness.stale_after === undefined ? null : String(item.freshness.stale_after)
+            }
+            : { created_at: "", valid_for: "", stale_after: null },
+        command: item.command === undefined ? undefined : String(item.command),
+        command_exit_code: item.command_exit_code === undefined ? undefined : Number(item.command_exit_code),
+        artifact_paths: asStringArray(item.artifact_paths),
+        proves: asStringArray(item.proves).map(normalizeProofLayerId),
+        does_not_prove: asStringArray(item.does_not_prove).map((claim) => (claim.includes(".") ? normalizeProofLayerId(claim) : claim)),
+        redaction: isRecord(item.redaction)
+            ? { checked: item.redaction.checked === true, contains_secret: item.redaction.contains_secret === true }
+            : { checked: false, contains_secret: false },
+        reviewability: isRecord(item.reviewability)
+            ? {
+                external_reviewer_can_reproduce: item.reviewability.external_reviewer_can_reproduce === true,
+                reproduction_steps: String(item.reviewability.reproduction_steps ?? "")
+            }
+            : { external_reviewer_can_reproduce: false, reproduction_steps: "" },
+        assertion_result: normalizeAssertionResult(item.assertion_result),
+        negative_evidence_scan: normalizeNegativeEvidenceScan(item.negative_evidence_scan),
+        sibling_substitution_used: item.sibling_substitution_used === true,
+        sibling_substitution_approval_source: item.sibling_substitution_approval_source === undefined ? undefined : String(item.sibling_substitution_approval_source)
+    }));
+}

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

@@ -0,0 +1,10 @@
+import { type CommandRunRecord, type SuperpowersEvidenceRecord } from "./superpowers-task-state-schema.js";
+export declare function runSuperpowersAssertion(workdir: string, options: {
+    acId: string;
+    proofLayer: string;
+    commandArgs: string[];
+}): Promise<CommandRunRecord>;
+export declare function recordSuperpowersEvidence(workdir: string, options: {
+    artifactPath: string;
+    commandRunId: string;
+}): Promise<SuperpowersEvidenceRecord>;