project-tiny-context-harness 0.2.80 → 0.2.81

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

@@ -1,5 +1,6 @@
 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";
 export async function runSliceGate(workdir, sliceId) {
@@ -30,20 +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 completionErrors = completionConditionErrors(latest);
-    const errors = [...new Set([...report.errors, ...completionErrors])];
+    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.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 };
 }
+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"]);
@@ -105,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: []
@@ -119,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,
@@ -130,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"
         };
     }
@@ -140,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;
 }
@@ -156,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);
@@ -171,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);
@@ -113,7 +114,7 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
             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 };
     }
@@ -132,7 +133,7 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
         }
         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]));
@@ -158,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) {
@@ -217,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.js

@@ -3,9 +3,12 @@ import { pathExists, readText } from "./fs.js";
 import { findSensitiveEvidence } from "./plan-acceptance-evidence.js";
 import { primitiveText, repoRelative, resolveInputDir } from "./plan-validator-common.js";
 import { derivedMatchesState } from "./superpowers-task-derive.js";
+import { validatePlanCompletionConformance } from "./superpowers-task-conformance.js";
 import { fullPopulationRequired, validateDeliveryContract, validateScopeConflicts } from "./superpowers-task-delivery.js";
 import { loadSuperpowersState, sha256 } from "./superpowers-task-state.js";
+import { validateCanonicalStatuses } from "./superpowers-task-status.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
+import { evaluateProofLayerAssertions, isUiBrowserLayer } from "./superpowers-task-assertions.js";
 export async function validateSuperpowersState(projectRoot, args = []) {
     const info = [];
     const warnings = [];
@@ -35,7 +38,9 @@ export async function validateSuperpowersState(projectRoot, args = []) {
     }
     await validateSourceHashes(targetDir, state, errors);
     validateDeliveryContract(state, errors);
+    validateCanonicalStatuses(state, errors);
     validateGraphReferences(state, errors);
+    validatePlanCompletionConformance(state, errors);
     validateScopeConflicts(state, errors);
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
@@ -163,7 +168,7 @@ function validateEvidenceRecords(state, errors) {
             if (proofLayer.endsWith(".runtime") && /\b(mock|unit|viewmodel)\b/i.test(evidence.type)) {
                 errors.push(`${label} runtime proof cannot be mock/unit/viewmodel only`);
             }
-            if (proofLayer.endsWith(".ui_browser") && !/\b(browser|ui_browser|screenshot)\b/i.test(evidence.type)) {
+            if (proofLayer.endsWith(".ui_browser") && !/(browser|ui_browser|screenshot|playwright)/i.test(evidence.type)) {
                 errors.push(`${label} UI proof must use browser owner surface evidence`);
             }
         }
@@ -185,6 +190,13 @@ function validateProofLayers(state, errors) {
                 errors.push(`proof layer ${layerId} references ${evidenceId} but that evidence does not prove it`);
             }
         }
+        if (layer.status === "satisfied") {
+            const evaluation = evaluateProofLayerAssertions(state, layerId);
+            errors.push(...evaluation.blocking_assertion_failures, ...evaluation.negative_evidence_findings);
+            if (isUiBrowserLayer(layerId) && evaluation.assertion_status !== "passed") {
+                errors.push(`proof layer ${layerId} ui_browser proof not machine-backed`);
+            }
+        }
     }
 }
 function validateAuditor(state, errors) {
@@ -242,6 +254,7 @@ export function completionConditionErrors(state) {
     validateDeliveryContract(state, errors);
     validateScopeConflicts(state, errors);
     validateGraphReferences(state, errors);
+    validatePlanCompletionConformance(state, errors);
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
     validateAuditor(state, errors);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.80",
+  "version": "0.2.81",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",
@@ -55,15 +55,15 @@
     "prepack": "npm run build"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "dependencies": {
-    "@google/design.md": "^0.2.0",
-    "impeccable": "^2.3.2",
+    "@google/design.md": "^0.3.0",
+    "impeccable": "^3.1.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^26.0.0",
     "typescript": "^5.5.0"
   }
 }