project-tiny-context-harness 0.2.82 → 0.2.83

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

@@ -1,8 +1,9 @@
 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 { applyTrustedEvidenceKernelResult, evaluateTrustedEvidenceKernel } from "./superpowers-task-evidence-kernel.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,19 +25,17 @@ 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);
+    const errors = [...new Set([...kernel.errors, ...report.errors, ...acceptanceReport.errors])];
+    const 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;
@@ -45,25 +44,32 @@ export async function runFinalGate(workdir) {
     latest.final.audit_task_complete = true;
     latest.meta.audit_task_complete = true;
     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,
+        kernel: "trusted_evidence_kernel",
         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"
+            "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"
         ],
         errors,
+        stale_evidence_ids: kernel.stale_evidence_ids,
+        harness_task_final_verdict: kernel.harness_task_final_verdict,
         next_required_actions: nextRequiredActions
     };
     await saveSuperpowersState(workdir, latest);
@@ -71,12 +77,15 @@ export async function runFinalGate(workdir) {
     await appendSuperpowersEvent(workdir, "final_gate", { product_goal_complete: complete });
     return { product_goal_complete: complete, 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 +104,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,86 @@
+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,
+    /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,
+    /(^|\/)(\.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) {
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+}
+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,47 @@
+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-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-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",
+    "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"
+];
+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) {
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+}

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,7 +70,8 @@ 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";
@@ -86,6 +102,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>;
@@ -99,6 +120,60 @@ export interface SuperpowersTaskState {
         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;
+    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 +333,24 @@ export interface SuperpowersSliceRecord {
     };
 }
 export interface SuperpowersEvidenceRecord {
+    schema_version?: "evidence-record-v1" | "evidence-record-v2" | string;
     evidence_id: string;
+    task_attempt_id?: string;
+    source_bundle_hash?: string;
+    product_source_hash?: string;
+    technical_plan_hash?: string;
+    acceptance_checklist_hash?: string;
+    git_head?: string;
+    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 +377,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));
+}

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { normalizeProofLayerId } from "./superpowers-task-fields.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
-import { evaluateProofLayerAssertions, isMachineVerifiableLayer, normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertions.js";
+import { evaluateProofLayerAssertions, isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { readEvidenceRecords } from "./superpowers-task-evidence-records.js";
 import { SUPERPOWERS_TASK_STATE_JSON_SCHEMA, SUPERPOWERS_TASK_STATE_SCHEMA_VERSION, asStringArray, isRecord } from "./superpowers-task-state-schema.js";
 const SOURCE_FILES = {
     product_architecture_source: {
@@ -73,6 +74,11 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             proof_layers: {},
             edges: []
         },
+        attempts: [],
+        current_attempt_id: "",
+        required_command_specs: [],
+        command_runs: [],
+        negative_evidence_records: [],
         slices: [],
         evidence: [],
         gates: {},
@@ -214,41 +220,6 @@ export function sha256(value) {
 export function stableJson(value) {
     return JSON.stringify(sortJson(value), null, 2);
 }
-function readEvidenceRecords(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isRecord).map((item) => ({
-        evidence_id: String(item.evidence_id ?? item.evidenceId ?? ""),
-        slice_id: String(item.slice_id ?? item.sliceId ?? ""),
-        type: String(item.type ?? ""),
-        freshness: isRecord(item.freshness)
-            ? {
-                created_at: String(item.freshness.created_at ?? ""),
-                valid_for: String(item.freshness.valid_for ?? ""),
-                stale_after: item.freshness.stale_after === null ? null : item.freshness.stale_after === undefined ? null : String(item.freshness.stale_after)
-            }
-            : { created_at: "", valid_for: "", stale_after: null },
-        command: item.command === undefined ? undefined : String(item.command),
-        command_exit_code: item.command_exit_code === undefined ? undefined : Number(item.command_exit_code),
-        artifact_paths: asStringArray(item.artifact_paths),
-        proves: asStringArray(item.proves).map(normalizeProofLayerId),
-        does_not_prove: asStringArray(item.does_not_prove).map((value) => (value.includes(".") ? normalizeProofLayerId(value) : value)),
-        redaction: isRecord(item.redaction)
-            ? { checked: item.redaction.checked === true, contains_secret: item.redaction.contains_secret === true }
-            : { checked: false, contains_secret: false },
-        reviewability: isRecord(item.reviewability)
-            ? {
-                external_reviewer_can_reproduce: item.reviewability.external_reviewer_can_reproduce === true,
-                reproduction_steps: String(item.reviewability.reproduction_steps ?? "")
-            }
-            : { external_reviewer_can_reproduce: false, reproduction_steps: "" },
-        assertion_result: normalizeAssertionResult(item.assertion_result),
-        negative_evidence_scan: normalizeNegativeEvidenceScan(item.negative_evidence_scan),
-        sibling_substitution_used: item.sibling_substitution_used === true,
-        sibling_substitution_approval_source: item.sibling_substitution_approval_source === undefined ? undefined : String(item.sibling_substitution_approval_source)
-    }));
-}
 function sortJson(value) {
     if (Array.isArray(value)) {
         return value.map(sortJson);

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

@@ -1,5 +1,15 @@
 const CANONICAL_PLAN_STATUSES = new Set(["not_started", "in_progress", "partial", "blocked", "invalidated", "complete", "out_of_scope_NA"]);
-const CANONICAL_AC_STATUSES = new Set(["not_started", "not_run", "in_progress", "partial", "blocked", "invalidated", "complete", "out_of_scope_NA"]);
+const CANONICAL_AC_STATUSES = new Set([
+    "not_started",
+    "not_run",
+    "in_progress",
+    "partial",
+    "blocked",
+    "invalidated",
+    "under_specified",
+    "complete",
+    "out_of_scope_NA"
+]);
 export function validateCanonicalStatuses(state, errors) {
     for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
         if (!CANONICAL_PLAN_STATUSES.has(item.status)) {

package/dist/lib/superpowers-task-under-specified.d.ts

@@ -0,0 +1,7 @@
+import type { SuperpowersAcceptanceCriterion, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface UnderSpecifiedAc {
+    ac_id: string;
+    reasons: string[];
+}
+export declare function findUnderSpecifiedAcs(state: SuperpowersTaskState): UnderSpecifiedAc[];
+export declare function underSpecifiedReasons(acId: string, ac: SuperpowersAcceptanceCriterion): string[];