project-tiny-context-harness 0.2.83 → 0.2.85

package/dist/lib/package-source.js

@@ -58,15 +58,25 @@ async function applyMapping(projectRoot, mapping) {
     if (typeof rendered === "string") {
         return (await writeTextIfChanged(target, rendered)) ? [mapping.target] : [];
     }
-    await fs.rm(target, { recursive: true, force: true });
     await ensureDir(target);
     const changed = [];
+    const expectedRelatives = new Set(rendered.map((item) => item.relative));
     for (const item of rendered) {
         const targetFile = path.join(target, item.relative);
         if (await writeTextIfChanged(targetFile, item.content)) {
             changed.push(`${mapping.target}/${item.relative}`);
         }
     }
+    for (const targetFile of await listFiles(target)) {
+        if (path.basename(targetFile) === ".gitkeep") {
+            continue;
+        }
+        const relative = path.relative(target, targetFile);
+        if (!expectedRelatives.has(relative)) {
+            await fs.rm(targetFile, { force: true });
+            changed.push(`${mapping.target}/${relative}`);
+        }
+    }
     return changed;
 }
 async function renderMapping(projectRoot, mapping) {

package/dist/lib/superpowers-task-command-run-correlation.d.ts

@@ -0,0 +1,8 @@
+import type { CommandRunRecord, ExecutionAttempt, RequiredCommandSpec, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface CommandRunCorrelationResult {
+    errors: string[];
+    invalidated_evidence_ids: string[];
+}
+export declare function validateRequiredCommandCorrelation(state: SuperpowersTaskState, attempt: ExecutionAttempt | undefined, expectedSpecs: RequiredCommandSpec[]): CommandRunCorrelationResult;
+export declare function validateCommandRunsForSpec(state: SuperpowersTaskState, attempt: ExecutionAttempt | undefined, spec: RequiredCommandSpec): string[];
+export declare function validateCommandRun(run: CommandRunRecord, attempt: ExecutionAttempt | undefined): string[];

package/dist/lib/superpowers-task-command-run-correlation.js

@@ -0,0 +1,103 @@
+import { isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { normalizeProofLayerName } from "./superpowers-task-fields.js";
+import { requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+export function validateRequiredCommandCorrelation(state, attempt, expectedSpecs) {
+    const errors = [];
+    const invalidated = new Set();
+    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");
+        }
+    }
+    for (const spec of expectedSpecs) {
+        errors.push(...validateCommandRunsForSpec(state, attempt, spec));
+    }
+    for (const finding of findFailedCommandInvalidations(state)) {
+        invalidated.add(finding.evidence_id);
+        errors.push(`${finding.evidence_id} newer failed command invalidates older passed evidence for ${finding.ac_id}.${finding.proof_layer}: ${finding.command_run_id}`);
+    }
+    return { errors: unique(errors), invalidated_evidence_ids: [...invalidated] };
+}
+export 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 &&
+            normalizeProofLayerName(item.proof_layer) === normalizeProofLayerName(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;
+}
+export 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`);
+    }
+    if (!run.started_at) {
+        errors.push(`${run.command_run_id} missing started_at`);
+    }
+    if (!run.completed_at) {
+        errors.push(`${run.command_run_id} missing completed_at`);
+    }
+    if (!run.task_attempt_id) {
+        errors.push(`${run.command_run_id} missing attempt_id`);
+    }
+    return errors;
+}
+function findFailedCommandInvalidations(state) {
+    const evidence = state.evidence ?? [];
+    const failedRuns = (state.command_runs ?? []).filter((run) => run.task_attempt_id === state.current_attempt_id && Number(run.exit_code) !== 0);
+    return failedRuns.flatMap((run) => evidence
+        .filter((item) => evidenceTargetsRunLayer(item, run) && evidencePredatesRun(item, run))
+        .map((item) => ({
+        evidence_id: item.evidence_id,
+        command_run_id: run.command_run_id,
+        ac_id: run.ac_id,
+        proof_layer: run.proof_layer
+    })));
+}
+function evidenceTargetsRunLayer(evidence, run) {
+    const layerId = `${run.ac_id}.${normalizeProofLayerName(run.proof_layer)}`;
+    const targetLayers = (evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? []).map((item) => item.includes(".") ? item : `${run.ac_id}.${normalizeProofLayerName(item)}`);
+    return (evidence.task_attempt_id === run.task_attempt_id &&
+        (evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? []).includes(run.ac_id) &&
+        (targetLayers.includes(layerId) || evidence.proves.includes(layerId)));
+}
+function evidencePredatesRun(evidence, run) {
+    const evidenceTime = Date.parse(evidence.generated_at ?? evidence.freshness?.created_at ?? evidence.artifact_mtime ?? "");
+    const runTime = Date.parse(run.started_at || run.completed_at || run.ended_at || "");
+    if (Number.isNaN(evidenceTime) || Number.isNaN(runTime)) {
+        return true;
+    }
+    return evidenceTime <= runTime;
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/lib/superpowers-task-completion-output.d.ts

@@ -0,0 +1,91 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export type CompletionOutputStatus = "accept" | "reject" | "blocked";
+export interface CompletionOutputContract {
+    product_goal_complete: boolean;
+    acceptance_target_status: string;
+    completion_output_status: CompletionOutputStatus;
+    final_answer_allowed: boolean;
+    required_user_visible_status: "accepted" | "rejected" | "blocked";
+    final_answer: CompletionOutputStatus;
+    exit_code: 0 | 1 | 2;
+    blocked_reasons: string[];
+    rejection_reasons: string[];
+    audit_task_complete: boolean;
+    final_gate_ran: boolean;
+    generated_output_mismatch: boolean;
+    blocker_triage?: FinalGateBlockerTriage;
+    candidate_state?: FinalGateCandidateState;
+}
+export interface CompletionOutputResolveInput {
+    final_gate_ran?: boolean;
+    product_goal_complete?: boolean;
+    acceptance_target_status?: string;
+    audit_task_complete?: boolean;
+    validator_errors?: string[];
+    acceptance_validator_errors?: string[];
+    blocked_reasons?: string[];
+    rejection_reasons?: string[];
+    generated_output_mismatch?: boolean;
+    required_command_not_run?: boolean;
+    environment_unknown?: boolean;
+    state_unreadable?: boolean;
+    source_unreadable?: boolean;
+    kernel_invalid?: boolean;
+    required_validator_unavailable?: boolean;
+}
+export interface CompletionOutputSurface {
+    surface: string;
+    text: string;
+}
+export type CompletionOutputSurfaceType = "user_visible_final_summary" | "final_card" | "agent_final_answer" | "generated_summary" | "machine_readable_json_status" | "derived_diagnostic_json" | "matrix_diagnostic" | "verdict_diagnostic" | "workflow_protocol_text" | "execution_binding_text" | "rule_explanation_text" | "local_audit_diagnostic" | "unknown";
+export type CompletionPhraseClassification = "true_false_completion_claim" | "allowed_protocol_reserved_word" | "allowed_machine_status_field" | "allowed_diagnostic_status" | "allowed_rule_explanation";
+export interface CompletionPhraseFinding {
+    surface: string;
+    surface_type?: CompletionOutputSurfaceType;
+    classification?: CompletionPhraseClassification;
+    phrase: string;
+    line: number;
+    text: string;
+    self_recoverable?: boolean;
+}
+export interface FinalGateCandidateState {
+    final_gate_ran: boolean;
+    product_goal_complete: boolean;
+    acceptance_target_status: string;
+    completion_output_status: CompletionOutputStatus;
+    generated_output_mismatch: boolean;
+    source: "trusted_evidence_kernel";
+}
+export type FinalGateBlockerCategory = "none" | "product_evidence_failed" | "missing_current_evidence" | "stale_or_contradictory_evidence" | "generated_output_mismatch" | "self_recoverable_generated_output_mismatch" | "transient_state_bookkeeping" | "environment_blocked" | "contract_blocked" | "harness_drift_blocked";
+export interface FinalGateBlockerTriage {
+    category: FinalGateBlockerCategory;
+    self_recoverable: boolean;
+    recovery_attempted: boolean;
+    recovery_action: string;
+    next_action: string;
+    details: string[];
+    blocker_count: number;
+}
+export interface FinalGateBlockerTriageInput {
+    errors: string[];
+    output_findings: CompletionPhraseFinding[];
+    previous_transient_findings?: string[];
+    candidate_state?: FinalGateCandidateState;
+    recovery_attempted?: boolean;
+    recovery_action?: string;
+}
+export declare function resolveCompletionOutputStatus(input: CompletionOutputResolveInput): CompletionOutputContract;
+export declare function completionOutputContractFromState(state: SuperpowersTaskState): CompletionOutputContract;
+export declare function applyCompletionOutputContract(state: SuperpowersTaskState, contract: CompletionOutputContract): void;
+export declare function scanFalseCompletionPhrases(input: {
+    completion_output_status: CompletionOutputStatus;
+    surfaces: CompletionOutputSurface[] | string;
+}): CompletionPhraseFinding[];
+export declare function scanFalseCompletionPhrasesDetailed(input: {
+    completion_output_status: CompletionOutputStatus;
+    surfaces: CompletionOutputSurface[] | string;
+}): CompletionPhraseFinding[];
+export declare function scanGeneratedCompletionOutputSurfaces(workdir: string, contract: CompletionOutputContract): Promise<CompletionPhraseFinding[]>;
+export declare function scanGeneratedCompletionOutputSurfacesDetailed(workdir: string, contract: CompletionOutputContract): Promise<CompletionPhraseFinding[]>;
+export declare function completionPhraseFindingMessages(findings: CompletionPhraseFinding[]): string[];
+export declare function triageFinalGateBlockers(input: FinalGateBlockerTriageInput): FinalGateBlockerTriage;

package/dist/lib/superpowers-task-completion-output.js

@@ -0,0 +1,374 @@
+import path from "node:path";
+import { pathExists, readText } from "./fs.js";
+import { asStringArray, isRecord } from "./superpowers-task-state-schema.js";
+const BLOCKING_TARGET_STATUSES = new Set(["not_run", "blocked", "under_specified", "unknown"]);
+const REJECTING_TARGET_STATUSES = new Set(["partial", "failed", "rejected", "invalidated", "not_accepted"]);
+const GENERATED_COMPLETION_SURFACES = [
+    "derived/final-summary.md",
+    "derived/final-card.md",
+    "derived/final-acceptance-verdict.json",
+    "derived/final-acceptance-verdict.md",
+    "derived/plan-conformance-matrix.json",
+    "derived/plan-conformance-matrix.md",
+    "derived/local-audit.md",
+    "goal-objective.txt",
+    "execution-binding.md",
+    "workflow-protocol.md"
+];
+const FORBIDDEN_PHRASES = [
+    { phrase: "update_goal(status=\"complete\")", pattern: /update_goal\s*\(\s*status\s*=\s*["']complete["']\s*\)/i },
+    { phrase: "goal achieved", pattern: /\bgoal achieved\b/i },
+    { phrase: "ready to merge", pattern: /\bready to merge\b/i },
+    { phrase: "implementation complete", pattern: /\bimplementation complete\b/i },
+    { phrase: "all passed", pattern: /\ball (?:acs?|acceptance criteria|checks|tests)?\s*passed\b/i },
+    { phrase: "product complete", pattern: /\bproduct complete\b/i },
+    { phrase: "completed", pattern: /\bcompleted\b/i },
+    { phrase: "complete", pattern: /\bcomplete\b/i },
+    { phrase: "accepted", pattern: /\baccepted\b/i },
+    { phrase: "accept", pattern: /\baccept\b/i },
+    { phrase: "done", pattern: /\bdone\b/i },
+    { phrase: "success", pattern: /\bsuccess(?:ful)?\b/i },
+    { phrase: "任务完成", pattern: /任务完成/ },
+    { phrase: "已完成", pattern: /已完成/ },
+    { phrase: "验收通过", pattern: /验收通过/ },
+    { phrase: "目标完成", pattern: /目标完成/ },
+    { phrase: "全部通过", pattern: /全部通过/ },
+    { phrase: "可以合并", pattern: /可以合并/ }
+];
+export function resolveCompletionOutputStatus(input) {
+    const finalGateRan = input.final_gate_ran === true;
+    const productGoalComplete = input.product_goal_complete === true;
+    const acceptanceTargetStatus = normalizeAcceptanceTargetStatus(input.acceptance_target_status);
+    const validatorErrors = [...(input.validator_errors ?? []), ...(input.acceptance_validator_errors ?? [])].filter(Boolean);
+    const blockedReasons = [...(input.blocked_reasons ?? [])];
+    const rejectionReasons = [...(input.rejection_reasons ?? [])];
+    if (!finalGateRan) {
+        blockedReasons.push("final_gate_not_run");
+    }
+    if (input.required_command_not_run === true) {
+        blockedReasons.push("required_command_not_run");
+    }
+    if (input.environment_unknown === true) {
+        blockedReasons.push("environment_unknown");
+    }
+    if (input.state_unreadable === true) {
+        blockedReasons.push("state_unreadable");
+    }
+    if (input.source_unreadable === true) {
+        blockedReasons.push("source_unreadable");
+    }
+    if (input.kernel_invalid === true) {
+        blockedReasons.push("kernel_invalid");
+    }
+    if (input.required_validator_unavailable === true) {
+        blockedReasons.push("required_validator_unavailable");
+    }
+    if (input.generated_output_mismatch === true) {
+        blockedReasons.push("generated_output_mismatch");
+    }
+    if (BLOCKING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
+        blockedReasons.push(`acceptance_target_status=${acceptanceTargetStatus}`);
+    }
+    if (REJECTING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
+        rejectionReasons.push(`acceptance_target_status=${acceptanceTargetStatus}`);
+    }
+    if (finalGateRan && !productGoalComplete && !BLOCKING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
+        rejectionReasons.push("product_goal_complete=false");
+    }
+    if (validatorErrors.length > 0) {
+        rejectionReasons.push(...validatorErrors);
+    }
+    const accept = finalGateRan &&
+        productGoalComplete &&
+        isAcceptedStatus(acceptanceTargetStatus) &&
+        validatorErrors.length === 0 &&
+        blockedReasons.length === 0 &&
+        rejectionReasons.length === 0;
+    const completionOutputStatus = accept ? "accept" : blockedReasons.length > 0 ? "blocked" : "reject";
+    const exitCode = completionOutputStatus === "accept" ? 0 : completionOutputStatus === "reject" ? 1 : 2;
+    return {
+        product_goal_complete: productGoalComplete && accept,
+        acceptance_target_status: acceptanceTargetStatus,
+        completion_output_status: completionOutputStatus,
+        final_answer_allowed: completionOutputStatus === "accept",
+        required_user_visible_status: completionOutputStatus === "accept" ? "accepted" : completionOutputStatus === "reject" ? "rejected" : "blocked",
+        final_answer: completionOutputStatus,
+        exit_code: exitCode,
+        blocked_reasons: unique(blockedReasons),
+        rejection_reasons: unique(rejectionReasons),
+        audit_task_complete: input.audit_task_complete === true,
+        final_gate_ran: finalGateRan,
+        generated_output_mismatch: input.generated_output_mismatch === true
+    };
+}
+export function completionOutputContractFromState(state) {
+    const finalRecord = state.final;
+    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
+    const hasStoredOutput = typeof finalRecord.completion_output_status === "string" || typeof gate.completion_output_status === "string";
+    const contract = resolveCompletionOutputStatus({
+        final_gate_ran: hasStoredOutput || isRecord(state.gates?.final_gate),
+        product_goal_complete: state.final.product_goal_complete,
+        acceptance_target_status: state.final.acceptance_target_status,
+        audit_task_complete: state.final.audit_task_complete,
+        blocked_reasons: asStringArray(finalRecord.blocked_reasons ?? gate.blocked_reasons),
+        rejection_reasons: asStringArray(finalRecord.rejection_reasons ?? gate.rejection_reasons),
+        generated_output_mismatch: finalRecord.generated_output_mismatch === true || gate.generated_output_mismatch === true
+    });
+    const triage = isRecord(finalRecord.blocker_triage)
+        ? finalRecord.blocker_triage
+        : isRecord(gate.blocker_triage)
+            ? gate.blocker_triage
+            : undefined;
+    const candidate = isRecord(finalRecord.candidate_state)
+        ? finalRecord.candidate_state
+        : isRecord(gate.candidate_state)
+            ? gate.candidate_state
+            : undefined;
+    if (triage) {
+        contract.blocker_triage = triage;
+    }
+    if (candidate) {
+        contract.candidate_state = candidate;
+    }
+    return contract;
+}
+export function applyCompletionOutputContract(state, contract) {
+    const finalRecord = state.final;
+    const metaRecord = state.meta;
+    finalRecord.product_goal_complete = contract.product_goal_complete;
+    state.meta.product_goal_complete = contract.product_goal_complete;
+    finalRecord.acceptance_target_status = contract.acceptance_target_status;
+    state.meta.acceptance_target_status = contract.acceptance_target_status;
+    finalRecord.audit_task_complete = contract.audit_task_complete;
+    state.meta.audit_task_complete = contract.audit_task_complete;
+    finalRecord.completion_output_status = contract.completion_output_status;
+    finalRecord.final_answer_allowed = contract.final_answer_allowed;
+    finalRecord.required_user_visible_status = contract.required_user_visible_status;
+    finalRecord.final_answer = contract.final_answer;
+    finalRecord.exit_code = contract.exit_code;
+    finalRecord.blocked_reasons = contract.blocked_reasons;
+    finalRecord.rejection_reasons = contract.rejection_reasons;
+    finalRecord.generated_output_mismatch = contract.generated_output_mismatch;
+    if (contract.blocker_triage) {
+        finalRecord.blocker_triage = contract.blocker_triage;
+    }
+    if (contract.candidate_state) {
+        finalRecord.candidate_state = contract.candidate_state;
+    }
+    metaRecord.completion_output_status = contract.completion_output_status;
+}
+export function scanFalseCompletionPhrases(input) {
+    return scanFalseCompletionPhrasesDetailed(input);
+}
+export function scanFalseCompletionPhrasesDetailed(input) {
+    if (input.completion_output_status === "accept") {
+        return [];
+    }
+    const surfaces = typeof input.surfaces === "string" ? [{ surface: "inline", text: input.surfaces }] : input.surfaces;
+    const findings = [];
+    for (const surface of surfaces) {
+        const lines = surface.text.split(/\r?\n/);
+        for (const [index, line] of lines.entries()) {
+            const allowed = classifyAllowedCompletionLine(surface.surface, line);
+            if (allowed) {
+                continue;
+            }
+            for (const item of FORBIDDEN_PHRASES) {
+                if (item.pattern.test(line)) {
+                    findings.push({
+                        surface: surface.surface,
+                        surface_type: classifySurfaceLine(surface.surface, line),
+                        classification: "true_false_completion_claim",
+                        phrase: item.phrase,
+                        line: index + 1,
+                        text: line.trim(),
+                        self_recoverable: isSelfRecoverableSurface(surface.surface)
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return findings;
+}
+export async function scanGeneratedCompletionOutputSurfaces(workdir, contract) {
+    return scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract);
+}
+export async function scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract) {
+    const surfaces = [];
+    for (const relative of GENERATED_COMPLETION_SURFACES) {
+        const file = path.join(workdir, ...relative.split("/"));
+        if (await pathExists(file)) {
+            surfaces.push({ surface: relative, text: await readText(file) });
+        }
+    }
+    return scanFalseCompletionPhrasesDetailed({ completion_output_status: contract.completion_output_status, surfaces });
+}
+export function completionPhraseFindingMessages(findings) {
+    return findings.map((finding) => {
+        const kind = finding.classification ? ` ${finding.classification}` : "";
+        return `false completion phrase${kind} in ${finding.surface}:${finding.line}: ${finding.phrase}`;
+    });
+}
+export function triageFinalGateBlockers(input) {
+    const errors = unique(input.errors);
+    const findings = input.output_findings ?? [];
+    const previous = unique(input.previous_transient_findings ?? []);
+    const details = unique([...errors, ...findings.map((finding) => `${finding.surface}:${finding.line}:${finding.phrase}`), ...previous]);
+    const recoveryAttempted = input.recovery_attempted === true;
+    const recoveryAction = input.recovery_action ?? "";
+    if (findings.length > 0) {
+        const selfRecoverable = findings.every((finding) => finding.self_recoverable === true);
+        return {
+            category: selfRecoverable ? "self_recoverable_generated_output_mismatch" : "generated_output_mismatch",
+            self_recoverable: selfRecoverable,
+            recovery_attempted: recoveryAttempted,
+            recovery_action: recoveryAction,
+            next_action: selfRecoverable
+                ? "regenerate derived generated-output surfaces and rerun final-gate once"
+                : "remove or regenerate the user-visible false completion wording before final-gate can accept",
+            details,
+            blocker_count: findings.length
+        };
+    }
+    const text = errors.join("\n");
+    if (/harness_drift|protected_baseline|product task modified|harness task missing/i.test(text)) {
+        return blocker("harness_drift_blocked", false, recoveryAttempted, recoveryAction, "split harness changes into a harness_task with adversarial fixtures before proving product completion", details);
+    }
+    if (/source file is missing|source_unreadable|scope_conflict_requires_decision|three[- ]input|Product \/ Plan \/ Checklist|Context Delta coverage is unresolved/i.test(text)) {
+        return blocker("contract_blocked", false, recoveryAttempted, recoveryAction, "clarify or restore the source contract before rerunning final-gate", details);
+    }
+    if (/required command not_run|command not_run|browser unavailable|playwright unavailable|dependency unavailable|environment_unknown|required_validator_unavailable|permission|MFA/i.test(text)) {
+        return blocker("environment_blocked", false, recoveryAttempted, recoveryAction, "restore the unavailable command, browser, dependency or permission and rerun final-gate", details);
+    }
+    if (/stale evidence|negative evidence|current contradiction|source hash mismatch|dirty worktree|failed_test_result_artifact|owner_dom_forbidden_state|playwright_last_run_failed/i.test(text)) {
+        return blocker("stale_or_contradictory_evidence", false, recoveryAttempted, recoveryAction, "replace stale or contradictory evidence with fresh current-attempt evidence", details);
+    }
+    if (/missing current|missing assertion result|not machine-backed|missing required proof layer|proof layer .*missing|requires all required plan items|incomplete|no evidence_ids|unknown evidence_id/i.test(text)) {
+        return blocker("missing_current_evidence", false, recoveryAttempted, recoveryAction, "add fresh current-attempt evidence for the missing AC, PI or proof layer", details);
+    }
+    if (previous.length > 0 && errors.length === 0) {
+        return blocker("transient_state_bookkeeping", true, recoveryAttempted, recoveryAction || "cleared previous transient bookkeeping before current candidate scan", "cleared previous transient bookkeeping; no user action required", details);
+    }
+    if (errors.length > 0) {
+        return blocker("product_evidence_failed", false, recoveryAttempted, recoveryAction, "fix the current product evidence failure and rerun final-gate", details);
+    }
+    return blocker("none", false, recoveryAttempted, recoveryAction, "no blocker remains", details);
+}
+function normalizeAcceptanceTargetStatus(value) {
+    const normalized = String(value ?? "not_run").trim().toLowerCase();
+    if (normalized === "accepted") {
+        return "complete";
+    }
+    if (normalized === "not accepted") {
+        return "not_accepted";
+    }
+    return normalized || "not_run";
+}
+function isAcceptedStatus(value) {
+    return value === "complete" || value === "accepted";
+}
+function classifyAllowedCompletionLine(surface, line) {
+    const text = line.trim();
+    if (!text) {
+        return "allowed_rule_explanation";
+    }
+    if (/Audit workflow completed; acceptance target not complete\./i.test(text)) {
+        return "allowed_rule_explanation";
+    }
+    if (/^Product goal complete:\s*false$/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    if (/^(?:complete|partial|acceptance_required|missing_layer)_count:\s*\d+$/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    if (/^-\s+[A-Z]+-\d+:\s*(?:complete|accepted|accept)\s*$/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    const jsonField = /^"([^"]+)"\s*:\s*/.exec(text);
+    if (jsonField && !/^(final_answer|final_conclusion|conclusion|summary|message|required_user_visible_status)$/i.test(jsonField[1])) {
+        return "allowed_machine_status_field";
+    }
+    if (/\b(product_goal_complete|completion_output_status|acceptance_target_status|audit_task_complete)\b/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    if (isDiagnosticSurface(surface) && /["']?(overall_)?status["']?\s*:\s*["']?(complete|accepted|accept)["']?/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    if (/diagnostic|row-level|row status|not[_ -]?in[_ -]?scope/i.test(text)) {
+        return "allowed_diagnostic_status";
+    }
+    if (/\b(do not|must not|cannot|never|unless|only when|forbid|forbidden|invalid|false[- ]completion|does not mean|cannot authorize|cannot imply)\b/i.test(text)) {
+        return "allowed_rule_explanation";
+    }
+    if (/\bnot\s+(?:complete|completed|accepted|accept|done|successful)\b/i.test(text)) {
+        return "allowed_rule_explanation";
+    }
+    if (/不得|不能|禁止|仅当|不是|不等于/.test(text)) {
+        return "allowed_rule_explanation";
+    }
+    return undefined;
+}
+function classifySurfaceLine(surface, line) {
+    const normalized = surface.split(path.sep).join("/");
+    if (/^Final answer:|Goal achieved|ready to merge|implementation complete/i.test(line)) {
+        return "agent_final_answer";
+    }
+    if (normalized.endsWith("derived/final-summary.md")) {
+        return "user_visible_final_summary";
+    }
+    if (normalized.endsWith("derived/final-card.md")) {
+        return "final_card";
+    }
+    if (normalized.endsWith("goal-objective.txt")) {
+        return "agent_final_answer";
+    }
+    if (normalized.endsWith("execution-binding.md")) {
+        return "execution_binding_text";
+    }
+    if (normalized.endsWith("workflow-protocol.md")) {
+        return "workflow_protocol_text";
+    }
+    if (/final-acceptance-verdict\.json$/.test(normalized)) {
+        return "verdict_diagnostic";
+    }
+    if (/plan-conformance-matrix\.json$/.test(normalized)) {
+        return "matrix_diagnostic";
+    }
+    if (/\.json$/.test(normalized)) {
+        return "machine_readable_json_status";
+    }
+    if (/local-audit/.test(normalized)) {
+        return "local_audit_diagnostic";
+    }
+    if (/derived\//.test(normalized)) {
+        return "generated_summary";
+    }
+    return "unknown";
+}
+function isSelfRecoverableSurface(surface) {
+    const normalized = surface.split(path.sep).join("/");
+    return /^derived\/(?:final-summary|final-card|final-acceptance-verdict|plan-conformance-matrix|local-audit)\.(?:md|json)$/.test(normalized);
+}
+function isDiagnosticSurface(surface) {
+    const type = classifySurfaceLine(surface, "");
+    return (type === "machine_readable_json_status" ||
+        type === "derived_diagnostic_json" ||
+        type === "matrix_diagnostic" ||
+        type === "verdict_diagnostic" ||
+        type === "local_audit_diagnostic");
+}
+function blocker(category, selfRecoverable, recoveryAttempted, recoveryAction, nextAction, details) {
+    return {
+        category,
+        self_recoverable: selfRecoverable,
+        recovery_attempted: recoveryAttempted,
+        recovery_action: recoveryAction,
+        next_action: nextAction,
+        details,
+        blocker_count: category === "none" ? 0 : Math.max(1, details.length)
+    };
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

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

@@ -15,11 +15,15 @@ export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
         failures.push(`${label} stale evidence from old attempt ${evidence.task_attempt_id || "(missing)"}; expected current attempt ${state.current_attempt_id}`);
     }
     for (const field of [
+        "generated_at",
         "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",
         "command_spec_id",
         "command_run_id",
@@ -48,9 +52,24 @@ export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
     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.git_status_short !== undefined && evidence.git_status_short !== attempt.git_status_short) {
+        failures.push(`${label} stale evidence git_status_short mismatch for current attempt`);
+    }
+    if (attempt && evidence.tracked_diff_hash !== undefined && evidence.tracked_diff_hash !== attempt.tracked_diff_hash) {
+        failures.push(`${label} stale evidence tracked_diff_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.relevant_untracked_hash !== undefined && evidence.relevant_untracked_hash !== attempt.relevant_untracked_hash) {
+        failures.push(`${label} stale evidence relevant_untracked_hash 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 && (attempt.git_status_short || attempt.relevant_untracked_hash !== "none") && evidence.covers_dirty_worktree !== true) {
+        failures.push(`${label} dirty worktree evidence must set covers_dirty_worktree=true for current attempt`);
+    }
+    if (attempt && evidence.generated_at && Date.parse(evidence.generated_at) < Date.parse(attempt.started_at)) {
+        failures.push(`${label} stale evidence generated_at predates 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`);
     }
@@ -65,6 +84,9 @@ export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
         if (commandRun.exit_code !== 0) {
             failures.push(`${label} command run ${commandRun.command_run_id} exit_code=${commandRun.exit_code}; expected 0`);
         }
+        if (!commandRun.completed_at) {
+            failures.push(`${label} command run ${commandRun.command_run_id} missing completed_at`);
+        }
         if (commandRun.command_spec_id !== evidence.command_spec_id) {
             failures.push(`${label} command_spec_id mismatch between evidence and command run`);
         }