project-tiny-context-harness 0.2.82 → 0.2.84

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

@@ -1,8 +1,11 @@
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { deriveSuperpowersArtifacts } from "./superpowers-task-derive.js";
 import { validatePlanAcceptance } from "./plan-acceptance-validator.js";
-import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState } from "./superpowers-task-state.js";
-import { completionConditionErrors, validateSuperpowersState } from "./superpowers-task-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);
     const slice = state.slices.find((item) => item.slice_id === sliceId);
@@ -24,59 +27,105 @@ export async function runEpochGate(workdir, epochId) {
 }
 export async function runFinalGate(workdir) {
     const state = await loadSuperpowersState(workdir);
-    recomputeStatuses(state);
-    state.final.audit_task_complete = true;
-    state.meta.audit_task_complete = true;
-    state.gates.validator = { status: "not_run" };
+    const kernel = await evaluateTrustedEvidenceKernel(workdir, state);
+    applyTrustedEvidenceKernelResult(state, kernel);
+    state.gates.validator = { status: "not_run", kernel: "trusted_evidence_kernel" };
     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 completionErrors = completionConditionErrors(latest);
-    const errors = [...new Set([...report.errors, ...acceptanceReport.errors, ...completionErrors])];
-    const complete = errors.length === 0;
-    const acceptanceStatus = complete ? "complete" : acceptanceStatusForErrors(errors);
+    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
-        ? ["all_required_acs_complete", "validator_passed", "assertion_evidence_passed", "negative_evidence_scan_passed", "auditor_no_blocker"]
+        ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
         : [];
     latest.final.next_required_actions = nextRequiredActions;
     latest.gates.validator = { status: errors.length === 0 ? "pass" : "blocked", errors };
     latest.gates.final_gate = {
         status: complete ? "pass" : acceptanceStatus,
-        order: [
-            "derive",
-            "verification_before_completion_expected",
-            "validate_state",
-            "validate_derived",
-            "validate_plan_acceptance",
-            "auditor_blocker_scan",
-            "stale_overclaim_scope_scan",
-            "ac_evidence_assertion_gate",
-            "negative_evidence_scan_gate",
-            "compute_completion"
-        ],
+        kernel: "trusted_evidence_kernel",
+        order: kernel.kernel_order,
         errors,
-        next_required_actions: nextRequiredActions
+        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,
+        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) {
+function acceptanceStatusForErrors(errors, kernel) {
     const text = errors.join("\n");
-    if (/source hash mismatch|source_changed_requires_recompile|scope_conflict_requires_decision|auditor blocker|Context Delta coverage is unresolved/i.test(text)) {
+    if (kernel?.acceptance_target_status === "under_specified" || /under_specified/i.test(text)) {
+        return "under_specified";
+    }
+    if (/source hash mismatch|source_changed_requires_recompile|scope_conflict_requires_decision|auditor blocker|Context Delta coverage is unresolved|harness_drift|protected_baseline|harness_task_missing|required_command_specs_hash/i.test(text)) {
         return "blocked";
     }
-    if (/invalid evidence|forbidden shortcut|negative evidence|stale evidence|raw secret|contains_secret|sibling substitution|assertion_result\.status=failed|assertion exit_code=|command_exit_code=|forbidden text/i.test(text)) {
+    if (/invalid evidence|forbidden shortcut|negative evidence|stale evidence|raw secret|contains_secret|sibling substitution|assertion_result\.status=failed|assertion exit_code=|command_exit_code=|forbidden text|current contradiction|workflow_gate_bug_prevented|playwright_last_run_failed|owner_dom_forbidden_state|failed_test_result_artifact/i.test(text)) {
         return "invalidated";
     }
     return "partial";
@@ -95,6 +144,9 @@ function nextActionsForErrors(errors) {
         if (/negative evidence|forbidden/i.test(error)) {
             return `${error}; rerun the negative evidence scan and fix the contradictory owner-surface state`;
         }
+        if (/current contradiction|playwright_last_run_failed|owner_dom_forbidden_state|failed_test_result_artifact/i.test(error)) {
+            return `${error}; rerun the required current assertion command after fixing the current failure`;
+        }
         if (/derived\/.*does not match/i.test(error)) {
             return `${error}; rerun ty-context composite-long-task derive <workdir>`;
         }

package/dist/lib/superpowers-task-harness-drift.d.ts

@@ -0,0 +1,11 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface HarnessDriftResult {
+    harness_drift_detected: boolean;
+    acceptance_target_status: "complete" | "partial" | "blocked";
+    product_goal_complete: boolean;
+    harness_task_final_verdict?: "passed" | "failed";
+    changed_files: string[];
+    errors: string[];
+}
+export declare function detectHarnessDrift(state: SuperpowersTaskState): HarnessDriftResult;
+export declare function isHarnessPath(file: string): boolean;

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

@@ -0,0 +1,90 @@
+import { isRecord } from "./superpowers-task-state-schema.js";
+const HARNESS_PATH_PATTERNS = [
+    /(^|\/)tests\/.*\.(spec|test)\.[cm]?[jt]sx?$/i,
+    /(^|\/)playwright\.config\./i,
+    /(^|\/).*\.spec\.[cm]?[jt]sx?$/i,
+    /(^|\/).*\.test\.[cm]?[jt]sx?$/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,
+    /(^|\/)package\.json$/i
+];
+const REQUIRED_NEGATIVE_FIXTURES = [
+    "stale_evidence",
+    "historical_complete",
+    "derived_contradiction",
+    "ac010_summary_only",
+    "target_mismatch",
+    "api_only_for_ui",
+    "negative_evidence_after_pass",
+    "source_hash_mismatch",
+    "dirty_worktree_mismatch",
+    "missing_assertion_result",
+    "test_weakening"
+];
+export function detectHarnessDrift(state) {
+    const attempt = currentAttempt(state);
+    const changedFiles = changedFilesFor(attempt);
+    const harnessFiles = changedFiles.filter(isHarnessPath);
+    const mode = attempt?.mode ?? "product_task";
+    if (mode === "product_task" && harnessFiles.length > 0) {
+        return {
+            harness_drift_detected: true,
+            acceptance_target_status: "blocked",
+            product_goal_complete: false,
+            changed_files: harnessFiles,
+            errors: [
+                `harness_drift_detected: ${harnessFiles.join(", ")}`,
+                "本轮修改了验收工具链或测试本身，不能用被修改后的验收证明同一轮产品完成。请拆成独立 harness_task。"
+            ]
+        };
+    }
+    if (mode === "harness_task") {
+        return harnessTaskFixtureVerdict(state, changedFiles);
+    }
+    return { harness_drift_detected: false, acceptance_target_status: "complete", product_goal_complete: true, changed_files: [], errors: [] };
+}
+export function isHarnessPath(file) {
+    const normalized = file.replace(/\\/g, "/");
+    return HARNESS_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function harnessTaskFixtureVerdict(state, changedFiles) {
+    const fixtureState = isRecord(state.gates?.harness_task_fixtures) ? state.gates.harness_task_fixtures : undefined;
+    const errors = [];
+    if (!fixtureState) {
+        errors.push("harness_task_missing_adversarial_fixtures: harness_task must declare adversarial fixture outcomes");
+    }
+    else {
+        for (const fixture of REQUIRED_NEGATIVE_FIXTURES) {
+            if (fixtureState[fixture] !== false) {
+                errors.push(`harness_task_missing_adversarial_fixtures: ${fixture} must have expected product_goal_complete=false`);
+            }
+        }
+        if (fixtureState.happy_path !== true) {
+            errors.push("harness_task_missing_happy_path_fixture: happy_path must have expected product_goal_complete=true");
+        }
+    }
+    const fixtureChanges = changedFiles.filter((file) => /(^|\/)tests\/ty-context\/.*fixture/i.test(file.replace(/\\/g, "/")));
+    if (fixtureChanges.length > 0) {
+        errors.push(`fixture_changed_requires_review: ${fixtureChanges.join(", ")}`);
+    }
+    return {
+        harness_drift_detected: false,
+        acceptance_target_status: errors.length > 0 ? "blocked" : "complete",
+        product_goal_complete: false,
+        harness_task_final_verdict: errors.length > 0 ? "failed" : "passed",
+        changed_files: changedFiles,
+        errors
+    };
+}
+function currentAttempt(state) {
+    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.d.ts

@@ -0,0 +1,10 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface ProtectedBaselineResult {
+    protected_baseline_changed: boolean;
+    product_goal_complete: boolean;
+    changed_files: string[];
+    errors: string[];
+}
+export declare const PROTECTED_BASELINE_PATHS: string[];
+export declare function evaluateProtectedBaseline(state: SuperpowersTaskState): ProtectedBaselineResult;
+export declare function isProtectedBaselinePath(file: string): boolean;

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

@@ -0,0 +1,66 @@
+import { isHarnessPath } from "./superpowers-task-harness-drift.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+export const PROTECTED_BASELINE_PATHS = [
+    "packages/ty-context/assets/protected-harness-baseline.json",
+    ".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/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);
+    const changedFiles = [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];
+    const protectedChanges = changedFiles.filter(isProtectedBaselinePath);
+    const mode = attempt?.mode ?? "product_task";
+    const errors = [];
+    if (mode === "product_task" && protectedChanges.length > 0) {
+        errors.push(`protected_baseline_changed: product_task cannot change protected harness baseline paths: ${protectedChanges.join(", ")}`);
+    }
+    if (mode === "harness_task" && protectedChanges.length > 0 && !protectedBaselineReason(state)) {
+        errors.push("protected_baseline_reason_required: harness_task baseline changes must record gates.protected_baseline.reason");
+    }
+    return {
+        protected_baseline_changed: protectedChanges.length > 0,
+        product_goal_complete: errors.length === 0,
+        changed_files: protectedChanges,
+        errors
+    };
+}
+export function isProtectedBaselinePath(file) {
+    const normalized = file.replace(/\\/g, "/");
+    return PROTECTED_BASELINE_PATHS.includes(normalized) || isHarnessPath(normalized);
+}
+function protectedBaselineReason(state) {
+    const baseline = state.gates?.protected_baseline;
+    return isRecord(baseline) && typeof baseline.reason === "string" && baseline.reason.trim().length > 0;
+}
+function currentAttempt(state) {
+    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

@@ -4,7 +4,7 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
     readonly $id: "https://project-tiny-context-harness.local/superpowers-task-state.schema.json";
     readonly title: "Superpowers Long-Task State";
     readonly type: "object";
-    readonly required: readonly ["meta", "sources", "context", "delivery", "graph", "slices", "evidence", "gates", "progress", "blockers", "final"];
+    readonly required: readonly ["meta", "sources", "context", "delivery", "graph", "attempts", "current_attempt_id", "required_command_specs", "command_runs", "negative_evidence_records", "slices", "evidence", "gates", "progress", "blockers", "final"];
     readonly properties: {
         readonly meta: {
             readonly type: "object";
@@ -33,6 +33,21 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
         readonly graph: {
             readonly type: "object";
         };
+        readonly attempts: {
+            readonly type: "array";
+        };
+        readonly current_attempt_id: {
+            readonly type: "string";
+        };
+        readonly required_command_specs: {
+            readonly type: "array";
+        };
+        readonly command_runs: {
+            readonly type: "array";
+        };
+        readonly negative_evidence_records: {
+            readonly type: "array";
+        };
         readonly slices: {
             readonly type: "array";
         };
@@ -55,11 +70,13 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
 };
 export type SuperpowersProofLayerStatus = "missing" | "satisfied" | "invalidated" | "blocked";
 export type SuperpowersPlanItemStatus = "not_started" | "in_progress" | "complete" | "partial" | "blocked" | "invalidated" | "out_of_scope_NA";
-export type SuperpowersAcceptanceStatus = "not_run" | "complete" | "partial" | "blocked" | "invalidated" | "out_of_scope_NA";
+export type SuperpowersAcceptanceStatus = "not_run" | "complete" | "partial" | "blocked" | "invalidated" | "under_specified" | "out_of_scope_NA";
+export type SuperpowersAttemptMode = "product_task" | "harness_task";
 export type SuperpowersProductDeliveryScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "mixed_scope_requires_boundary";
 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;
@@ -71,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: {
@@ -86,6 +104,11 @@ export interface SuperpowersTaskState {
         proof_layers: Record<string, SuperpowersProofLayer>;
         edges: SuperpowersGraphEdge[];
     };
+    attempts: ExecutionAttempt[];
+    current_attempt_id: string;
+    required_command_specs: RequiredCommandSpec[];
+    command_runs: CommandRunRecord[];
+    negative_evidence_records: NegativeEvidenceRecord[];
     slices: SuperpowersSliceRecord[];
     evidence: SuperpowersEvidenceRecord[];
     gates: Record<string, unknown>;
@@ -95,10 +118,74 @@ 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[];
     };
 }
+export interface ExecutionAttempt {
+    task_attempt_id: 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;
+    untracked_relevant_hash?: string;
+    worktree_fingerprint: string;
+    started_at: string;
+    ended_at: string | null;
+    finalized_at?: string | null;
+    required_command_specs_hash: string;
+    mode: SuperpowersAttemptMode;
+    changed_files?: string[];
+}
+export interface RequiredCommandSpec {
+    command_spec_id: string;
+    ac_id: string;
+    proof_layers: string[];
+    command: string;
+    assertion_artifacts: string[];
+    required_test_ids: string[];
+    machine_blocking: boolean;
+    assertion_result_required: boolean;
+    positive_assertions: string[];
+    negative_assertions: string[];
+    invalid_completion_signals: string[];
+    final_evidence_expected: string[];
+}
+export interface CommandRunRecord {
+    command_run_id: string;
+    task_attempt_id: string;
+    command_spec_id: string;
+    ac_id: string;
+    proof_layer: string;
+    command_line: string;
+    exit_code: number;
+    started_at: string;
+    completed_at?: string;
+    ended_at: string;
+    artifact_paths: string[];
+}
+export interface NegativeEvidenceRecord {
+    negative_evidence_id: string;
+    task_attempt_id: string;
+    target_ac_ids: string[];
+    target_proof_layers: string[];
+    artifact_path: string;
+    artifact_sha256?: string;
+    status: "passed" | "failed" | "blocked" | "stale";
+}
 export interface SuperpowersSourceRecord {
     path: string;
     sha256: string;
@@ -258,7 +345,29 @@ export interface SuperpowersSliceRecord {
     };
 }
 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;
+    command_line?: string;
+    artifact_path?: string;
+    artifact_sha256?: string;
+    artifact_mtime?: string;
+    target_ac_ids?: string[];
+    target_pi_ids?: string[];
+    target_proof_layers?: string[];
     slice_id: string;
     type: string;
     freshness: {
@@ -285,17 +394,21 @@ export interface SuperpowersEvidenceRecord {
     sibling_substitution_approval_source?: string;
 }
 export interface AssertionResult {
-    schema_version: "assertion-result-v1";
+    schema_version: "assertion-result-v1" | "assertion-result-v2";
     status: "passed" | "failed" | "blocked" | "stale";
     runner: string;
     exit_code: number;
     target_ac_ids: string[];
+    target_pi_ids?: string[];
     target_proof_layers: string[];
     owner_surface?: string;
     route?: string;
     action?: string;
     positive_assertions: AssertionCheck[];
     negative_assertions: AssertionCheck[];
+    invalid_completion_signals?: AssertionCheck[];
+    negative_evidence_scan?: NegativeEvidenceScan;
+    required_test_ids?: string[];
     artifacts?: string[];
 }
 export interface AssertionCheck {

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

@@ -4,7 +4,24 @@ export const SUPERPOWERS_TASK_STATE_JSON_SCHEMA = {
     $id: "https://project-tiny-context-harness.local/superpowers-task-state.schema.json",
     title: "Superpowers Long-Task State",
     type: "object",
-    required: ["meta", "sources", "context", "delivery", "graph", "slices", "evidence", "gates", "progress", "blockers", "final"],
+    required: [
+        "meta",
+        "sources",
+        "context",
+        "delivery",
+        "graph",
+        "attempts",
+        "current_attempt_id",
+        "required_command_specs",
+        "command_runs",
+        "negative_evidence_records",
+        "slices",
+        "evidence",
+        "gates",
+        "progress",
+        "blockers",
+        "final"
+    ],
     properties: {
         meta: {
             type: "object",
@@ -19,6 +36,11 @@ export const SUPERPOWERS_TASK_STATE_JSON_SCHEMA = {
         context: { type: "object" },
         delivery: { type: "object" },
         graph: { type: "object" },
+        attempts: { type: "array" },
+        current_attempt_id: { type: "string" },
+        required_command_specs: { type: "array" },
+        command_runs: { type: "array" },
+        negative_evidence_records: { type: "array" },
         slices: { type: "array" },
         evidence: { type: "array" },
         gates: { type: "object" },

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

@@ -0,0 +1,3 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function validateShape(state: SuperpowersTaskState, errors: string[]): void;
+export declare function hasUsableShape(state: SuperpowersTaskState): boolean;

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

@@ -0,0 +1,50 @@
+import { isRecord } from "./superpowers-task-state-schema.js";
+export function validateShape(state, errors) {
+    if (state.meta?.schema_version !== "superpowers-task-state-v1") {
+        errors.push("task-state.json schema_version must be superpowers-task-state-v1");
+    }
+    for (const key of [
+        "meta",
+        "sources",
+        "context",
+        "delivery",
+        "graph",
+        "attempts",
+        "current_attempt_id",
+        "required_command_specs",
+        "command_runs",
+        "negative_evidence_records",
+        "slices",
+        "evidence",
+        "gates",
+        "progress",
+        "blockers",
+        "final"
+    ]) {
+        if (!(key in state)) {
+            errors.push(`task-state.json is missing section: ${key}`);
+        }
+    }
+}
+export function hasUsableShape(state) {
+    const candidate = state;
+    return (isRecord(candidate.meta) &&
+        isRecord(candidate.sources) &&
+        isRecord(candidate.context) &&
+        isRecord(candidate.delivery) &&
+        isRecord(candidate.graph) &&
+        isRecord(candidate.graph.plan_items) &&
+        isRecord(candidate.graph.acceptance_criteria) &&
+        isRecord(candidate.graph.proof_layers) &&
+        Array.isArray(candidate.attempts) &&
+        typeof candidate.current_attempt_id === "string" &&
+        Array.isArray(candidate.required_command_specs) &&
+        Array.isArray(candidate.command_runs) &&
+        Array.isArray(candidate.negative_evidence_records) &&
+        Array.isArray(candidate.slices) &&
+        Array.isArray(candidate.evidence) &&
+        isRecord(candidate.gates) &&
+        isRecord(candidate.progress) &&
+        Array.isArray(candidate.blockers) &&
+        isRecord(candidate.final));
+}