project-tiny-context-harness 0.2.79 → 0.2.81

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

@@ -1,7 +1,8 @@
 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 { allCompletionConditionsSatisfied, validateSuperpowersState } from "./superpowers-task-validator.js";
+import { completionConditionErrors, 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);
@@ -30,18 +31,73 @@ export async function runFinalGate(workdir) {
     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 complete = report.errors.length === 0 && allCompletionConditionsSatisfied(latest);
+    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 nextRequiredActions = complete ? [] : nextActionsForErrors(errors);
     latest.final.product_goal_complete = complete;
     latest.meta.product_goal_complete = complete;
-    latest.final.acceptance_target_status = complete ? "complete" : "partial";
+    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;
-    latest.final.completion_basis = complete ? ["all_required_acs_complete", "validator_passed", "auditor_no_blocker"] : [];
-    latest.gates.validator = { status: report.errors.length === 0 ? "pass" : "blocked", errors: report.errors };
+    latest.final.completion_basis = complete
+        ? ["all_required_acs_complete", "validator_passed", "assertion_evidence_passed", "negative_evidence_scan_passed", "auditor_no_blocker"]
+        : [];
+    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"
+        ],
+        errors,
+        next_required_actions: nextRequiredActions
+    };
     await saveSuperpowersState(workdir, latest);
     await deriveSuperpowersArtifacts(workdir);
     await appendSuperpowersEvent(workdir, "final_gate", { product_goal_complete: complete });
-    return { product_goal_complete: complete, errors: report.errors };
+    return { product_goal_complete: complete, errors };
+}
+function acceptanceStatusForErrors(errors) {
+    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)) {
+        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)) {
+        return "invalidated";
+    }
+    return "partial";
+}
+function nextActionsForErrors(errors) {
+    return errors.slice(0, 12).map((error) => {
+        if (/source hash mismatch/i.test(error)) {
+            return `${error}; rerun ty-context composite-long-task compile <workdir> after approving source changes`;
+        }
+        if (/scope_conflict_requires_decision/i.test(error)) {
+            return `${error}; clarify Product / Plan / Checklist delivery scope before more implementation`;
+        }
+        if (/missing assertion result|not machine-backed/i.test(error)) {
+            return `${error}; add assertion_result evidence for the target AC/proof layer`;
+        }
+        if (/negative evidence|forbidden/i.test(error)) {
+            return `${error}; rerun the negative evidence scan and fix the contradictory owner-surface state`;
+        }
+        if (/derived\/.*does not match/i.test(error)) {
+            return `${error}; rerun ty-context composite-long-task derive <workdir>`;
+        }
+        return error;
+    });
 }

package/dist/lib/superpowers-task-source-compile.js

@@ -1,3 +1,5 @@
+import { MACHINE_VERIFIABLE_PROOF_LAYERS, proofLayerName } from "./superpowers-task-assertions.js";
+import { compileReportSuffix, missingCategory, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
 import { fieldArray, fieldBoolean, fieldLine, fieldText, parseDocumentFields, parseHeadingDefinitions } from "./superpowers-task-source-parser.js";
 export const DEFAULT_LAYERS = ["code", "test"];
 const PRODUCT_DELIVERY_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "mixed_scope_requires_boundary"]);
@@ -8,7 +10,15 @@ const PRODUCT_FIELDS = new Set([
     "full_population_required",
     "representative_samples_validate",
     "representative_samples_do_not_validate",
-    "out_of_scope_backlog"
+    "out_of_scope_backlog",
+    "source_authority",
+    "product_goal",
+    "surface_ia_lock",
+    "decision_lock",
+    "context_delta",
+    "source_to_context_coverage",
+    "acceptance_semantics",
+    "impact"
 ]);
 const PLAN_FIELDS = new Set([
     "delivery_scope",
@@ -20,16 +30,50 @@ const PLAN_FIELDS = new Set([
     "forbidden_surfaces",
     "implementation_paths",
     "required_tests",
-    "related_acs"
+    "related_acs",
+    "requirement_ref",
+    "decision_id",
+    "proof_layer_ids",
+    "api_schema_changes",
+    "state_machine",
+    "data_flow",
+    "worker_runtime_behavior",
+    "ui_ia_changes",
+    "migration_plan",
+    "evidence_artifacts",
+    "explicit_no_test_scope",
+    "non_completing_shortcuts",
+    "substitution_policy",
+    "drift_severity",
+    "partial_conditions",
+    "blockers",
+    "context_fact_refs"
 ]);
 const ACCEPTANCE_FIELDS = new Set([
+    "checklist_source",
     "acceptance_scope",
     "ac_validates",
     "ac_does_not_validate",
     "sample_boundary",
     "full_population_required",
     "related_plan_items",
-    "required_proof_layers"
+    "required_proof_layers",
+    "ac_type",
+    "proof_chain",
+    "verification_method",
+    "fail_conditions",
+    "invalid_evidence",
+    "substitution_policy",
+    "missing_layer_downgrade",
+    "auditor_expectation",
+    "out_of_scope_na_approval_source",
+    "required_test_ids",
+    "explicit_no_test_scope",
+    "hard_blockers",
+    "validates_explanation",
+    "does_not_validate_explanation",
+    "final_evidence_expected",
+    "test_cases"
 ]);
 export function parseProductArchitectureScope(content, sourceFile) {
     const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELDS);
@@ -63,6 +107,11 @@ export function parsePlanItems(content, sourceFile) {
             forbidden_surfaces: optionalArray(fields, "forbidden_surfaces"),
             implementation_paths: optionalArray(fields, "implementation_paths"),
             required_tests: optionalArray(fields, "required_tests"),
+            proof_layer_ids: optionalArray(fields, "proof_layer_ids").map(normalizeLayer),
+            non_completing_shortcuts: optionalArray(fields, "non_completing_shortcuts"),
+            substitution_policy: optionalArray(fields, "substitution_policy"),
+            explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
+            context_fact_refs: optionalArray(fields, "context_fact_refs"),
             status: "not_started",
             related_acs: optionalArray(fields, "related_acs").map((item) => item.toUpperCase()),
             required_proof_layers: []
@@ -77,6 +126,7 @@ export function parseAcceptanceCriteria(content, sourceFile) {
     for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELDS })) {
         const fields = definition.fields;
         const layers = optionalArray(fields, "required_proof_layers").map(normalizeLayer).filter(Boolean);
+        const requiredProofLayers = layers.length > 0 ? layers : DEFAULT_LAYERS;
         items[definition.id] = {
             scope: definition.title,
             source_file: definition.source_file,
@@ -88,7 +138,13 @@ export function parseAcceptanceCriteria(content, sourceFile) {
             sample_boundary: requireText(errors, definition.id, "sample_boundary", fields, sourceFile, definition.source_start_line),
             full_population_required: requireBoolean(errors, definition.id, "full_population_required", fields, sourceFile, definition.source_start_line),
             related_plan_items: optionalArray(fields, "related_plan_items").map((item) => item.toUpperCase()),
-            required_proof_layers: layers.length > 0 ? layers : DEFAULT_LAYERS,
+            required_proof_layers: requiredProofLayers,
+            assertion_requirements: assertionRequirements(fields, requiredProofLayers),
+            required_test_ids: optionalArray(fields, "required_test_ids"),
+            fail_conditions: optionalArray(fields, "fail_conditions"),
+            invalid_evidence: optionalArray(fields, "invalid_evidence"),
+            final_evidence_expected: optionalArray(fields, "final_evidence_expected"),
+            explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
             status: "not_run"
         };
     }
@@ -98,15 +154,41 @@ export function parseAcceptanceCriteria(content, sourceFile) {
 function normalizeLayer(value) {
     return value.trim().toLowerCase().replace(/[- ]+/g, "_");
 }
+function assertionRequirements(fields, layers) {
+    const requiredTestIds = optionalArray(fields, "required_test_ids");
+    const positiveAssertions = unique([
+        ...fieldArray(fields, "ac_validates"),
+        ...requiredTestIds,
+        ...optionalArray(fields, "test_cases"),
+        ...optionalArray(fields, "verification_method"),
+        ...optionalArray(fields, "final_evidence_expected")
+    ]);
+    const negativeAssertions = unique([
+        ...fieldArray(fields, "ac_does_not_validate"),
+        ...optionalArray(fields, "fail_conditions"),
+        ...optionalArray(fields, "invalid_evidence")
+    ]);
+    return layers.map((layer) => {
+        const normalized = proofLayerName(normalizeLayer(layer));
+        return {
+            proof_layer: normalized,
+            required: true,
+            machine_blocking: MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            required_test_ids: requiredTestIds,
+            positive_assertions: positiveAssertions,
+            negative_assertions: negativeAssertions
+        };
+    });
+}
 function requireEnum(errors, label, name, fields, allowed, sourceFile, fallbackLine) {
     const value = fieldText(fields, name);
     const line = fieldLine(fields, name) ?? fallbackLine;
     if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the required field and rerun compile")}`);
         return "";
     }
     if (!allowed.has(value)) {
-        errors.push(`${label} invalid ${name}: ${value} at ${sourceFile}:${line}; allowed: ${[...allowed].join(", ")}`);
+        errors.push(`${label} invalid ${name}: ${value} at ${sourceFile}:${line}; allowed: ${[...allowed].join(", ")}${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, `value must be one of ${[...allowed].join(", ")}`, "fix the field value and rerun compile")}`);
     }
     return value;
 }
@@ -114,14 +196,14 @@ function requireText(errors, label, name, fields, sourceFile, fallbackLine) {
     const value = fieldText(fields, name);
     const line = fieldLine(fields, name) ?? fallbackLine;
     if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add non-empty text and rerun compile")}`);
     }
     return value;
 }
 function requireArray(errors, label, name, fields, sourceFile, fallbackLine) {
     const line = fieldLine(fields, name) ?? fallbackLine;
     if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the list field and rerun compile")}`);
         return [];
     }
     return fieldArray(fields, name);
@@ -129,20 +211,18 @@ function requireArray(errors, label, name, fields, sourceFile, fallbackLine) {
 function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
     const line = fieldLine(fields, name) ?? fallbackLine;
     if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add true or false and rerun compile")}`);
         return null;
     }
     const value = fieldBoolean(fields, name);
     if (value === null) {
-        errors.push(`${label} invalid ${name}: ${fieldText(fields, name)} at ${sourceFile}:${line}; must be true or false`);
+        errors.push(`${label} invalid ${name}: ${fieldText(fields, name)} at ${sourceFile}:${line}; must be true or false${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, "value must be true or false", "fix the boolean and rerun compile")}`);
     }
     return value;
 }
 function optionalArray(fields, name) {
     return fields[name] ? fieldArray(fields, name) : [];
 }
-function throwCompileErrors(errors) {
-    if (errors.length > 0) {
-        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
-    }
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
 }

package/dist/lib/superpowers-task-source-parser.js

@@ -1,3 +1,4 @@
+import { compileError, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
 export function parseHeadingDefinitions(content, options) {
     const lines = splitLines(content);
     const errors = [];
@@ -8,7 +9,7 @@ export function parseHeadingDefinitions(content, options) {
     for (const heading of headings) {
         const firstLine = seen.get(heading.id);
         if (firstLine !== undefined) {
-            errors.push(`${heading.id} duplicate definition at ${options.sourceFile}:${firstLine} and ${options.sourceFile}:${heading.line}`);
+            errors.push(compileError(`${heading.id} duplicate definition at ${options.sourceFile}:${firstLine} and ${options.sourceFile}:${heading.line}`, "blocking_unparseable_object", options.sourceFile, heading.line, heading.id, "duplicate object ids make PI/AC graph references ambiguous", "keep exactly one heading definition for this id"));
             continue;
         }
         seen.set(heading.id, heading.line);
@@ -24,15 +25,15 @@ export function parseHeadingDefinitions(content, options) {
         });
     }
     if (definitions.length === 0) {
-        errors.push(`${options.sourceFile} must define ${options.kind} items with Markdown headings like "## ${options.kind}-001: ..."`);
+        errors.push(compileError(`${options.sourceFile} must define ${options.kind} items with Markdown headings like "## ${options.kind}-001: ..."`, options.kind === "PI" ? "blocking_missing_plan" : "blocking_missing_checklist", options.sourceFile, 1, `${options.kind}_heading`, "the source cannot compile without at least one object heading", `add headings like ## ${options.kind}-001: ...`));
     }
-    throwIfErrors(errors);
+    throwCompileErrors(errors);
     return definitions;
 }
 export function parseDocumentFields(content, sourceFile, allowedFields) {
     const errors = [];
     const fields = parseFields(splitLines(content), sourceFile, 1, allowedFields, errors);
-    throwIfErrors(errors);
+    throwCompileErrors(errors);
     return fields;
 }
 export function fieldText(fields, name) {
@@ -72,11 +73,11 @@ function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
         const lineNumber = startLine + index;
         const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
         if (heading && allowedFields.has(heading[2].trim())) {
-            errors.push(`${sourceFile}:${lineNumber} field headings are not supported; use "${heading[2].trim()}: ..."`);
+            errors.push(compileError(`${sourceFile}:${lineNumber} field headings are not supported; use "${heading[2].trim()}: ..."`, "blocking_unparseable_object", sourceFile, lineNumber, heading[2].trim(), "field heading syntax is ambiguous in compiled source", "use key: value fields"));
             continue;
         }
         if (/^\s*\|/.test(line) && containsKnownField(line, allowedFields)) {
-            errors.push(`${sourceFile}:${lineNumber} table fields are not supported; use key: value fields`);
+            errors.push(compileError(`${sourceFile}:${lineNumber} table fields are not supported; use key: value fields`, "blocking_unparseable_object", sourceFile, lineNumber, "table_field", "table fields cannot be parsed into canonical state safely", "use key: value fields"));
             continue;
         }
         const match = /^([a-z][a-z0-9_]*)\s*:\s*(.*)$/.exec(line);
@@ -86,12 +87,12 @@ function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
         const name = match[1];
         if (!allowedFields.has(name)) {
             if (name.includes("_")) {
-                errors.push(`${sourceFile}:${lineNumber} unknown field ${name}`);
+                errors.push(compileError(`${sourceFile}:${lineNumber} unknown field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "unknown fields may hide required source semantics", "rename the field to a supported canonical key"));
             }
             continue;
         }
         if (fields[name]) {
-            errors.push(`${sourceFile}:${lineNumber} duplicate field ${name}`);
+            errors.push(compileError(`${sourceFile}:${lineNumber} duplicate field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "duplicate fields make canonical source values ambiguous", "keep one field value"));
             continue;
         }
         const parsed = parseFieldValue(lines, index, match[2], sourceFile, lineNumber, errors);
@@ -107,13 +108,13 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
         let cursor = index + 1;
         for (; cursor < lines.length; cursor++) {
             const next = lines[cursor];
-            if (next.trim() && !/^\s/.test(next)) {
+            if (next.trim() && isTopLevelFieldOrHeading(next)) {
                 break;
             }
             block.push(next.replace(/^\s{0,2}/, ""));
         }
         if (block.length === 0) {
-            errors.push(`${sourceFile}:${lineNumber} block field must include indented text`);
+            errors.push(compileError(`${sourceFile}:${lineNumber} block field must include indented text`, "blocking_unparseable_object", sourceFile, lineNumber, "block_field", "empty block field cannot prove source intent", "add indented text or remove the field"));
         }
         return { value: block.join("\n").trim(), endIndex: cursor - 1 };
     }
@@ -127,18 +128,24 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
         if (!next.trim()) {
             continue;
         }
-        if (!/^\s/.test(next)) {
+        if (isTopLevelFieldOrHeading(next)) {
             break;
         }
         const listItem = /^\s*[-*+]\s+(.+?)\s*$/.exec(next);
         if (!listItem) {
-            errors.push(`${sourceFile}:${cursor + 1} field lists must use indented "- item" entries or key: | blocks`);
+            errors.push(compileError(`${sourceFile}:${cursor + 1} field lists must use indented "- item" entries or key: | blocks`, "blocking_unparseable_object", sourceFile, cursor + 1, "list_field", "list syntax cannot be parsed into canonical arrays", "use indented '- item' entries or key: | blocks"));
             continue;
         }
         values.push(cleanValue(listItem[1]));
     }
     return { value: values, endIndex: cursor - 1 };
 }
+function isTopLevelFieldOrHeading(line) {
+    if (/^(#{1,6})\s+/.test(line)) {
+        return true;
+    }
+    return /^([a-z][a-z0-9_]*)\s*:/.test(line);
+}
 function rejectListStyleDefinitions(lines, options, errors) {
     const idPattern = options.kind === "PI" ? "PI" : "AC";
     const listPattern = new RegExp(`^\\s*[-*+]\\s+(${idPattern}-\\d{3,})\\b\\s*[:.-]?`, "i");
@@ -152,7 +159,7 @@ function rejectListStyleDefinitions(lines, options, errors) {
             continue;
         }
         const id = match[1].toUpperCase();
-        errors.push(`${id} list-style definition is not allowed at ${options.sourceFile}:${index + 1}; use "## ${id}: ..."`);
+        errors.push(compileError(`${id} list-style definition is not allowed at ${options.sourceFile}:${index + 1}; use "## ${id}: ..."`, "blocking_unparseable_object", options.sourceFile, index + 1, id, "list-style object definitions are not canonical PI/AC headings", `use "## ${id}: ..."`));
     }
 }
 function listItemBlock(lines, start) {
@@ -211,8 +218,3 @@ function splitLines(content) {
 function cleanValue(value) {
     return value.replace(/^[-#*\s]+/, "").trim();
 }
-function throwIfErrors(errors) {
-    if (errors.length > 0) {
-        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
-    }
-}

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

@@ -54,7 +54,7 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
     };
 };
 export type SuperpowersProofLayerStatus = "missing" | "satisfied" | "invalidated" | "blocked";
-export type SuperpowersPlanItemStatus = "not_started" | "complete" | "partial" | "sampled_only" | "not_implemented" | "blocked" | "scope_changed_requires_user_approval" | "contradicted_by_current_state" | "out_of_scope_NA";
+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 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";
@@ -95,6 +95,7 @@ export interface SuperpowersTaskState {
         acceptance_target_status: string;
         audit_task_complete: boolean;
         completion_basis: string[];
+        next_required_actions?: string[];
     };
 }
 export interface SuperpowersSourceRecord {
@@ -134,6 +135,11 @@ export interface SuperpowersPlanItem {
     forbidden_surfaces: string[];
     implementation_paths: string[];
     required_tests: string[];
+    proof_layer_ids?: string[];
+    non_completing_shortcuts?: string[];
+    substitution_policy?: string[];
+    explicit_no_test_scope?: boolean;
+    context_fact_refs?: string[];
     status: SuperpowersPlanItemStatus;
     related_acs: string[];
     required_proof_layers: string[];
@@ -150,8 +156,22 @@ export interface SuperpowersAcceptanceCriterion {
     full_population_required: boolean | null;
     related_plan_items: string[];
     required_proof_layers: string[];
+    assertion_requirements?: AssertionRequirement[];
+    required_test_ids?: string[];
+    fail_conditions?: string[];
+    invalid_evidence?: string[];
+    final_evidence_expected?: string[];
+    explicit_no_test_scope?: boolean;
     status: SuperpowersAcceptanceStatus;
 }
+export interface AssertionRequirement {
+    proof_layer: string;
+    required: boolean;
+    machine_blocking: boolean;
+    required_test_ids: string[];
+    positive_assertions: string[];
+    negative_assertions: string[];
+}
 export interface SuperpowersProofLayer {
     required: boolean;
     status: SuperpowersProofLayerStatus;
@@ -190,6 +210,7 @@ export interface SuperpowersEvidenceRecord {
         stale_after: string | null;
     };
     command?: string;
+    command_exit_code?: number;
     artifact_paths: string[];
     proves: string[];
     does_not_prove: string[];
@@ -201,8 +222,47 @@ export interface SuperpowersEvidenceRecord {
         external_reviewer_can_reproduce: boolean;
         reproduction_steps: string;
     };
+    assertion_result?: AssertionResult;
+    negative_evidence_scan?: NegativeEvidenceScan;
     sibling_substitution_used?: boolean;
     sibling_substitution_approval_source?: string;
 }
+export interface AssertionResult {
+    schema_version: "assertion-result-v1";
+    status: "passed" | "failed" | "blocked" | "stale";
+    runner: string;
+    exit_code: number;
+    target_ac_ids: string[];
+    target_proof_layers: string[];
+    owner_surface?: string;
+    route?: string;
+    action?: string;
+    positive_assertions: AssertionCheck[];
+    negative_assertions: AssertionCheck[];
+    artifacts?: string[];
+}
+export interface AssertionCheck {
+    id: string;
+    status: "passed" | "failed" | "blocked" | "stale";
+    actual?: string;
+    expected?: string;
+    forbidden_text?: string;
+}
+export interface NegativeEvidenceScan {
+    schema_version: "negative-evidence-scan-v1";
+    status: "passed" | "failed" | "blocked" | "stale";
+    target_ac_ids: string[];
+    owner_surface?: string;
+    route?: string;
+    forbidden_findings: NegativeFinding[];
+    required_findings: AssertionCheck[];
+    artifacts: string[];
+}
+export interface NegativeFinding {
+    id: string;
+    status: "found" | "not_found";
+    forbidden_text?: string;
+    actual?: string;
+}
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function asStringArray(value: unknown): string[];

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { evaluateProofLayerAssertions, isMachineVerifiableLayer, normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertions.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: {
@@ -17,6 +18,7 @@ const SOURCE_FILES = {
         authority: "acs_completion_semantics_proof_layers"
     }
 };
+const SLICE_PROGRESS_TYPES = new Set(["functional_gap_closed", "proof_gap_closed", "blocker_resolved", "invalid_evidence_removed"]);
 export async function initializeSuperpowersTask(workdir, options = {}) {
     await ensureDir(path.join(workdir, "derived"));
     await writeTextIfChanged(path.join(workdir, "task-state.schema.json"), `${stableJson(SUPERPOWERS_TASK_STATE_JSON_SCHEMA)}\n`);
@@ -71,7 +73,8 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             product_goal_complete: false,
             acceptance_target_status: "not_run",
             audit_task_complete: false,
-            completion_basis: []
+            completion_basis: [],
+            next_required_actions: []
         }
     };
     await saveSuperpowersState(workdir, state);
@@ -96,6 +99,10 @@ export async function applySliceDelta(workdir, deltaFile) {
     if (!progressValue || !String(progressValue.type ?? "").trim() || asStringArray(progressValue.closed_items).length === 0) {
         throw new Error("slice_delta must include progress_value with type and closed_items");
     }
+    const progressType = String(progressValue.type);
+    if (!SLICE_PROGRESS_TYPES.has(progressType)) {
+        throw new Error(`slice_delta progress_value.type must be one of ${[...SLICE_PROGRESS_TYPES].join(", ")}; got ${progressType || "(missing)"}`);
+    }
     const evidenceRecords = readEvidenceRecords(delta.evidence_records);
     for (const evidence of evidenceRecords) {
         const existingIndex = state.evidence.findIndex((item) => item.evidence_id === evidence.evidence_id);
@@ -119,7 +126,7 @@ export async function applySliceDelta(workdir, deltaFile) {
         blockers: Array.isArray(delta.blockers) ? delta.blockers : [],
         cleanup_assertions: asStringArray(delta.cleanup_assertions),
         progress_value: {
-            type: String(progressValue.type),
+            type: progressType,
             closed_items: asStringArray(progressValue.closed_items),
             why_it_reduces_rework: String(progressValue.why_it_reduces_rework ?? "")
         }
@@ -147,7 +154,7 @@ export function recomputeStatuses(state) {
         if (layerIds.length === 0) {
             ac.status = "not_run";
         }
-        else if (layerIds.every((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied")) {
+        else if (layerIds.every((layerId) => layerSatisfiedForCompletion(state, layerId))) {
             ac.status = "complete";
         }
         else if (layerIds.some((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied")) {
@@ -169,6 +176,12 @@ export function recomputeStatuses(state) {
         }
     }
 }
+function layerSatisfiedForCompletion(state, layerId) {
+    if (state.graph.proof_layers[layerId]?.status !== "satisfied") {
+        return false;
+    }
+    return !isMachineVerifiableLayer(layerId) || evaluateProofLayerAssertions(state, layerId).assertion_status === "passed";
+}
 export function emptyProgressState() {
     return {
         system_capability_progress: { status: "not_started" },
@@ -208,6 +221,7 @@ function readEvidenceRecords(value) {
             }
             : { 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),
         does_not_prove: asStringArray(item.does_not_prove),
@@ -220,6 +234,8 @@ function readEvidenceRecords(value) {
                 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)
     }));

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

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

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

@@ -0,0 +1,14 @@
+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"]);
+export function validateCanonicalStatuses(state, errors) {
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        if (!CANONICAL_PLAN_STATUSES.has(item.status)) {
+            errors.push(`plan item ${planId} has non-canonical status: ${item.status}`);
+        }
+    }
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        if (!CANONICAL_AC_STATUSES.has(ac.status)) {
+            errors.push(`AC ${acId} has non-canonical status: ${ac.status}`);
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
 import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
 import type { ValidatorReport } from "./validators.js";
 export declare function validateSuperpowersState(projectRoot: string, args?: string[]): Promise<ValidatorReport>;
+export declare function completionConditionErrors(state: SuperpowersTaskState): string[];
 export declare function allCompletionConditionsSatisfied(state: SuperpowersTaskState): boolean;