project-tiny-context-harness 0.2.81 → 0.2.83

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

@@ -1,16 +1,7 @@
+import { evaluateCurrentAttemptEvidence } from "./superpowers-task-current-evidence.js";
+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([
-    "ui_browser",
-    "api_schema",
-    "runtime",
-    "worker_runtime",
-    "data_artifact",
-    "integration",
-    "security_redaction",
-    "test",
-    "all_provider_all_runner",
-    "cleanup_stale_scan"
-]);
+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 = [
@@ -33,7 +24,8 @@ const GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS = [
     /\bsample[-_ ]?for[-_ ]?full[-_ ]?population\b/i
 ];
 export function proofLayerName(layerId) {
-    return layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : 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(".")) : "";
@@ -76,6 +68,13 @@ export function evaluateProofLayerAssertions(state, layerId) {
     if (!isMachineVerifiableLayer(layerId)) {
         return { assertion_status: "not_applicable", blocking_assertion_failures: [], negative_evidence_findings: [] };
     }
+    if (!state.current_attempt_id) {
+        return {
+            assertion_status: "missing",
+            blocking_assertion_failures: [`proof layer ${layerId} missing current attempt; current attempt is required for machine-backed completion`],
+            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));
@@ -89,6 +88,7 @@ export function evaluateProofLayerAssertions(state, layerId) {
     const blocking = [];
     const negative = [];
     for (const evidence of evidenceRecords) {
+        blocking.push(...evaluateCurrentAttemptEvidence(state, evidence, layerId));
         blocking.push(...evaluateAssertionEvidence(evidence, layerId));
         negative.push(...evaluateNegativeEvidence(evidence, layerId));
     }
@@ -124,8 +124,8 @@ export function evaluateAssertionEvidence(evidence, layerId) {
         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.schema_version !== "assertion-result-v1" && assertion.schema_version !== "assertion-result-v2") {
+        failures.push(`${label} assertion_result.schema_version must be assertion-result-v1 or assertion-result-v2`);
     }
     if (assertion.status !== "passed") {
         failures.push(`${label} assertion_result.status=${assertion.status}; expected passed`);
@@ -139,11 +139,18 @@ export function evaluateAssertionEvidence(evidence, layerId) {
     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)) {
+    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));
+    failures.push(...checkAssertions(`${label} invalid completion signal`, assertion.invalid_completion_signals ?? []));
+    const missingRequiredTests = (assertion.required_test_ids ?? []).filter((testId) => !testId);
+    if (missingRequiredTests.length > 0) {
+        failures.push(`${label} assertion_result.required_test_ids contains empty test ids`);
+    }
     if ((assertion.artifacts?.length ?? 0) === 0 && evidence.artifact_paths.length === 0) {
         failures.push(`${label} assertion-backed evidence must include artifacts`);
     }
@@ -189,9 +196,9 @@ function checkAssertions(prefix, checks) {
         .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;
+    const scan = evidence.assertion_result?.negative_evidence_scan ?? evidence.negative_evidence_scan;
     if (!scan) {
-        return [];
+        return [`proof layer ${layerId} evidence ${evidence.evidence_id} missing negative_evidence_scan`];
     }
     const acId = proofLayerAcId(layerId);
     const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
@@ -205,6 +212,14 @@ export function evaluateNegativeEvidence(evidence, layerId) {
     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());
@@ -226,7 +241,7 @@ function invalidEvidenceReason(evidence, layerName) {
     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)) {
+    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)) {
@@ -235,7 +250,7 @@ function invalidEvidenceReason(evidence, layerName) {
     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)) {
+    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-attempt.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionAttempt, SuperpowersAttemptMode, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function startSuperpowersAttempt(workdir: string, state: SuperpowersTaskState, mode?: SuperpowersAttemptMode): Promise<ExecutionAttempt>;
+export declare function startAndSaveSuperpowersAttempt(workdir: string, mode?: SuperpowersAttemptMode): Promise<ExecutionAttempt>;
+export declare function computeSourceBundleHash(state: SuperpowersTaskState, specsHash?: string): string;

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

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+import { loadSuperpowersState, saveSuperpowersState, sha256, stableJson } from "./superpowers-task-state.js";
+const execFileAsync = promisify(execFile);
+export async function startSuperpowersAttempt(workdir, state, mode = "product_task") {
+    const now = new Date().toISOString();
+    const specsHash = requiredCommandSpecsHash(state.required_command_specs ?? []);
+    const sourceBundleHash = computeSourceBundleHash(state, specsHash);
+    const git = await readGitIdentity(workdir);
+    const worktreeFingerprint = sha256(stableJson(git));
+    const attemptOrdinal = (state.attempts ?? []).length + 1;
+    const attempt = {
+        task_attempt_id: `ATT-${compactDate(now)}-${attemptOrdinal}-${sourceBundleHash.slice(0, 8)}`,
+        source_bundle_hash: sourceBundleHash,
+        product_source_hash: state.sources.product_architecture_source?.sha256 ?? "",
+        technical_plan_hash: state.sources.technical_realization_plan?.sha256 ?? "",
+        acceptance_checklist_hash: state.sources.acceptance_checklist?.sha256 ?? "",
+        git_head: git.git_head,
+        git_status_short: git.git_status_short,
+        tracked_diff_hash: git.tracked_diff_hash,
+        relevant_untracked_hash: git.relevant_untracked_hash,
+        untracked_relevant_hash: git.relevant_untracked_hash,
+        worktree_fingerprint: worktreeFingerprint,
+        started_at: now,
+        ended_at: null,
+        finalized_at: null,
+        required_command_specs_hash: specsHash,
+        mode,
+        changed_files: git.changed_files
+    };
+    state.attempts = [...(state.attempts ?? []).filter((item) => item.task_attempt_id !== attempt.task_attempt_id), attempt];
+    state.current_attempt_id = attempt.task_attempt_id;
+    return attempt;
+}
+export async function startAndSaveSuperpowersAttempt(workdir, mode = "product_task") {
+    const state = await loadSuperpowersState(workdir);
+    const attempt = await startSuperpowersAttempt(workdir, state, mode);
+    await saveSuperpowersState(workdir, state);
+    await appendSuperpowersEvent(workdir, "attempt_started", { task_attempt_id: attempt.task_attempt_id });
+    return attempt;
+}
+export function computeSourceBundleHash(state, specsHash = requiredCommandSpecsHash(state.required_command_specs ?? [])) {
+    return sha256(stableJson({
+        product_source_hash: state.sources.product_architecture_source?.sha256 ?? "",
+        technical_plan_hash: state.sources.technical_realization_plan?.sha256 ?? "",
+        acceptance_checklist_hash: state.sources.acceptance_checklist?.sha256 ?? "",
+        required_command_specs_hash: specsHash
+    }));
+}
+async function readGitIdentity(workdir) {
+    const head = await git(workdir, ["rev-parse", "HEAD"]);
+    if (!head.ok) {
+        return {
+            git_head: "no-git",
+            git_status_short: "no-git",
+            tracked_diff_hash: sha256("no-git-tracked-diff"),
+            relevant_untracked_hash: "ignored:no-git",
+            changed_files: []
+        };
+    }
+    const status = await git(workdir, ["status", "--short"]);
+    const diff = await git(workdir, ["diff", "--binary"]);
+    const stagedDiff = await git(workdir, ["diff", "--cached", "--binary"]);
+    const untracked = await git(workdir, ["ls-files", "--others", "--exclude-standard"]);
+    const trackedNames = await git(workdir, ["diff", "--name-only"]);
+    const stagedNames = await git(workdir, ["diff", "--cached", "--name-only"]);
+    const changedFiles = unique([
+        ...lines(trackedNames.ok ? trackedNames.stdout : ""),
+        ...lines(stagedNames.ok ? stagedNames.stdout : ""),
+        ...lines(untracked.ok ? untracked.stdout : "")
+    ]);
+    return {
+        git_head: head.stdout.trim(),
+        git_status_short: status.ok ? status.stdout.trim() : "git-status-unavailable",
+        tracked_diff_hash: sha256(`${diff.ok ? diff.stdout : "git-diff-unavailable"}\n${stagedDiff.ok ? stagedDiff.stdout : ""}`),
+        relevant_untracked_hash: untracked.ok && untracked.stdout.trim() ? sha256(untracked.stdout.trim()) : "none",
+        changed_files: changedFiles
+    };
+}
+async function git(workdir, args) {
+    try {
+        const result = await execFileAsync("git", args, { cwd: workdir, windowsHide: true, timeout: 10000 });
+        return { ok: true, stdout: result.stdout };
+    }
+    catch {
+        return { ok: false, stdout: "" };
+    }
+}
+function compactDate(value) {
+    return value.replace(/[-:.TZ]/g, "").slice(0, 14);
+}
+function lines(value) {
+    return value
+        .split(/\r?\n/)
+        .map((item) => item.trim().replace(/\\/g, "/"))
+        .filter(Boolean);
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/lib/superpowers-task-command-specs.d.ts

@@ -0,0 +1,3 @@
+import type { RequiredCommandSpec, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function deriveRequiredCommandSpecs(state: SuperpowersTaskState): RequiredCommandSpec[];
+export declare function requiredCommandSpecsHash(specs: RequiredCommandSpec[]): string;

package/dist/lib/superpowers-task-command-specs.js

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+import { stableJson } from "./superpowers-task-state.js";
+export function deriveRequiredCommandSpecs(state) {
+    return Object.entries(state.graph.acceptance_criteria).flatMap(([acId, ac]) => {
+        const proofLayers = [...new Set((ac.required_proof_layers ?? []).filter(Boolean))];
+        if (proofLayers.length === 0) {
+            return [];
+        }
+        const spec = {
+            ac_id: acId,
+            proof_layers: proofLayers,
+            command: ac.assertion_command ?? "",
+            assertion_artifacts: ac.assertion_artifacts ?? [],
+            required_test_ids: ac.required_test_ids ?? [],
+            machine_blocking: ac.machine_blocking !== false,
+            assertion_result_required: ac.assertion_result_required !== false,
+            positive_assertions: ac.positive_assertions ?? [],
+            negative_assertions: ac.negative_assertions ?? [],
+            invalid_completion_signals: ac.invalid_completion_signals ?? [],
+            final_evidence_expected: ac.final_evidence_expected ?? []
+        };
+        return [{ command_spec_id: commandSpecId(spec), ...spec }];
+    });
+}
+export function requiredCommandSpecsHash(specs) {
+    return sha256(stableJson(specs.map((spec) => ({
+        ...spec,
+        proof_layers: [...(spec.proof_layers ?? [])].sort(),
+        assertion_artifacts: [...(spec.assertion_artifacts ?? [])].sort(),
+        required_test_ids: [...(spec.required_test_ids ?? [])].sort(),
+        positive_assertions: [...(spec.positive_assertions ?? [])].sort(),
+        negative_assertions: [...(spec.negative_assertions ?? [])].sort(),
+        invalid_completion_signals: [...(spec.invalid_completion_signals ?? [])].sort(),
+        final_evidence_expected: [...(spec.final_evidence_expected ?? [])].sort()
+    }))));
+}
+function commandSpecId(spec) {
+    return sha256([
+        spec.ac_id,
+        spec.proof_layers.join(","),
+        spec.command,
+        spec.assertion_artifacts.join(","),
+        spec.required_test_ids.join(","),
+        spec.positive_assertions.join(","),
+        spec.negative_assertions.join(","),
+        spec.invalid_completion_signals.join(","),
+        spec.final_evidence_expected.join(",")
+    ].join("\n"));
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

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

@@ -1,3 +1,6 @@
 import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export declare function compileSuperpowersTask(workdir: string): Promise<SuperpowersTaskState>;
+import type { SuperpowersAttemptMode } from "./superpowers-task-state-schema.js";
+export declare function compileSuperpowersTask(workdir: string, options?: {
+    mode?: SuperpowersAttemptMode;
+}): Promise<SuperpowersTaskState>;
 export declare function computeScopeConflicts(state: SuperpowersTaskState): string[];

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

@@ -3,9 +3,11 @@ 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 { startSuperpowersAttempt } from "./superpowers-task-attempt.js";
+import { deriveRequiredCommandSpecs } from "./superpowers-task-command-specs.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) {
+export async function compileSuperpowersTask(workdir, options = {}) {
     const state = await loadSuperpowersState(workdir);
     await refreshSourceHashes(workdir, state);
     await assertRequiredSourcesExist(workdir, state);
@@ -40,9 +42,13 @@ export async function compileSuperpowersTask(workdir) {
         }
     }
     state.graph.edges = Object.entries(planItems).flatMap(([planId, item]) => item.related_acs.map((acId) => ({ from: planId, to: acId, type: "supports" })));
+    state.required_command_specs = deriveRequiredCommandSpecs(state);
+    state.command_runs = [];
+    state.negative_evidence_records = [];
     state.delivery.scope_conflicts = computeScopeConflicts(state);
     state.progress = compileProgress(state);
     recomputeStatuses(state);
+    await startSuperpowersAttempt(workdir, state, options.mode ?? "product_task");
     await saveSuperpowersState(workdir, state);
     await appendSuperpowersEvent(workdir, "graph_compiled", {
         plan_items: Object.keys(planItems).length,

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

@@ -0,0 +1,6 @@
+import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface SuperpowersContradictionScan {
+    errors: string[];
+    historicalCompleteIgnored: boolean;
+}
+export declare function scanSuperpowersContradictions(workdir: string, state: SuperpowersTaskState): Promise<SuperpowersContradictionScan>;

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

@@ -0,0 +1,126 @@
+import path from "node:path";
+import { listFiles, pathExists, readText } from "./fs.js";
+const OWNER_SURFACE_FORBIDDEN_STATES = ["尚未运行自测", "运行未记录", "未验证", "不可用", "暂不可用", "页面无明显变化"];
+export async function scanSuperpowersContradictions(workdir, state) {
+    const files = await listFiles(workdir);
+    const errors = [
+        ...scanFinalStateContradictions(state),
+        ...(await scanCurrentFailureArtifacts(workdir, files))
+    ];
+    const historicalCompleteIgnored = errors.length > 0 && (await hasHistoricalCompleteEvent(workdir));
+    if (historicalCompleteIgnored) {
+        errors.push("historical_complete_ignored: Historical stale completion event detected and ignored. Current recomputed product_goal_complete=false.");
+    }
+    if (errors.length > 0) {
+        errors.push("workflow_gate_bug_prevented: current contradiction scan prevents product_goal_complete=true.");
+    }
+    return { errors: unique(errors), historicalCompleteIgnored };
+}
+function scanFinalStateContradictions(state) {
+    const errors = [];
+    if (state.meta?.product_goal_complete === false && state.final?.product_goal_complete === true) {
+        errors.push("current contradiction task_state_product_goal_mismatch: meta product_goal_complete=false but final product_goal_complete=true.");
+    }
+    if (state.meta?.acceptance_target_status && state.final?.acceptance_target_status && state.meta.acceptance_target_status !== state.final.acceptance_target_status) {
+        errors.push(`current contradiction task_state_acceptance_status_mismatch: meta=${state.meta.acceptance_target_status} final=${state.final.acceptance_target_status}.`);
+    }
+    for (const commandRun of state.command_runs ?? []) {
+        if (Number(commandRun.exit_code) !== 0) {
+            errors.push(`current contradiction command_run_failed: ${commandRun.command_run_id} ac=${commandRun.ac_id} proof_layer=${commandRun.proof_layer} exit_code=${commandRun.exit_code}.`);
+        }
+    }
+    return errors;
+}
+async function scanCurrentFailureArtifacts(workdir, files) {
+    const errors = [];
+    for (const file of files) {
+        const relative = slash(path.relative(workdir, file));
+        if (relative.endsWith(".last-run.json")) {
+            errors.push(...(await scanPlaywrightLastRun(file, relative)));
+            continue;
+        }
+        if (/test-results\/.*error-context\.md$/i.test(relative)) {
+            errors.push(...(await scanOwnerDomErrorContext(file, relative)));
+            continue;
+        }
+        if (isFailureJsonCandidate(relative)) {
+            errors.push(...(await scanFailedJsonArtifact(file, relative)));
+        }
+    }
+    return errors;
+}
+async function scanPlaywrightLastRun(file, relative) {
+    const parsed = await readJsonRecord(file);
+    if (!parsed) {
+        return [];
+    }
+    const status = String(parsed.status ?? parsed.outcome ?? "").toLowerCase();
+    const failedTests = Array.isArray(parsed.failedTests) ? parsed.failedTests : Array.isArray(parsed.failed_tests) ? parsed.failed_tests : [];
+    if (status !== "failed" && failedTests.length === 0) {
+        return [];
+    }
+    return [
+        `current contradiction playwright_last_run_failed: ${relative} status=${status || "unknown"} failed_tests=${failedTests
+            .map(String)
+            .join(", ") || "(unspecified)"}.`
+    ];
+}
+async function scanOwnerDomErrorContext(file, relative) {
+    const text = await readText(file);
+    const findings = OWNER_SURFACE_FORBIDDEN_STATES.filter((state) => text.includes(state));
+    if (findings.length === 0) {
+        return [];
+    }
+    return [`current contradiction owner_dom_forbidden_state: ${relative} contains ${findings.join(", ")}.`];
+}
+async function scanFailedJsonArtifact(file, relative) {
+    const parsed = await readJsonRecord(file);
+    if (!parsed) {
+        return [];
+    }
+    const text = JSON.stringify(parsed);
+    const status = String(parsed.status ?? parsed.outcome ?? parsed.result ?? "").toLowerCase();
+    const failures = Number(parsed.failures ?? parsed.failed ?? parsed.failed_count ?? 0);
+    if (status !== "failed" && failures <= 0 && !/"failed"/i.test(text)) {
+        return [];
+    }
+    return [`current contradiction failed_test_result_artifact: ${relative} reports failed status.`];
+}
+function isFailureJsonCandidate(relative) {
+    return (/\.json$/i.test(relative) &&
+        /(^|\/)(test-results|playwright-report|junit|command-runs|negative-evidence|negative_evidence)(\/|$)/i.test(relative));
+}
+async function hasHistoricalCompleteEvent(workdir) {
+    const eventsPath = path.join(workdir, "events.ndjson");
+    if (!(await pathExists(eventsPath))) {
+        return false;
+    }
+    const content = await readText(eventsPath);
+    return content
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .some((line) => {
+        try {
+            const event = JSON.parse(line);
+            return String(event.event ?? event.event_type ?? event.type ?? "") === "final_gate" && event.product_goal_complete === true;
+        }
+        catch {
+            return /final_gate/.test(line) && /product_goal_complete["']?\s*:\s*true/.test(line);
+        }
+    });
+}
+async function readJsonRecord(file) {
+    try {
+        const parsed = JSON.parse(await readText(file));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function slash(value) {
+    return value.split(path.sep).join("/");
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

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

@@ -0,0 +1,3 @@
+import type { SuperpowersEvidenceRecord, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function evaluateCurrentAttemptEvidence(state: SuperpowersTaskState, evidence: SuperpowersEvidenceRecord, layerId: string): string[];
+export declare function evaluateCurrentAttemptArtifact(workdir: string, evidence: SuperpowersEvidenceRecord, layerId: string): Promise<string[]>;

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

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { pathExists, readText } from "./fs.js";
+import { normalizeProofLayerName } from "./superpowers-task-fields.js";
+export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
+    if (!state.current_attempt_id) {
+        return [];
+    }
+    const failures = [];
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    if (evidence.schema_version !== "evidence-record-v2") {
+        failures.push(`${label} must be EvidenceRecordV2 for current-attempt machine completion`);
+    }
+    if (evidence.task_attempt_id !== state.current_attempt_id) {
+        failures.push(`${label} stale evidence from old attempt ${evidence.task_attempt_id || "(missing)"}; expected current attempt ${state.current_attempt_id}`);
+    }
+    for (const field of [
+        "source_bundle_hash",
+        "product_source_hash",
+        "technical_plan_hash",
+        "acceptance_checklist_hash",
+        "git_head",
+        "worktree_fingerprint",
+        "command_spec_id",
+        "command_run_id",
+        "command_line",
+        "artifact_path",
+        "artifact_sha256",
+        "artifact_mtime"
+    ]) {
+        if (!evidence[field]) {
+            failures.push(`${label} EvidenceRecordV2 missing ${field}`);
+        }
+    }
+    const attempt = state.attempts?.find((item) => item.task_attempt_id === state.current_attempt_id);
+    if (attempt && evidence.source_bundle_hash && evidence.source_bundle_hash !== attempt.source_bundle_hash) {
+        failures.push(`${label} stale evidence source_bundle_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.product_source_hash && evidence.product_source_hash !== attempt.product_source_hash) {
+        failures.push(`${label} stale evidence product_source_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.technical_plan_hash && evidence.technical_plan_hash !== attempt.technical_plan_hash) {
+        failures.push(`${label} stale evidence technical_plan_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.acceptance_checklist_hash && evidence.acceptance_checklist_hash !== attempt.acceptance_checklist_hash) {
+        failures.push(`${label} stale evidence acceptance_checklist_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.git_head && evidence.git_head !== attempt.git_head) {
+        failures.push(`${label} stale evidence git_head mismatch for current attempt`);
+    }
+    if (attempt && evidence.worktree_fingerprint && evidence.worktree_fingerprint !== attempt.worktree_fingerprint) {
+        failures.push(`${label} stale evidence worktree_fingerprint mismatch for current attempt`);
+    }
+    if (attempt && evidence.artifact_mtime && Date.parse(evidence.artifact_mtime) < Date.parse(attempt.started_at)) {
+        failures.push(`${label} stale evidence artifact_mtime predates current attempt`);
+    }
+    const commandRun = state.command_runs?.find((item) => item.command_run_id === evidence.command_run_id);
+    if (!commandRun) {
+        failures.push(`${label} missing command run ${evidence.command_run_id || "(missing)"}`);
+    }
+    else {
+        if (commandRun.task_attempt_id !== state.current_attempt_id) {
+            failures.push(`${label} command run ${commandRun.command_run_id} is from old attempt ${commandRun.task_attempt_id}`);
+        }
+        if (commandRun.exit_code !== 0) {
+            failures.push(`${label} command run ${commandRun.command_run_id} exit_code=${commandRun.exit_code}; expected 0`);
+        }
+        if (commandRun.command_spec_id !== evidence.command_spec_id) {
+            failures.push(`${label} command_spec_id mismatch between evidence and command run`);
+        }
+    }
+    const commandSpec = state.required_command_specs?.find((item) => item.command_spec_id === evidence.command_spec_id);
+    if (!commandSpec) {
+        failures.push(`${label} missing required command spec ${evidence.command_spec_id || "(missing)"}`);
+    }
+    else if (commandSpec.ac_id !== proofLayerAcId(layerId) || !commandSpec.proof_layers.map(normalizeProofLayerName).includes(proofLayerName(layerId))) {
+        failures.push(`${label} command spec does not cover ${layerId}`);
+    }
+    const ac = state.graph.acceptance_criteria?.[proofLayerAcId(layerId)];
+    const targetAcIds = evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [];
+    if (!targetAcIds.includes(proofLayerAcId(layerId))) {
+        failures.push(`${label} target_ac_ids ${targetAcIds.join(", ") || "(none)"} do not include ${proofLayerAcId(layerId)}`);
+    }
+    const expectedPiIds = ac?.related_plan_items ?? [];
+    const targetPiIds = evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [];
+    for (const piId of expectedPiIds) {
+        if (!targetPiIds.includes(piId)) {
+            failures.push(`${label} target_pi_ids ${targetPiIds.join(", ") || "(none)"} do not include related plan item ${piId}`);
+        }
+    }
+    const targetLayers = (evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? []).map(normalizeLayerId);
+    if (!targetLayers.includes(normalizeLayerId(layerId)) && !targetLayers.includes(proofLayerName(layerId))) {
+        failures.push(`${label} target_proof_layers ${targetLayers.join(", ") || "(none)"} do not include ${layerId}`);
+    }
+    if (evidence.assertion_result?.schema_version !== "assertion-result-v2") {
+        failures.push(`${label} assertion_result.schema_version must be assertion-result-v2 for current-attempt machine completion`);
+    }
+    return failures;
+}
+export async function evaluateCurrentAttemptArtifact(workdir, evidence, layerId) {
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    return validateArtifact(workdir, evidence, label);
+}
+async function validateArtifact(workdir, evidence, label) {
+    const failures = [];
+    if (!evidence.artifact_path) {
+        failures.push(`${label} EvidenceRecordV2 missing artifact_path`);
+        return failures;
+    }
+    const artifact = await resolveArtifactPath(workdir, evidence.artifact_path);
+    if (!artifact) {
+        failures.push(`${label} artifact_path does not exist: ${evidence.artifact_path}`);
+        return failures;
+    }
+    if (evidence.artifact_sha256) {
+        const actual = createHash("sha256").update(await readText(artifact)).digest("hex");
+        if (actual !== evidence.artifact_sha256) {
+            failures.push(`${label} stale evidence artifact_sha256 mismatch for ${evidence.artifact_path}`);
+        }
+    }
+    return failures;
+}
+async function resolveArtifactPath(workdir, artifactPath) {
+    const candidates = path.isAbsolute(artifactPath) ? [artifactPath] : [path.join(workdir, artifactPath), path.join(projectRootFromWorkdir(workdir), artifactPath)];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function proofLayerName(layerId) {
+    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+    return normalizeProofLayerName(raw);
+}
+function proofLayerAcId(layerId) {
+    return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
+}
+function normalizeLayerId(layerId) {
+    if (!layerId.includes(".")) {
+        return normalizeProofLayerName(layerId);
+    }
+    const acId = proofLayerAcId(layerId);
+    return `${acId}.${proofLayerName(layerId)}`;
+}
+function projectRootFromWorkdir(workdir) {
+    const normalized = workdir.replace(/\\/g, "/");
+    const marker = "/tmp/ty-context/plan-acceptance/";
+    const index = normalized.lastIndexOf(marker);
+    if (index < 0) {
+        return workdir;
+    }
+    return normalized.slice(0, index);
+}