project-tiny-context-harness 0.2.83 → 0.2.85

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

@@ -2,7 +2,9 @@ import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { deriveSuperpowersArtifacts } from "./superpowers-task-derive.js";
 import { validatePlanAcceptance } from "./plan-acceptance-validator.js";
 import { loadSuperpowersState, saveSuperpowersState } from "./superpowers-task-state.js";
+import { applyCompletionOutputContract, completionPhraseFindingMessages, resolveCompletionOutputStatus, scanGeneratedCompletionOutputSurfacesDetailed, triageFinalGateBlockers } from "./superpowers-task-completion-output.js";
 import { applyTrustedEvidenceKernelResult, evaluateTrustedEvidenceKernel } from "./superpowers-task-evidence-kernel.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
 import { validateSuperpowersState } from "./superpowers-task-validator.js";
 export async function runSliceGate(workdir, sliceId) {
     const state = await loadSuperpowersState(workdir);
@@ -24,25 +26,48 @@ export async function runEpochGate(workdir, epochId) {
     return { passed: true, messages: ["epoch derived artifacts refreshed"] };
 }
 export async function runFinalGate(workdir) {
+    return runFinalGateOnce(workdir, { recoveryAttempted: false, recoveryAction: "" });
+}
+async function runFinalGateOnce(workdir, options) {
     const state = await loadSuperpowersState(workdir);
+    const previousTransientFindings = previousTransientBookkeepingFindings(state);
     const kernel = await evaluateTrustedEvidenceKernel(workdir, state);
     applyTrustedEvidenceKernelResult(state, kernel);
     state.gates.validator = { status: "not_run", kernel: "trusted_evidence_kernel" };
+    const candidateContract = resolveCompletionOutputStatus({
+        final_gate_ran: true,
+        product_goal_complete: kernel.product_goal_complete && kernel.errors.length === 0,
+        acceptance_target_status: kernel.product_goal_complete && kernel.errors.length === 0 ? "complete" : kernel.acceptance_target_status,
+        audit_task_complete: true,
+        validator_errors: kernel.errors,
+        rejection_reasons: kernel.product_goal_complete ? [] : kernel.errors.slice(0, 12)
+    });
+    const candidateState = candidateStateFromContract(candidateContract);
+    candidateContract.candidate_state = candidateState;
+    applyCompletionOutputContract(state, candidateContract);
+    state.final.completion_basis = candidateContract.product_goal_complete
+        ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
+        : [];
     await saveSuperpowersState(workdir, state);
     await deriveSuperpowersArtifacts(workdir);
     const report = await validateSuperpowersState(workdir, [workdir]);
     const acceptanceReport = await validatePlanAcceptance(workdir, [workdir]);
     const latest = await loadSuperpowersState(workdir);
-    const errors = [...new Set([...kernel.errors, ...report.errors, ...acceptanceReport.errors])];
-    const complete = kernel.product_goal_complete && errors.length === 0;
+    let errors = [...new Set([...kernel.errors, ...report.errors, ...acceptanceReport.errors])];
+    let complete = kernel.product_goal_complete && errors.length === 0;
     const acceptanceStatus = complete ? "complete" : acceptanceStatusForErrors(errors, kernel);
     const nextRequiredActions = complete ? [] : nextActionsForErrors(errors);
-    latest.final.product_goal_complete = complete;
-    latest.meta.product_goal_complete = complete;
-    latest.final.acceptance_target_status = acceptanceStatus;
-    latest.meta.acceptance_target_status = latest.final.acceptance_target_status;
-    latest.final.audit_task_complete = true;
-    latest.meta.audit_task_complete = true;
+    let contract = resolveCompletionOutputStatus({
+        final_gate_ran: true,
+        product_goal_complete: complete,
+        acceptance_target_status: acceptanceStatus,
+        audit_task_complete: true,
+        validator_errors: report.errors,
+        acceptance_validator_errors: acceptanceReport.errors,
+        rejection_reasons: complete ? [] : nextRequiredActions
+    });
+    contract.candidate_state = candidateState;
+    applyCompletionOutputContract(latest, contract);
     latest.final.completion_basis = complete
         ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
         : [];
@@ -51,31 +76,126 @@ export async function runFinalGate(workdir) {
     latest.gates.final_gate = {
         status: complete ? "pass" : acceptanceStatus,
         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"
-        ],
+        order: kernel.kernel_order,
         errors,
         stale_evidence_ids: kernel.stale_evidence_ids,
+        ignored_unregistered_evidence: kernel.ignored_unregistered_evidence,
+        invalidated_evidence_ids: kernel.invalidated_evidence_ids,
+        ac_findings: kernel.ac_findings,
+        pi_findings: kernel.pi_findings,
         harness_task_final_verdict: kernel.harness_task_final_verdict,
-        next_required_actions: nextRequiredActions
+        next_required_actions: nextRequiredActions,
+        completion_output_status: contract.completion_output_status,
+        final_answer_allowed: contract.final_answer_allowed,
+        required_user_visible_status: contract.required_user_visible_status,
+        exit_code: contract.exit_code,
+        blocked_reasons: contract.blocked_reasons,
+        rejection_reasons: contract.rejection_reasons,
+        generated_output_mismatch: contract.generated_output_mismatch,
+        candidate_state: candidateState,
+        previous_bookkeeping_snapshot: previousTransientFindings
     };
     await saveSuperpowersState(workdir, latest);
     await deriveSuperpowersArtifacts(workdir);
-    await appendSuperpowersEvent(workdir, "final_gate", { product_goal_complete: complete });
-    return { product_goal_complete: complete, errors };
+    const outputFindings = await scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract);
+    let triage = triageFinalGateBlockers({
+        errors,
+        output_findings: outputFindings,
+        previous_transient_findings: previousTransientFindings,
+        candidate_state: candidateState,
+        recovery_attempted: options.recoveryAttempted || previousTransientFindings.length > 0,
+        recovery_action: options.recoveryAction || (previousTransientFindings.length > 0 ? "cleared previous transient bookkeeping" : "")
+    });
+    if (outputFindings.length > 0 && triage.self_recoverable && !options.recoveryAttempted) {
+        await deriveSuperpowersArtifacts(workdir);
+        return runFinalGateOnce(workdir, { recoveryAttempted: true, recoveryAction: "regenerated_derived_outputs" });
+    }
+    if (outputFindings.length > 0) {
+        errors = [...new Set([...errors, ...completionPhraseFindingMessages(outputFindings)])];
+        complete = false;
+        triage = triageFinalGateBlockers({
+            errors,
+            output_findings: outputFindings,
+            previous_transient_findings: previousTransientFindings,
+            candidate_state: candidateState,
+            recovery_attempted: options.recoveryAttempted,
+            recovery_action: options.recoveryAction
+        });
+        contract = resolveCompletionOutputStatus({
+            final_gate_ran: true,
+            product_goal_complete: false,
+            acceptance_target_status: acceptanceStatusForErrors(errors, kernel),
+            audit_task_complete: true,
+            validator_errors: errors,
+            generated_output_mismatch: true
+        });
+        contract.candidate_state = candidateState;
+        contract.blocker_triage = triage;
+        const blockedLatest = await loadSuperpowersState(workdir);
+        applyCompletionOutputContract(blockedLatest, contract);
+        blockedLatest.final.completion_basis = [];
+        blockedLatest.final.next_required_actions = nextActionsForErrors(errors);
+        blockedLatest.gates.validator = { status: "blocked", errors };
+        blockedLatest.gates.final_gate = {
+            ...(isRecord(blockedLatest.gates.final_gate) ? blockedLatest.gates.final_gate : {}),
+            status: contract.completion_output_status,
+            errors,
+            next_required_actions: blockedLatest.final.next_required_actions,
+            completion_output_status: contract.completion_output_status,
+            final_answer_allowed: contract.final_answer_allowed,
+            required_user_visible_status: contract.required_user_visible_status,
+            exit_code: contract.exit_code,
+            blocked_reasons: contract.blocked_reasons,
+            rejection_reasons: contract.rejection_reasons,
+            generated_output_mismatch: contract.generated_output_mismatch,
+            false_completion_phrase_findings: outputFindings,
+            candidate_state: candidateState,
+            blocker_triage: triage,
+            previous_bookkeeping_snapshot: previousTransientFindings
+        };
+        blockedLatest.final.false_completion_phrase_findings = outputFindings;
+        await saveSuperpowersState(workdir, blockedLatest);
+        await deriveSuperpowersArtifacts(workdir);
+    }
+    else {
+        if (triage.category === "environment_blocked" || triage.category === "contract_blocked" || triage.category === "harness_drift_blocked") {
+            contract = resolveCompletionOutputStatus({
+                final_gate_ran: true,
+                product_goal_complete: false,
+                acceptance_target_status: "blocked",
+                audit_task_complete: true,
+                validator_errors: errors,
+                blocked_reasons: [triage.category],
+                rejection_reasons: []
+            });
+            contract.candidate_state = candidateState;
+        }
+        contract.blocker_triage = triage;
+        const triagedLatest = await loadSuperpowersState(workdir);
+        applyCompletionOutputContract(triagedLatest, contract);
+        triagedLatest.final.next_required_actions = contract.completion_output_status === "accept" ? [] : nextActionsForErrors(errors);
+        triagedLatest.gates.final_gate = {
+            ...(isRecord(triagedLatest.gates.final_gate) ? triagedLatest.gates.final_gate : {}),
+            completion_output_status: contract.completion_output_status,
+            final_answer_allowed: contract.final_answer_allowed,
+            required_user_visible_status: contract.required_user_visible_status,
+            exit_code: contract.exit_code,
+            blocked_reasons: contract.blocked_reasons,
+            rejection_reasons: contract.rejection_reasons,
+            generated_output_mismatch: contract.generated_output_mismatch,
+            candidate_state: candidateState,
+            blocker_triage: triage,
+            previous_bookkeeping_snapshot: previousTransientFindings
+        };
+        await saveSuperpowersState(workdir, triagedLatest);
+        await deriveSuperpowersArtifacts(workdir);
+    }
+    await appendSuperpowersEvent(workdir, "final_gate", {
+        product_goal_complete: contract.product_goal_complete,
+        completion_output_status: contract.completion_output_status,
+        blocker_triage: contract.blocker_triage
+    });
+    return { ...contract, blocker_triage: contract.blocker_triage ?? triage, errors };
 }
 function acceptanceStatusForErrors(errors, kernel) {
     const text = errors.join("\n");
@@ -113,3 +233,35 @@ function nextActionsForErrors(errors) {
         return error;
     });
 }
+function candidateStateFromContract(contract) {
+    return {
+        final_gate_ran: contract.final_gate_ran,
+        product_goal_complete: contract.product_goal_complete,
+        acceptance_target_status: contract.acceptance_target_status,
+        completion_output_status: contract.completion_output_status,
+        generated_output_mismatch: false,
+        source: "trusted_evidence_kernel"
+    };
+}
+function previousTransientBookkeepingFindings(state) {
+    const findings = [];
+    const finalRecord = state.final;
+    const metaRecord = state.meta;
+    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
+    collectTransient(findings, "final", finalRecord);
+    collectTransient(findings, "meta", metaRecord);
+    collectTransient(findings, "gates.final_gate", gate);
+    return [...new Set(findings)];
+}
+function collectTransient(findings, label, record) {
+    const status = typeof record.completion_output_status === "string" ? record.completion_output_status : "";
+    if (status === "blocked" || status === "reject") {
+        findings.push(`${label}.completion_output_status=${status}`);
+    }
+    if (record.generated_output_mismatch === true) {
+        findings.push(`${label}.generated_output_mismatch=true`);
+    }
+    if (Array.isArray(record.false_completion_phrase_findings) && record.false_completion_phrase_findings.length > 0) {
+        findings.push(`${label}.false_completion_phrase_findings=${record.false_completion_phrase_findings.length}`);
+    }
+}

package/dist/lib/superpowers-task-harness-drift.js

@@ -4,7 +4,8 @@ const HARNESS_PATH_PATTERNS = [
     /(^|\/)playwright\.config\./i,
     /(^|\/).*\.spec\.[cm]?[jt]sx?$/i,
     /(^|\/).*\.test\.[cm]?[jt]sx?$/i,
-    /superpowers-task-(assertions|evidence|evidence-kernel|current-evidence|command-specs|ac010|gates|validator|derive|state|state-schema|state-shape|under-specified|protected-baseline|harness-drift)\.ts$/i,
+    /(^|\/)tests\/ty-context\/fixtures\/composite-long-task\//i,
+    /superpowers-task-(assertions|evidence|evidence-kernel|current-evidence|command-specs|command-run-correlation|unregistered-evidence|completion-output|final-card|ac010|gates|validator|derive|state|state-schema|state-shape|under-specified|protected-baseline|harness-drift)\.ts$/i,
     /(^|\/)(\.codex\/ty-context-managed|packages\/ty-context\/assets)\/skills\/composite-long-task-workflow\//i,
     /composite-long-task-workflow-protocol\.md$/i,
     /(^|\/)Makefile$/i,
@@ -79,7 +80,10 @@ function harnessTaskFixtureVerdict(state, changedFiles) {
     };
 }
 function currentAttempt(state) {
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+    if (!state.current_attempt_id) {
+        return undefined;
+    }
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
 }
 function changedFilesFor(attempt) {
     return [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];

package/dist/lib/superpowers-task-protected-baseline.js

@@ -5,15 +5,31 @@ export const PROTECTED_BASELINE_PATHS = [
     ".codex/ty-context-managed/protected-harness-baseline.json",
     "packages/ty-context/source-mappings.yaml",
     "packages/ty-context/src/lib/superpowers-task-gates.ts",
+    "packages/ty-context/src/lib/superpowers-task-completion-output.ts",
+    "packages/ty-context/src/lib/superpowers-task-final-card.ts",
     "packages/ty-context/src/lib/superpowers-task-validator.ts",
     "packages/ty-context/src/lib/superpowers-task-derive.ts",
     "packages/ty-context/src/lib/superpowers-task-evidence.ts",
     "packages/ty-context/src/lib/superpowers-task-evidence-kernel.ts",
+    "packages/ty-context/src/lib/superpowers-task-current-evidence.ts",
+    "packages/ty-context/src/lib/superpowers-task-command-run-correlation.ts",
+    "packages/ty-context/src/lib/superpowers-task-unregistered-evidence.ts",
+    "packages/ty-context/src/lib/superpowers-task-ac010.ts",
+    "packages/ty-context/src/lib/superpowers-task-harness-drift.ts",
+    "packages/ty-context/src/lib/superpowers-task-protected-baseline.ts",
     "packages/ty-context/src/lib/superpowers-task-state-schema.ts",
     ".codex/ty-context-managed/skills/composite-long-task-workflow/SKILL.md",
     ".codex/ty-context-managed/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md",
+    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/goal-objective.template.md",
+    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/execution-binding.template.md",
     "packages/ty-context/assets/skills/composite-long-task-workflow/SKILL.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md"
+    "packages/ty-context/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md",
+    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/goal-objective.template.md",
+    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/execution-binding.template.md",
+    "tests/ty-context/composite-long-task-completion-output-gate.test.mjs",
+    "tests/ty-context/fixtures/composite-long-task/completion-output-gate/expected-outcomes.json",
+    "tests/ty-context/composite-long-task-false-completion-regression.test.mjs",
+    "tests/ty-context/fixtures/composite-long-task/false-completion-regression/manifest.json"
 ];
 export function evaluateProtectedBaseline(state) {
     const attempt = currentAttempt(state);
@@ -43,5 +59,8 @@ function protectedBaselineReason(state) {
     return isRecord(baseline) && typeof baseline.reason === "string" && baseline.reason.trim().length > 0;
 }
 function currentAttempt(state) {
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+    if (!state.current_attempt_id) {
+        return undefined;
+    }
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
 }

package/dist/lib/superpowers-task-state-schema.d.ts

@@ -76,6 +76,25 @@ export type SuperpowersProductDeliveryScope = "system_capability_build" | "repre
 export type SuperpowersPlanDeliveryScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "out_of_scope_backlog";
 export type SuperpowersAcceptanceScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "full_population_not_required";
 export type SuperpowersScopeFitDecision = "fit_for_three_inputs" | "selected_from_split" | "blocked_for_decision" | "";
+export type CompletionOutputStatus = "accept" | "reject" | "blocked";
+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 FinalGateCandidateStateRecord {
+    final_gate_ran: boolean;
+    product_goal_complete: boolean;
+    acceptance_target_status: string;
+    completion_output_status: CompletionOutputStatus;
+    generated_output_mismatch: boolean;
+    source: string;
+}
+export interface FinalGateBlockerTriageRecord {
+    category: FinalGateBlockerCategory;
+    self_recoverable: boolean;
+    recovery_attempted: boolean;
+    recovery_action: string;
+    next_action: string;
+    details: string[];
+    blocker_count: number;
+}
 export interface SuperpowersTaskState {
     meta: {
         task_id: string;
@@ -87,6 +106,7 @@ export interface SuperpowersTaskState {
         product_goal_complete: boolean;
         acceptance_target_status: string;
         audit_task_complete: boolean;
+        completion_output_status?: CompletionOutputStatus;
     };
     sources: Record<string, SuperpowersSourceRecord>;
     context: {
@@ -116,6 +136,17 @@ export interface SuperpowersTaskState {
         product_goal_complete: boolean;
         acceptance_target_status: string;
         audit_task_complete: boolean;
+        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[];
+        generated_output_mismatch?: boolean;
+        false_completion_phrase_findings?: unknown[];
+        blocker_triage?: FinalGateBlockerTriageRecord;
+        candidate_state?: FinalGateCandidateStateRecord;
         completion_basis: string[];
         next_required_actions?: string[];
     };
@@ -162,6 +193,7 @@ export interface CommandRunRecord {
     command_line: string;
     exit_code: number;
     started_at: string;
+    completed_at?: string;
     ended_at: string;
     artifact_paths: string[];
 }
@@ -336,11 +368,16 @@ export interface SuperpowersEvidenceRecord {
     schema_version?: "evidence-record-v1" | "evidence-record-v2" | string;
     evidence_id: string;
     task_attempt_id?: string;
+    generated_at?: string;
     source_bundle_hash?: string;
     product_source_hash?: string;
     technical_plan_hash?: string;
     acceptance_checklist_hash?: string;
     git_head?: string;
+    git_status_short?: string;
+    tracked_diff_hash?: string;
+    relevant_untracked_hash?: string;
+    covers_dirty_worktree?: boolean;
     worktree_fingerprint?: string;
     command_spec_id?: string;
     command_run_id?: string;

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

@@ -41,7 +41,8 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             goal_type: options.goalType ?? "implementation",
             product_goal_complete: false,
             acceptance_target_status: "not_run",
-            audit_task_complete: false
+            audit_task_complete: false,
+            completion_output_status: "blocked"
         },
         sources: await sourceRecords(workdir),
         context: {
@@ -88,6 +89,14 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             product_goal_complete: false,
             acceptance_target_status: "not_run",
             audit_task_complete: false,
+            completion_output_status: "blocked",
+            final_answer_allowed: false,
+            required_user_visible_status: "blocked",
+            final_answer: "blocked",
+            exit_code: 2,
+            blocked_reasons: ["final_gate_not_run"],
+            rejection_reasons: [],
+            generated_output_mismatch: false,
             completion_basis: [],
             next_required_actions: []
         }

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

@@ -0,0 +1,11 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface IgnoredUnregisteredEvidence {
+    path: string;
+    status: string;
+    target_ac_ids: string[];
+    target_proof_layers: string[];
+}
+export declare function scanUnregisteredAssertionEvidence(workdir: string, state: SuperpowersTaskState): Promise<{
+    ignored: IgnoredUnregisteredEvidence[];
+    errors: string[];
+}>;

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

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { listFiles, readText } from "./fs.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+export async function scanUnregisteredAssertionEvidence(workdir, state) {
+    const registeredPaths = new Set();
+    for (const evidence of state.evidence ?? []) {
+        for (const candidate of [evidence.artifact_path, ...(evidence.artifact_paths ?? []), ...(evidence.assertion_result?.artifacts ?? [])]) {
+            if (candidate) {
+                registeredPaths.add(slash(candidate));
+                registeredPaths.add(slash(path.join(workdir, candidate)));
+            }
+        }
+    }
+    const ignored = [];
+    for (const file of await listFiles(workdir)) {
+        if (!/\.json$/i.test(file)) {
+            continue;
+        }
+        const relative = slash(path.relative(workdir, file));
+        if (registeredPaths.has(relative) || registeredPaths.has(slash(file))) {
+            continue;
+        }
+        const parsed = await readJson(file);
+        const assertion = assertionRecord(parsed);
+        if (!assertion) {
+            continue;
+        }
+        const status = String(assertion.status ?? "");
+        if (status !== "passed") {
+            continue;
+        }
+        ignored.push({
+            path: relative,
+            status,
+            target_ac_ids: asStringArray(assertion.target_ac_ids),
+            target_proof_layers: asStringArray(assertion.target_proof_layers)
+        });
+    }
+    return {
+        ignored,
+        errors: ignored.map((item) => `ignored_unregistered_evidence: unregistered assertion JSON ${item.path} status=passed is not proof`)
+    };
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readText(file));
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertionRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    if (looksLikeAssertion(value)) {
+        return value;
+    }
+    if (isRecord(value.assertion_result) && looksLikeAssertion(value.assertion_result)) {
+        return value.assertion_result;
+    }
+    return undefined;
+}
+function looksLikeAssertion(value) {
+    return /assertion-result-v\d+/i.test(String(value.schema_version ?? "")) || (typeof value.status === "string" && Array.isArray(value.target_ac_ids));
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function slash(value) {
+    return value.replace(/\\/g, "/");
+}

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

@@ -12,6 +12,7 @@ import { loadSuperpowersState, sha256 } from "./superpowers-task-state.js";
 import { validateCanonicalStatuses } from "./superpowers-task-status.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
 import { evaluateProofLayerAssertions, isUiBrowserLayer, proofLayerName } from "./superpowers-task-assertions.js";
+import { completionOutputContractFromState, completionPhraseFindingMessages, scanGeneratedCompletionOutputSurfaces } from "./superpowers-task-completion-output.js";
 export async function validateSuperpowersState(projectRoot, args = []) {
     const info = [];
     const warnings = [];
@@ -47,12 +48,52 @@ export async function validateSuperpowersState(projectRoot, args = []) {
     validateAuditor(state, errors);
     validateFinalCompletion(state, errors);
     errors.push(...(await derivedMatchesState(targetDir, state)));
+    await validateCompletionOutputConsistency(targetDir, state, errors, info);
     info.push(`checked superpowers task state ${repoRelative(projectRoot, targetDir)} plan_items=${Object.keys(state.graph?.plan_items ?? {}).length} acs=${Object.keys(state.graph?.acceptance_criteria ?? {}).length} evidence=${state.evidence?.length ?? 0}`);
     if (errors.length === 0) {
         info.push("Superpowers task state validation passed");
     }
     return { info, warnings, hygiene, errors };
 }
+async function validateCompletionOutputConsistency(workdir, state, errors, info) {
+    const contract = completionOutputContractFromState(state);
+    const finalRecord = state.final;
+    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
+    const storedStatus = finalRecord.completion_output_status ?? (typeof gate.completion_output_status === "string" ? gate.completion_output_status : undefined);
+    if (storedStatus && storedStatus !== contract.completion_output_status) {
+        errors.push(`completion_output_status mismatch: expected ${contract.completion_output_status}, found ${storedStatus}`);
+    }
+    if (contract.completion_output_status === "accept" && state.final.product_goal_complete !== true) {
+        errors.push("completion_output_status=accept but product_goal_complete is not true");
+    }
+    if (finalRecord.final_answer_allowed !== undefined && finalRecord.final_answer_allowed !== contract.final_answer_allowed) {
+        errors.push(`final_answer_allowed mismatch: expected ${contract.final_answer_allowed}, found ${finalRecord.final_answer_allowed}`);
+    }
+    if (finalRecord.required_user_visible_status && finalRecord.required_user_visible_status !== contract.required_user_visible_status) {
+        errors.push(`required_user_visible_status mismatch: expected ${contract.required_user_visible_status}, found ${finalRecord.required_user_visible_status}`);
+    }
+    if (finalRecord.exit_code !== undefined && finalRecord.exit_code !== contract.exit_code) {
+        errors.push(`completion output exit_code mismatch: expected ${contract.exit_code}, found ${finalRecord.exit_code}`);
+    }
+    if (contract.blocker_triage) {
+        info.push(`blocker_triage category=${contract.blocker_triage.category} self_recoverable=${contract.blocker_triage.self_recoverable} next_action=${contract.blocker_triage.next_action}`);
+    }
+    errors.push(...completionPhraseFindingMessages(await scanGeneratedCompletionOutputSurfaces(workdir, contract)));
+    await validateMarkdownCompletionStatus(workdir, contract.completion_output_status, errors);
+}
+async function validateMarkdownCompletionStatus(workdir, expectedStatus, errors) {
+    for (const relative of ["derived/final-summary.md", "derived/final-card.md", "derived/local-audit.md"]) {
+        const file = path.join(workdir, ...relative.split("/"));
+        if (!(await pathExists(file))) {
+            continue;
+        }
+        const text = await readText(file);
+        const match = /^completion_output_status:\s*(\S+)\s*$/im.exec(text);
+        if (match && match[1] !== expectedStatus) {
+            errors.push(`${relative} completion_output_status mismatch: expected ${expectedStatus}, found ${match[1]}`);
+        }
+    }
+}
 async function validateSourceHashes(workdir, state, errors) {
     for (const [key, source] of Object.entries(state.sources ?? {})) {
         const file = path.join(workdir, source.path);