project-tiny-context-harness 0.2.83 → 0.2.85

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

@@ -2,9 +2,12 @@ import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
 import { evaluateProofLayerAssertions } from "./superpowers-task-assertions.js";
+import { completionOutputContractFromState } from "./superpowers-task-completion-output.js";
+import { renderFinalCard } from "./superpowers-task-final-card.js";
 export async function deriveSuperpowersArtifacts(workdir) {
     const state = await loadSuperpowersState(workdir);
     const derived = deriveObjects(state);
+    const contract = completionOutputContractFromState(state);
     const derivedDir = path.join(workdir, "derived");
     await ensureDir(derivedDir);
     const files = [];
@@ -14,11 +17,12 @@ export async function deriveSuperpowersArtifacts(workdir) {
     await writeDerived(files, path.join(derivedDir, "evidence-index.json"), stableJson(deriveEvidenceIndex(state)));
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.md"), matrixMarkdown(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.md"), verdictMarkdown(derived.verdict));
-    await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state));
+    await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state, contract));
     await writeDerived(files, path.join(derivedDir, "progress-ledger.md"), progressMarkdown(derived.progress));
     await writeDerived(files, path.join(derivedDir, "evidence-index.md"), evidenceMarkdown(state));
     await writeDerived(files, path.join(derivedDir, "context-alignment.md"), contextMarkdown(state));
-    await writeDerived(files, path.join(derivedDir, "final-summary.md"), finalSummaryMarkdown(state, derived.verdict));
+    await writeDerived(files, path.join(derivedDir, "final-summary.md"), finalSummaryMarkdown(state, derived.verdict, contract));
+    await writeDerived(files, path.join(derivedDir, "final-card.md"), renderFinalCard(contract, state));
     return { matrix: derived.matrix, verdict: derived.verdict, files };
 }
 export function deriveObjects(state) {
@@ -140,9 +144,28 @@ export function deriveObjects(state) {
             .slice(0, 5)
             .map(([layerId]) => layerId)
     };
+    const contract = completionOutputContractFromState(state);
+    const completionMetadata = {
+        completion_output_status: contract.completion_output_status,
+        final_answer_allowed: contract.final_answer_allowed,
+        required_user_visible_status: contract.required_user_visible_status,
+        product_goal_complete: contract.product_goal_complete,
+        acceptance_target_status: contract.acceptance_target_status,
+        audit_task_complete: contract.audit_task_complete
+    };
     return {
-        matrix: { overall_status: allComplete ? "complete" : "partial", items: matrixRows },
-        verdict: { overall_status: allComplete ? "complete" : "partial", acceptance_items: verdictRows },
+        matrix: {
+            diagnostic_scope: "plan_conformance_rows_only",
+            overall_status: allComplete ? "complete" : "partial",
+            ...completionMetadata,
+            items: matrixRows
+        },
+        verdict: {
+            diagnostic_scope: "acceptance_evidence_rows_only",
+            overall_status: allComplete ? "complete" : "partial",
+            ...completionMetadata,
+            acceptance_items: verdictRows
+        },
         progress
     };
 }
@@ -289,12 +312,19 @@ missing_layer_count: ${missing}
 ${rows.map((row) => `- ${row.ac_id}: ${row.status}`).join("\n")}
 `;
 }
-function localAuditMarkdown(state) {
+function localAuditMarkdown(state, contract) {
+    const auditLine = contract.completion_output_status === "accept"
+        ? "Final-gate accepted the current attempt."
+        : "Audit workflow completed; acceptance target not complete.";
     return `# Local Audit
 
 audit_task_complete: ${state.final.audit_task_complete}
 acceptance_target_status: ${state.final.acceptance_target_status}
 product_goal_complete: ${state.final.product_goal_complete}
+completion_output_status: ${contract.completion_output_status}
+final_answer_allowed: ${contract.final_answer_allowed}
+
+${auditLine}
 `;
 }
 function progressMarkdown(progress) {
@@ -326,10 +356,38 @@ Product Context Delta: ${state.context.product_context_delta}
 Technical Context Delta: ${state.context.technical_context_delta}
 `;
 }
-function finalSummaryMarkdown(state, verdict) {
+function finalSummaryMarkdown(state, verdict, contract) {
+    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 triage = contract.blocker_triage;
+    const triageBlock = triage
+        ? `blocker_triage_category: ${triage.category}
+blocker_triage_self_recoverable: ${triage.self_recoverable}
+blocker_triage_recovery_attempted: ${triage.recovery_attempted}
+blocker_triage_next_action: ${triage.next_action}`
+        : `blocker_triage_category: none
+blocker_triage_self_recoverable: false
+blocker_triage_recovery_attempted: false
+blocker_triage_next_action: no blocker remains`;
+    const auditLine = contract.completion_output_status === "accept"
+        ? "Final-gate accepted the current attempt."
+        : "Audit workflow completed; acceptance target not complete.";
     return `# Final Summary
 
-overall_status: ${verdict.overall_status}
-product_goal_complete: ${state.final.product_goal_complete}
+diagnostic_overall_status: ${verdict.overall_status}
+product_goal_complete: ${contract.product_goal_complete}
+acceptance_target_status: ${contract.acceptance_target_status}
+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}
+${triageBlock}
+
+Final answer: ${contract.final_answer}
+
+${auditLine}
+
+Reasons:
+${reasonBlock}
 `;
 }

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

@@ -1,3 +1,4 @@
+import { type IgnoredUnregisteredEvidence } from "./superpowers-task-unregistered-evidence.js";
 import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
 export interface TrustedEvidenceKernelResult {
     product_goal_complete: boolean;
@@ -6,7 +7,13 @@ export interface TrustedEvidenceKernelResult {
     ac_statuses: Record<string, string>;
     pi_statuses: Record<string, string>;
     stale_evidence_ids: string[];
+    ignored_unregistered_evidence: IgnoredUnregisteredEvidence[];
+    invalidated_evidence_ids: string[];
+    kernel_order: string[];
+    ac_findings: Record<string, string[]>;
+    pi_findings: Record<string, string[]>;
     harness_task_final_verdict?: "passed" | "failed";
 }
+export declare const TRUSTED_EVIDENCE_KERNEL_ORDER: readonly ["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 declare function evaluateTrustedEvidenceKernel(workdir: string, providedState?: SuperpowersTaskState): Promise<TrustedEvidenceKernelResult>;
 export declare function applyTrustedEvidenceKernelResult(state: SuperpowersTaskState, result: TrustedEvidenceKernelResult): void;

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

@@ -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,35 @@
+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 triage = contract.blocker_triage;
+    const triageBlock = triage
+        ? `blocker_triage_category: ${triage.category}
+blocker_triage_self_recoverable: ${triage.self_recoverable}
+blocker_triage_recovery_attempted: ${triage.recovery_attempted}
+blocker_triage_next_action: ${triage.next_action}`
+        : `blocker_triage_category: none
+blocker_triage_self_recoverable: false
+blocker_triage_recovery_attempted: false
+blocker_triage_next_action: no blocker remains`;
+    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}
+${triageBlock}
+
+${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[];
 }>;