project-tiny-context-harness 0.2.80 → 0.2.82

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

@@ -1,87 +1,38 @@
+import { MACHINE_VERIFIABLE_PROOF_LAYERS, proofLayerName } from "./superpowers-task-assertions.js";
+import { compileReportSuffix, missingCategory, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
+import { ACCEPTANCE_FIELDS, ACCEPTANCE_SCOPES, fieldSet, isSelectedScopeFitSlice, normalizeProofLayerName, PLAN_DELIVERY_SCOPES, PLAN_FIELDS, PRODUCT_DELIVERY_SCOPES, PRODUCT_FIELDS, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.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"]);
-const PLAN_DELIVERY_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "out_of_scope_backlog"]);
-const ACCEPTANCE_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "full_population_not_required"]);
-const PRODUCT_FIELDS = new Set([
-    "delivery_scope",
-    "full_population_required",
-    "representative_samples_validate",
-    "representative_samples_do_not_validate",
-    "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",
-    "capability_target",
-    "representative_samples",
-    "full_population_boundary",
-    "non_required_population",
-    "owner_surfaces",
-    "forbidden_surfaces",
-    "implementation_paths",
-    "required_tests",
-    "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",
-    "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"
-]);
+const PRODUCT_FIELD_SET = fieldSet(PRODUCT_FIELDS);
+const PLAN_FIELD_SET = fieldSet(PLAN_FIELDS);
+const ACCEPTANCE_FIELD_SET = fieldSet(ACCEPTANCE_FIELDS);
 export function parseProductArchitectureScope(content, sourceFile) {
-    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELDS);
+    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELD_SET);
     const errors = [];
+    const selectedScopeFitSlice = requireText(errors, "Product / Architecture Source", "selected_scope_fit_slice", fields, sourceFile, 1);
+    if (selectedScopeFitSlice && !isSelectedScopeFitSlice(selectedScopeFitSlice)) {
+        errors.push(`Product / Architecture Source invalid selected_scope_fit_slice: ${selectedScopeFitSlice} at ${sourceFile}:${fieldLine(fields, "selected_scope_fit_slice") ?? 1}; allowed: none or SFC-###${compileReportSuffix("blocking_unparseable_object", sourceFile, fieldLine(fields, "selected_scope_fit_slice") ?? 1, "selected_scope_fit_slice", "value must be none or an SFC-### id", "fix selected_scope_fit_slice and rerun compile")}`);
+    }
     const scope = {
         delivery_scope: requireEnum(errors, "Product / Architecture Source", "delivery_scope", fields, PRODUCT_DELIVERY_SCOPES, sourceFile, 1),
         full_population_required: requireBoolean(errors, "Product / Architecture Source", "full_population_required", fields, sourceFile, 1),
         representative_samples_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_validate", fields, sourceFile, 1),
         representative_samples_do_not_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_do_not_validate", fields, sourceFile, 1),
-        out_of_scope_backlog: requireArray(errors, "Product / Architecture Source", "out_of_scope_backlog", fields, sourceFile, 1)
+        out_of_scope_backlog: requireArray(errors, "Product / Architecture Source", "out_of_scope_backlog", fields, sourceFile, 1),
+        scope_fit_decision: requireEnum(errors, "Product / Architecture Source", "scope_fit_decision", fields, SCOPE_FIT_DECISIONS, sourceFile, 1),
+        selected_scope_fit_slice: selectedScopeFitSlice,
+        owner_boundary: requireText(errors, "Product / Architecture Source", "owner_boundary", fields, sourceFile, 1),
+        primary_capability_path: requireText(errors, "Product / Architecture Source", "primary_capability_path", fields, sourceFile, 1),
+        non_completing_outcomes: requireArray(errors, "Product / Architecture Source", "non_completing_outcomes", fields, sourceFile, 1),
+        assertion_policy: requireText(errors, "Product / Architecture Source", "assertion_policy", fields, sourceFile, 1),
+        source_authority: requireText(errors, "Product / Architecture Source", "source_authority", fields, sourceFile, 1),
+        product_goal: requireText(errors, "Product / Architecture Source", "product_goal", fields, sourceFile, 1),
+        surface_ia_lock: optionalText(fields, "surface_ia_lock"),
+        decision_lock: optionalText(fields, "decision_lock"),
+        context_delta: optionalText(fields, "context_delta"),
+        source_to_context_coverage: optionalText(fields, "source_to_context_coverage"),
+        acceptance_semantics: optionalText(fields, "acceptance_semantics"),
+        impact: optionalText(fields, "impact")
     };
     throwCompileErrors(errors);
     return scope;
@@ -89,7 +40,7 @@ export function parseProductArchitectureScope(content, sourceFile) {
 export function parsePlanItems(content, sourceFile) {
     const items = {};
     const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELDS })) {
+    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELD_SET })) {
         const fields = definition.fields;
         items[definition.id] = {
             requirement: definition.title,
@@ -101,10 +52,35 @@ export function parsePlanItems(content, sourceFile) {
             representative_samples: requireArray(errors, definition.id, "representative_samples", fields, sourceFile, definition.source_start_line),
             full_population_boundary: requireText(errors, definition.id, "full_population_boundary", fields, sourceFile, definition.source_start_line),
             non_required_population: requireArray(errors, definition.id, "non_required_population", fields, sourceFile, definition.source_start_line),
+            owner_boundary: requireText(errors, definition.id, "owner_boundary", fields, sourceFile, definition.source_start_line),
+            primary_capability_path: requireText(errors, definition.id, "primary_capability_path", fields, sourceFile, definition.source_start_line),
+            trigger_contract: requireText(errors, definition.id, "trigger_contract", fields, sourceFile, definition.source_start_line),
+            state_transition_contract: requireText(errors, definition.id, "state_transition_contract", fields, sourceFile, definition.source_start_line),
+            observable_result_contract: requireText(errors, definition.id, "observable_result_contract", fields, sourceFile, definition.source_start_line),
+            assertion_support: requireText(errors, definition.id, "assertion_support", fields, sourceFile, definition.source_start_line),
+            required_assertion_commands: requireArray(errors, definition.id, "required_assertion_commands", fields, sourceFile, definition.source_start_line),
+            invalid_implementation_shortcuts: requireArray(errors, definition.id, "invalid_implementation_shortcuts", fields, sourceFile, definition.source_start_line),
             owner_surfaces: optionalArray(fields, "owner_surfaces"),
             forbidden_surfaces: optionalArray(fields, "forbidden_surfaces"),
-            implementation_paths: optionalArray(fields, "implementation_paths"),
+            implementation_paths: requireArray(errors, definition.id, "implementation_paths", fields, sourceFile, definition.source_start_line),
             required_tests: optionalArray(fields, "required_tests"),
+            proof_layer_ids: optionalArray(fields, "proof_layer_ids").map(normalizeLayerId),
+            requirement_ref: optionalText(fields, "requirement_ref"),
+            decision_id: optionalText(fields, "decision_id"),
+            api_schema_changes: optionalText(fields, "api_schema_changes"),
+            state_machine: optionalText(fields, "state_machine"),
+            data_flow: optionalText(fields, "data_flow"),
+            worker_runtime_behavior: optionalText(fields, "worker_runtime_behavior"),
+            ui_ia_changes: optionalText(fields, "ui_ia_changes"),
+            migration_plan: optionalText(fields, "migration_plan"),
+            evidence_artifacts: optionalArray(fields, "evidence_artifacts"),
+            non_completing_shortcuts: optionalArray(fields, "non_completing_shortcuts"),
+            substitution_policy: optionalArray(fields, "substitution_policy"),
+            drift_severity: optionalText(fields, "drift_severity"),
+            partial_conditions: optionalArray(fields, "partial_conditions"),
+            blockers: optionalArray(fields, "blockers"),
+            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: []
@@ -116,9 +92,10 @@ export function parsePlanItems(content, sourceFile) {
 export function parseAcceptanceCriteria(content, sourceFile) {
     const items = {};
     const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELDS })) {
+    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELD_SET })) {
         const fields = definition.fields;
-        const layers = optionalArray(fields, "required_proof_layers").map(normalizeLayer).filter(Boolean);
+        const layers = requireArray(errors, definition.id, "required_proof_layers", fields, sourceFile, definition.source_start_line).map(normalizeLayer).filter(Boolean);
+        const requiredProofLayers = layers.length > 0 ? layers : DEFAULT_LAYERS;
         items[definition.id] = {
             scope: definition.title,
             source_file: definition.source_file,
@@ -129,8 +106,32 @@ export function parseAcceptanceCriteria(content, sourceFile) {
             ac_does_not_validate: requireArray(errors, definition.id, "ac_does_not_validate", fields, sourceFile, definition.source_start_line),
             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,
+            related_plan_items: requireArray(errors, definition.id, "related_plan_items", fields, sourceFile, definition.source_start_line).map((item) => item.toUpperCase()),
+            required_proof_layers: requiredProofLayers,
+            assertion_requirements: assertionRequirements(fields, requiredProofLayers),
+            assertion_command: requireText(errors, definition.id, "assertion_command", fields, sourceFile, definition.source_start_line),
+            assertion_artifacts: requireArray(errors, definition.id, "assertion_artifacts", fields, sourceFile, definition.source_start_line),
+            positive_assertions: requireArray(errors, definition.id, "positive_assertions", fields, sourceFile, definition.source_start_line),
+            negative_assertions: requireArray(errors, definition.id, "negative_assertions", fields, sourceFile, definition.source_start_line),
+            machine_blocking: requireBoolean(errors, definition.id, "machine_blocking", fields, sourceFile, definition.source_start_line),
+            invalid_completion_signals: requireArray(errors, definition.id, "invalid_completion_signals", fields, sourceFile, definition.source_start_line),
+            assertion_result_required: requireBoolean(errors, definition.id, "assertion_result_required", fields, sourceFile, definition.source_start_line),
+            ac_type: optionalText(fields, "ac_type"),
+            proof_chain: optionalArray(fields, "proof_chain").map(normalizeLayerId),
+            required_test_ids: optionalArray(fields, "required_test_ids"),
+            fail_conditions: optionalArray(fields, "fail_conditions"),
+            invalid_evidence: optionalArray(fields, "invalid_evidence"),
+            substitution_policy: optionalArray(fields, "substitution_policy"),
+            missing_layer_downgrade: optionalText(fields, "missing_layer_downgrade"),
+            auditor_expectation: optionalText(fields, "auditor_expectation"),
+            out_of_scope_na_approval_source: optionalText(fields, "out_of_scope_na_approval_source"),
+            hard_blockers: optionalArray(fields, "hard_blockers"),
+            validates_explanation: optionalText(fields, "validates_explanation"),
+            does_not_validate_explanation: optionalText(fields, "does_not_validate_explanation"),
+            final_evidence_expected: optionalArray(fields, "final_evidence_expected"),
+            verification_method: optionalArray(fields, "verification_method"),
+            test_cases: optionalArray(fields, "test_cases"),
+            explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
             status: "not_run"
         };
     }
@@ -138,17 +139,51 @@ export function parseAcceptanceCriteria(content, sourceFile) {
     return items;
 }
 function normalizeLayer(value) {
-    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
+    return normalizeProofLayerName(value);
+}
+function normalizeLayerId(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes(".")) {
+        return normalizeLayer(trimmed);
+    }
+    const acId = trimmed.slice(0, trimmed.lastIndexOf(".")).toUpperCase();
+    const layer = trimmed.slice(trimmed.lastIndexOf(".") + 1);
+    return `${acId}.${normalizeLayer(layer)}`;
+}
+function assertionRequirements(fields, layers) {
+    const requiredTestIds = optionalArray(fields, "required_test_ids");
+    const positiveAssertions = unique(optionalArray(fields, "positive_assertions"));
+    const negativeAssertions = unique(optionalArray(fields, "negative_assertions"));
+    const assertionCommand = fieldText(fields, "assertion_command");
+    const assertionArtifacts = optionalArray(fields, "assertion_artifacts");
+    const machineBlocking = fieldBoolean(fields, "machine_blocking");
+    const assertionResultRequired = fieldBoolean(fields, "assertion_result_required");
+    const invalidCompletionSignals = optionalArray(fields, "invalid_completion_signals");
+    return layers.map((layer) => {
+        const normalized = proofLayerName(normalizeLayer(layer));
+        return {
+            proof_layer: normalized,
+            required: true,
+            machine_blocking: machineBlocking ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            assertion_result_required: assertionResultRequired ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            assertion_command: assertionCommand,
+            assertion_artifacts: assertionArtifacts,
+            invalid_completion_signals: invalidCompletionSignals,
+            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 +191,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 +206,21 @@ 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 optionalText(fields, name) {
+    return fields[name] ? fieldText(fields, name) : "";
+}
+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);
@@ -85,13 +86,11 @@ 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 +112,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 +131,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 +157,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 +216,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,11 +54,12 @@ 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";
 export type SuperpowersAcceptanceScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "full_population_not_required";
+export type SuperpowersScopeFitDecision = "fit_for_three_inputs" | "selected_from_split" | "blocked_for_decision" | "";
 export interface SuperpowersTaskState {
     meta: {
         task_id: string;
@@ -95,6 +96,7 @@ export interface SuperpowersTaskState {
         acceptance_target_status: string;
         audit_task_complete: boolean;
         completion_basis: string[];
+        next_required_actions?: string[];
     };
 }
 export interface SuperpowersSourceRecord {
@@ -112,6 +114,20 @@ export interface SuperpowersProductArchitectureScope {
     representative_samples_validate: string[];
     representative_samples_do_not_validate: string[];
     out_of_scope_backlog: string[];
+    scope_fit_decision: SuperpowersScopeFitDecision;
+    selected_scope_fit_slice: string;
+    owner_boundary: string;
+    primary_capability_path: string;
+    non_completing_outcomes: string[];
+    assertion_policy: string;
+    source_authority: string;
+    product_goal: string;
+    surface_ia_lock?: string;
+    decision_lock?: string;
+    context_delta?: string;
+    source_to_context_coverage?: string;
+    acceptance_semantics?: string;
+    impact?: string;
 }
 export interface SuperpowersProgressState {
     system_capability_progress: Record<string, unknown>;
@@ -130,10 +146,35 @@ export interface SuperpowersPlanItem {
     representative_samples: string[];
     full_population_boundary: string;
     non_required_population: string[];
+    owner_boundary: string;
+    primary_capability_path: string;
+    trigger_contract: string;
+    state_transition_contract: string;
+    observable_result_contract: string;
+    assertion_support: string;
+    required_assertion_commands: string[];
+    invalid_implementation_shortcuts: string[];
     owner_surfaces: string[];
     forbidden_surfaces: string[];
     implementation_paths: string[];
     required_tests: string[];
+    proof_layer_ids?: string[];
+    requirement_ref?: string;
+    decision_id?: string;
+    api_schema_changes?: string;
+    state_machine?: string;
+    data_flow?: string;
+    worker_runtime_behavior?: string;
+    ui_ia_changes?: string;
+    migration_plan?: string;
+    evidence_artifacts?: string[];
+    non_completing_shortcuts?: string[];
+    substitution_policy?: string[];
+    drift_severity?: string;
+    partial_conditions?: string[];
+    blockers?: string[];
+    explicit_no_test_scope?: boolean;
+    context_fact_refs?: string[];
     status: SuperpowersPlanItemStatus;
     related_acs: string[];
     required_proof_layers: string[];
@@ -150,8 +191,44 @@ export interface SuperpowersAcceptanceCriterion {
     full_population_required: boolean | null;
     related_plan_items: string[];
     required_proof_layers: string[];
+    assertion_requirements?: AssertionRequirement[];
+    assertion_command?: string;
+    assertion_artifacts?: string[];
+    positive_assertions?: string[];
+    negative_assertions?: string[];
+    machine_blocking?: boolean | null;
+    invalid_completion_signals?: string[];
+    assertion_result_required?: boolean | null;
+    ac_type?: string;
+    proof_chain?: string[];
+    required_test_ids?: string[];
+    fail_conditions?: string[];
+    invalid_evidence?: string[];
+    substitution_policy?: string[];
+    missing_layer_downgrade?: string;
+    auditor_expectation?: string;
+    out_of_scope_na_approval_source?: string;
+    hard_blockers?: string[];
+    validates_explanation?: string;
+    does_not_validate_explanation?: string;
+    final_evidence_expected?: string[];
+    verification_method?: string[];
+    test_cases?: string[];
+    explicit_no_test_scope?: boolean;
     status: SuperpowersAcceptanceStatus;
 }
+export interface AssertionRequirement {
+    proof_layer: string;
+    required: boolean;
+    machine_blocking: boolean;
+    assertion_result_required?: boolean;
+    assertion_command?: string;
+    assertion_artifacts?: string[];
+    invalid_completion_signals?: string[];
+    required_test_ids: string[];
+    positive_assertions: string[];
+    negative_assertions: string[];
+}
 export interface SuperpowersProofLayer {
     required: boolean;
     status: SuperpowersProofLayerStatus;
@@ -190,6 +267,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 +279,49 @@ 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[];
+    target_proof_layers?: string[];
+    invalid_completion_signals_checked?: 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[];