project-tiny-context-harness 0.2.83 → 0.2.84

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

@@ -1,17 +1,45 @@
-import { deriveRequiredCommandSpecs, requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+import { deriveRequiredCommandSpecs } from "./superpowers-task-command-specs.js";
+import { validateCommandRunsForSpec, validateRequiredCommandCorrelation } from "./superpowers-task-command-run-correlation.js";
 import { evaluateAc010Bootstrap } from "./superpowers-task-ac010.js";
 import { evaluateCurrentAttemptArtifact } from "./superpowers-task-current-evidence.js";
 import { scanSuperpowersContradictions } from "./superpowers-task-contradictions.js";
 import { detectHarnessDrift } from "./superpowers-task-harness-drift.js";
 import { evaluateProtectedBaseline } from "./superpowers-task-protected-baseline.js";
+import { validateScopeConflicts } from "./superpowers-task-delivery.js";
 import { evaluateProofLayerAssertions, isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { scanUnregisteredAssertionEvidence } from "./superpowers-task-unregistered-evidence.js";
 import { findUnderSpecifiedAcs } from "./superpowers-task-under-specified.js";
 import { loadSuperpowersState, sourceRecords } from "./superpowers-task-state.js";
+export const TRUSTED_EVIDENCE_KERNEL_ORDER = [
+    "load_three_inputs",
+    "recompute_source_hashes",
+    "load_task_state",
+    "resolve_current_attempt",
+    "load_required_command_specs",
+    "load_command_run_records",
+    "load_registered_evidence_records",
+    "discard_stale_evidence",
+    "scan_unregistered_assertion_json",
+    "scan_contradictions",
+    "run_ac010_bootstrap_prevention",
+    "run_under_specified_ac_checks",
+    "run_harness_drift_lock",
+    "run_protected_baseline_guard",
+    "validate_scope_conflicts",
+    "recompute_every_ac",
+    "recompute_every_pi",
+    "recompute_acceptance_target_status",
+    "recompute_product_goal_complete",
+    "regenerate_derived",
+    "append_final_gate_event"
+];
 export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
     const state = providedState ?? (await loadSuperpowersState(workdir));
     const errors = [];
     const acStatuses = {};
+    const acFindings = {};
     const staleEvidenceIds = new Set();
+    const invalidatedEvidenceIds = new Set();
     const attempt = currentAttempt(state);
     const currentSources = await sourceRecords(workdir);
     if (!attempt) {
@@ -21,7 +49,9 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
         validateAttemptAgainstSources(state, attempt, currentSources, errors);
     }
     const expectedSpecs = deriveRequiredCommandSpecs(state);
-    validateRequiredSpecs(state, attempt, expectedSpecs, errors);
+    const commandCorrelation = validateRequiredCommandCorrelation(state, attempt, expectedSpecs);
+    errors.push(...commandCorrelation.errors);
+    commandCorrelation.invalidated_evidence_ids.forEach((id) => invalidatedEvidenceIds.add(id));
     const underSpecified = new Map(findUnderSpecifiedAcs(state).map((item) => [item.ac_id, item.reasons]));
     for (const reasons of underSpecified.values()) {
         errors.push(...reasons);
@@ -32,11 +62,15 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
     errors.push(...drift.errors);
     const baseline = evaluateProtectedBaseline(state);
     errors.push(...baseline.errors);
+    validateScopeConflicts(state, errors);
+    const unregistered = await scanUnregisteredAssertionEvidence(workdir, state);
+    errors.push(...unregistered.errors);
     const evidenceById = new Map((state.evidence ?? []).map((evidence) => [evidence.evidence_id, evidence]));
     for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
         const acErrors = [];
         if (underSpecified.has(acId)) {
             acStatuses[acId] = "under_specified";
+            acFindings[acId] = underSpecified.get(acId) ?? [];
             continue;
         }
         const requiredLayers = ac.required_proof_layers ?? [];
@@ -65,6 +99,9 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
                     }
                     acErrors.push(...validateEvidenceAgainstSpec(state, evidence, spec, layerId));
                     acErrors.push(...(await evaluateCurrentAttemptArtifact(workdir, evidence, layerId)));
+                    if (invalidatedEvidenceIds.has(evidence.evidence_id)) {
+                        acErrors.push(`${layerId} evidence ${evidence.evidence_id} invalidated by newer failed command`);
+                    }
                     if (isStaleEvidenceError(acErrors)) {
                         staleEvidenceIds.add(evidence.evidence_id);
                     }
@@ -73,6 +110,7 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
         }
         errors.push(...acErrors);
         acStatuses[acId] = statusForAcErrors(acErrors, requiredLayers.length);
+        acFindings[acId] = acErrors;
     }
     const ac010 = evaluateAc010Bootstrap(state, acStatuses);
     for (const acId of ac010.invalidated_ac_ids) {
@@ -80,6 +118,7 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
     }
     errors.push(...ac010.errors);
     const piStatuses = recomputePlanStatuses(state, acStatuses);
+    const piFindings = planFindings(state, acStatuses, piStatuses);
     const allAcsComplete = Object.keys(state.graph?.acceptance_criteria ?? {}).length > 0 &&
         Object.values(acStatuses).every((status) => status === "complete" || status === "out_of_scope_NA");
     const allPisComplete = Object.keys(state.graph?.plan_items ?? {}).length > 0 &&
@@ -93,6 +132,11 @@ export async function evaluateTrustedEvidenceKernel(workdir, providedState) {
         ac_statuses: acStatuses,
         pi_statuses: piStatuses,
         stale_evidence_ids: [...staleEvidenceIds],
+        ignored_unregistered_evidence: unregistered.ignored,
+        invalidated_evidence_ids: [...invalidatedEvidenceIds],
+        kernel_order: [...TRUSTED_EVIDENCE_KERNEL_ORDER],
+        ac_findings: acFindings,
+        pi_findings: piFindings,
         harness_task_final_verdict: drift.harness_task_final_verdict
     };
 }
@@ -122,24 +166,13 @@ export function applyTrustedEvidenceKernelResult(state, result) {
     state.gates.final_gate = {
         status: result.product_goal_complete ? "pass" : result.acceptance_target_status,
         kernel: "trusted_evidence_kernel",
-        order: [
-            "load_three_inputs",
-            "recompute_source_hashes",
-            "load_task_state",
-            "load_current_attempt",
-            "load_command_run_records",
-            "load_registered_evidence_records",
-            "discard_stale_evidence",
-            "contradiction_scan",
-            "recompute_every_ac",
-            "recompute_every_pi",
-            "recompute_acceptance_target_status",
-            "recompute_product_goal_complete",
-            "regenerate_derived",
-            "append_event"
-        ],
+        order: result.kernel_order,
         errors: result.errors,
         stale_evidence_ids: result.stale_evidence_ids,
+        ignored_unregistered_evidence: result.ignored_unregistered_evidence,
+        invalidated_evidence_ids: result.invalidated_evidence_ids,
+        ac_findings: result.ac_findings,
+        pi_findings: result.pi_findings,
         harness_task_final_verdict: result.harness_task_final_verdict,
         next_required_actions: state.final.next_required_actions
     };
@@ -183,57 +216,6 @@ function validateAttemptAgainstSources(state, attempt, currentSources, errors) {
         }
     }
 }
-function validateRequiredSpecs(state, attempt, expectedSpecs, errors) {
-    const expectedByAc = new Map(expectedSpecs.map((spec) => [spec.ac_id, spec]));
-    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
-        if (ac.machine_blocking !== true && ac.assertion_result_required !== true) {
-            continue;
-        }
-        const expected = expectedByAc.get(acId);
-        const actual = (state.required_command_specs ?? []).find((spec) => spec.ac_id === acId);
-        if (!expected || !actual) {
-            errors.push(`${acId} missing required_command_spec`);
-            continue;
-        }
-        if (actual.command_spec_id !== expected.command_spec_id) {
-            errors.push(`${acId} command_spec_id mismatch; required command specs must be recompiled from Acceptance Checklist`);
-        }
-    }
-    if (attempt) {
-        const specsHash = requiredCommandSpecsHash(state.required_command_specs ?? []);
-        if (attempt.required_command_specs_hash !== specsHash) {
-            errors.push("required_command_specs_hash mismatch for current attempt");
-        }
-    }
-}
-function validateCommandRunsForSpec(state, attempt, spec) {
-    const errors = [];
-    for (const proofLayer of spec.proof_layers.filter((layer) => isMachineVerifiableLayer(`${spec.ac_id}.${layer}`))) {
-        const run = (state.command_runs ?? []).find((item) => item.task_attempt_id === state.current_attempt_id &&
-            item.command_spec_id === spec.command_spec_id &&
-            item.ac_id === spec.ac_id &&
-            item.proof_layer === proofLayer);
-        if (!run) {
-            errors.push(`${spec.ac_id}.${proofLayer} missing current attempt command-run record for command_spec_id ${spec.command_spec_id}`);
-            continue;
-        }
-        errors.push(...validateCommandRun(run, attempt));
-    }
-    return errors;
-}
-function validateCommandRun(run, attempt) {
-    const errors = [];
-    if (attempt && run.task_attempt_id !== attempt.task_attempt_id) {
-        errors.push(`${run.command_run_id} stale command run from ${run.task_attempt_id}; expected ${attempt.task_attempt_id}`);
-    }
-    if (run.exit_code !== 0) {
-        errors.push(`${run.command_run_id} command_exit_code=${run.exit_code}; expected 0`);
-    }
-    if (!run.command_line.trim()) {
-        errors.push(`${run.command_run_id} missing command_line`);
-    }
-    return errors;
-}
 function validateEvidenceAgainstSpec(state, evidence, spec, layerId) {
     if (!spec) {
         return [];
@@ -327,12 +309,23 @@ function recomputePlanStatuses(state, acStatuses) {
     }
     return statuses;
 }
+function planFindings(state, acStatuses, piStatuses) {
+    const findings = {};
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        const related = item.related_acs ?? [];
+        findings[planId] = related
+            .filter((acId) => acStatuses[acId] && acStatuses[acId] !== "complete" && acStatuses[acId] !== "out_of_scope_NA")
+            .map((acId) => `${acId} status=${acStatuses[acId]}`)
+            .concat(piStatuses[planId] ? [`${planId} status=${piStatuses[planId]}`] : []);
+    }
+    return findings;
+}
 function statusForGlobalErrors(errors, acStatuses) {
     const text = errors.join("\n");
     if (Object.values(acStatuses).includes("under_specified") || /under_specified/i.test(text)) {
         return "under_specified";
     }
-    if (/harness_drift|protected_baseline|source hash mismatch|missing current attempt|required_command_specs_hash|harness_task_missing/i.test(text)) {
+    if (/harness_drift|protected_baseline|source hash mismatch|missing current attempt|required_command_specs_hash|harness_task_missing|scope_conflict_requires_decision/i.test(text)) {
         return "blocked";
     }
     if (/stale|failed|invalid|contradiction|negative evidence|forbidden|bootstrap/i.test(text)) {
@@ -341,7 +334,10 @@ function statusForGlobalErrors(errors, acStatuses) {
     return "partial";
 }
 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 isStaleEvidenceError(errors) {
     return errors.some((error) => /stale evidence|source_bundle_hash mismatch|artifact_sha256 mismatch|artifact_mtime/i.test(error));

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

@@ -35,6 +35,7 @@ export async function runSuperpowersAssertion(workdir, options) {
         command_line: commandLine,
         exit_code: exitCode,
         started_at: startedAt,
+        completed_at: endedAt,
         ended_at: endedAt,
         artifact_paths: []
     };
@@ -81,11 +82,16 @@ export async function recordSuperpowersEvidence(workdir, options) {
         schema_version: "evidence-record-v2",
         evidence_id: `EV2-${compactDate(new Date().toISOString())}-${sha256(options.commandRunId + artifactText).slice(0, 8)}`,
         task_attempt_id: commandRun.task_attempt_id,
+        generated_at: new Date().toISOString(),
         source_bundle_hash: attempt?.source_bundle_hash ?? computeSourceBundleHash(state),
         product_source_hash: attempt?.product_source_hash ?? state.sources.product_architecture_source?.sha256 ?? "",
         technical_plan_hash: attempt?.technical_plan_hash ?? state.sources.technical_realization_plan?.sha256 ?? "",
         acceptance_checklist_hash: attempt?.acceptance_checklist_hash ?? state.sources.acceptance_checklist?.sha256 ?? "",
         git_head: attempt?.git_head ?? "",
+        git_status_short: attempt?.git_status_short ?? "",
+        tracked_diff_hash: attempt?.tracked_diff_hash ?? "",
+        relevant_untracked_hash: attempt?.relevant_untracked_hash ?? "",
+        covers_dirty_worktree: Boolean(attempt?.git_status_short?.trim()),
         worktree_fingerprint: attempt?.worktree_fingerprint ?? "",
         command_spec_id: commandRun.command_spec_id,
         command_run_id: commandRun.command_run_id,
@@ -99,7 +105,7 @@ export async function recordSuperpowersEvidence(workdir, options) {
         target_proof_layers: [layerId],
         slice_id: String(artifactRecord.slice_id ?? "attempt-evidence"),
         type: String(artifactRecord.type ?? `${commandRun.proof_layer}_assertion`),
-        freshness: { created_at: commandRun.ended_at, valid_for: "current_attempt", stale_after: null },
+        freshness: { created_at: commandRun.completed_at ?? commandRun.ended_at, valid_for: "current_attempt", stale_after: null },
         command: commandRun.command_line,
         artifact_paths: [relativeArtifactPath],
         proves: [layerId],

package/dist/lib/superpowers-task-final-card.d.ts

@@ -0,0 +1,3 @@
+import { type CompletionOutputContract } from "./superpowers-task-completion-output.js";
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function renderFinalCard(contract: CompletionOutputContract, state: SuperpowersTaskState): string;

package/dist/lib/superpowers-task-final-card.js

@@ -0,0 +1,24 @@
+export function renderFinalCard(contract, state) {
+    const reasons = contract.completion_output_status === "blocked" ? contract.blocked_reasons : contract.rejection_reasons;
+    const reasonBlock = reasons.length > 0 ? reasons.map((reason) => `- ${reason}`).join("\n") : "- none";
+    const gate = contract.completion_output_status === "accept" ? "Final answer: accept" : `Final answer: ${contract.completion_output_status}`;
+    const auditLine = contract.completion_output_status === "accept"
+        ? "Final-gate accepted the current attempt."
+        : "Audit workflow completed; acceptance target not complete.";
+    return `# Final Card
+
+completion_output_status: ${contract.completion_output_status}
+${gate}
+required_user_visible_status: ${contract.required_user_visible_status}
+final_answer_allowed: ${contract.final_answer_allowed}
+exit_code: ${contract.exit_code}
+product_goal_complete: ${contract.product_goal_complete}
+acceptance_target_status: ${contract.acceptance_target_status}
+audit_task_complete: ${state.final.audit_task_complete}
+
+${auditLine}
+
+Reasons:
+${reasonBlock}
+`;
+}

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

@@ -1,3 +1,4 @@
+import { type CompletionOutputContract } from "./superpowers-task-completion-output.js";
 export declare function runSliceGate(workdir: string, sliceId: string): Promise<{
     passed: boolean;
     messages: string[];
@@ -6,7 +7,6 @@ export declare function runEpochGate(workdir: string, epochId: string): Promise<
     passed: boolean;
     messages: string[];
 }>;
-export declare function runFinalGate(workdir: string): Promise<{
-    product_goal_complete: boolean;
+export declare function runFinalGate(workdir: string): Promise<CompletionOutputContract & {
     errors: string[];
 }>;

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, scanGeneratedCompletionOutputSurfaces } 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);
@@ -33,16 +35,20 @@ export async function runFinalGate(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
+    });
+    applyCompletionOutputContract(latest, contract);
     latest.final.completion_basis = complete
         ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
         : [];
@@ -51,31 +57,65 @@ 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
     };
     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 scanGeneratedCompletionOutputSurfaces(workdir, contract);
+    if (outputFindings.length > 0) {
+        errors = [...new Set([...errors, ...completionPhraseFindingMessages(outputFindings)])];
+        complete = false;
+        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
+        });
+        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
+        };
+        blockedLatest.final.false_completion_phrase_findings = outputFindings;
+        await saveSuperpowersState(workdir, blockedLatest);
+        await deriveSuperpowersArtifacts(workdir);
+    }
+    await appendSuperpowersEvent(workdir, "final_gate", {
+        product_goal_complete: contract.product_goal_complete,
+        completion_output_status: contract.completion_output_status
+    });
+    return { ...contract, errors };
 }
 function acceptanceStatusForErrors(errors, kernel) {
     const text = errors.join("\n");

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,7 @@ 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 interface SuperpowersTaskState {
     meta: {
         task_id: string;
@@ -87,6 +88,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 +118,15 @@ 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[];
         completion_basis: string[];
         next_required_actions?: string[];
     };
@@ -162,6 +173,7 @@ export interface CommandRunRecord {
     command_line: string;
     exit_code: number;
     started_at: string;
+    completed_at?: string;
     ended_at: string;
     artifact_paths: string[];
 }
@@ -336,11 +348,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[];
+}>;