project-tiny-context-harness 0.2.81 → 0.2.82

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

@@ -0,0 +1,276 @@
+export const PRODUCT_FIELDS = [
+    "delivery_scope",
+    "full_population_required",
+    "representative_samples_validate",
+    "representative_samples_do_not_validate",
+    "out_of_scope_backlog",
+    "scope_fit_decision",
+    "selected_scope_fit_slice",
+    "owner_boundary",
+    "primary_capability_path",
+    "non_completing_outcomes",
+    "assertion_policy",
+    "source_authority",
+    "product_goal",
+    "surface_ia_lock",
+    "decision_lock",
+    "context_delta",
+    "source_to_context_coverage",
+    "acceptance_semantics",
+    "impact"
+];
+export const PLAN_FIELDS = [
+    "delivery_scope",
+    "capability_target",
+    "representative_samples",
+    "full_population_boundary",
+    "non_required_population",
+    "owner_surfaces",
+    "forbidden_surfaces",
+    "owner_boundary",
+    "primary_capability_path",
+    "trigger_contract",
+    "state_transition_contract",
+    "observable_result_contract",
+    "assertion_support",
+    "required_assertion_commands",
+    "invalid_implementation_shortcuts",
+    "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"
+];
+export const ACCEPTANCE_FIELDS = [
+    "acceptance_scope",
+    "ac_validates",
+    "ac_does_not_validate",
+    "sample_boundary",
+    "full_population_required",
+    "related_plan_items",
+    "required_proof_layers",
+    "assertion_command",
+    "assertion_artifacts",
+    "positive_assertions",
+    "negative_assertions",
+    "machine_blocking",
+    "invalid_completion_signals",
+    "assertion_result_required",
+    "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 const PRODUCT_REQUIRED_FIELDS = [
+    "delivery_scope",
+    "full_population_required",
+    "representative_samples_validate",
+    "representative_samples_do_not_validate",
+    "out_of_scope_backlog",
+    "scope_fit_decision",
+    "selected_scope_fit_slice",
+    "owner_boundary",
+    "primary_capability_path",
+    "non_completing_outcomes",
+    "assertion_policy",
+    "source_authority",
+    "product_goal"
+];
+export const PLAN_REQUIRED_FIELDS = [
+    "delivery_scope",
+    "capability_target",
+    "representative_samples",
+    "full_population_boundary",
+    "non_required_population",
+    "owner_boundary",
+    "primary_capability_path",
+    "trigger_contract",
+    "state_transition_contract",
+    "observable_result_contract",
+    "assertion_support",
+    "required_assertion_commands",
+    "invalid_implementation_shortcuts",
+    "implementation_paths"
+];
+export const ACCEPTANCE_REQUIRED_FIELDS = [
+    "acceptance_scope",
+    "ac_validates",
+    "ac_does_not_validate",
+    "sample_boundary",
+    "full_population_required",
+    "related_plan_items",
+    "required_proof_layers",
+    "assertion_command",
+    "assertion_artifacts",
+    "positive_assertions",
+    "negative_assertions",
+    "machine_blocking",
+    "invalid_completion_signals",
+    "assertion_result_required"
+];
+export const PRODUCT_FIELD_TYPES = {
+    delivery_scope: "enum",
+    full_population_required: "boolean",
+    representative_samples_validate: "array",
+    representative_samples_do_not_validate: "array",
+    out_of_scope_backlog: "array",
+    scope_fit_decision: "enum",
+    selected_scope_fit_slice: "text",
+    owner_boundary: "text",
+    primary_capability_path: "text",
+    non_completing_outcomes: "array",
+    assertion_policy: "text",
+    source_authority: "text",
+    product_goal: "text",
+    surface_ia_lock: "text",
+    decision_lock: "text",
+    context_delta: "text",
+    source_to_context_coverage: "text",
+    acceptance_semantics: "text",
+    impact: "text"
+};
+export const PLAN_FIELD_TYPES = {
+    delivery_scope: "enum",
+    capability_target: "text",
+    representative_samples: "array",
+    full_population_boundary: "text",
+    non_required_population: "array",
+    owner_surfaces: "array",
+    forbidden_surfaces: "array",
+    owner_boundary: "text",
+    primary_capability_path: "text",
+    trigger_contract: "text",
+    state_transition_contract: "text",
+    observable_result_contract: "text",
+    assertion_support: "text",
+    required_assertion_commands: "array",
+    invalid_implementation_shortcuts: "array",
+    implementation_paths: "array",
+    required_tests: "array",
+    related_acs: "array",
+    requirement_ref: "text",
+    decision_id: "text",
+    proof_layer_ids: "array",
+    api_schema_changes: "text",
+    state_machine: "text",
+    data_flow: "text",
+    worker_runtime_behavior: "text",
+    ui_ia_changes: "text",
+    migration_plan: "text",
+    evidence_artifacts: "array",
+    explicit_no_test_scope: "boolean",
+    non_completing_shortcuts: "array",
+    substitution_policy: "array",
+    drift_severity: "text",
+    partial_conditions: "array",
+    blockers: "array",
+    context_fact_refs: "array"
+};
+export const ACCEPTANCE_FIELD_TYPES = {
+    acceptance_scope: "enum",
+    ac_validates: "array",
+    ac_does_not_validate: "array",
+    sample_boundary: "text",
+    full_population_required: "boolean",
+    related_plan_items: "array",
+    required_proof_layers: "array",
+    assertion_command: "text",
+    assertion_artifacts: "array",
+    positive_assertions: "array",
+    negative_assertions: "array",
+    machine_blocking: "boolean",
+    invalid_completion_signals: "array",
+    assertion_result_required: "boolean",
+    ac_type: "text",
+    proof_chain: "array",
+    verification_method: "array",
+    fail_conditions: "array",
+    invalid_evidence: "array",
+    substitution_policy: "array",
+    missing_layer_downgrade: "text",
+    auditor_expectation: "text",
+    out_of_scope_na_approval_source: "text",
+    required_test_ids: "array",
+    explicit_no_test_scope: "boolean",
+    hard_blockers: "array",
+    validates_explanation: "text",
+    does_not_validate_explanation: "text",
+    final_evidence_expected: "array",
+    test_cases: "array"
+};
+export const PRODUCT_DELIVERY_SCOPES = new Set([
+    "system_capability_build", "representative_sample_validation", "full_population_operation", "mixed_scope_requires_boundary"
+]);
+export const PLAN_DELIVERY_SCOPES = new Set([
+    "system_capability_build", "representative_sample_validation", "full_population_operation", "out_of_scope_backlog"
+]);
+export const ACCEPTANCE_SCOPES = new Set([
+    "system_capability_build", "representative_sample_validation", "full_population_operation", "full_population_not_required"
+]);
+export const SCOPE_FIT_DECISIONS = new Set(["fit_for_three_inputs", "selected_from_split", "blocked_for_decision"]);
+export const CANONICAL_PROOF_LAYERS = [
+    "code",
+    "api_schema",
+    "worker_runtime",
+    "data_artifact",
+    "integration",
+    "ui_browser",
+    "security_redaction",
+    "all_provider_all_runner",
+    "cleanup_stale_scan",
+    "test"
+];
+export const LEGACY_PROOF_LAYER_ALIASES = {
+    runtime: "worker_runtime",
+    browser: "ui_browser",
+    api: "api_schema",
+    data: "data_artifact",
+    security: "security_redaction"
+};
+export const MACHINE_VERIFIABLE_LAYER_NAMES = new Set(CANONICAL_PROOF_LAYERS.filter((layer) => layer !== "code"));
+export function fieldSet(fields) {
+    return new Set(fields);
+}
+export function normalizeProofLayerName(layer) {
+    const normalized = layer.trim().toLowerCase().replace(/[- ]+/g, "_");
+    return LEGACY_PROOF_LAYER_ALIASES[normalized] ?? normalized;
+}
+export function normalizeProofLayerId(layerId) {
+    const value = layerId.trim();
+    if (!value.includes(".")) {
+        return normalizeProofLayerName(value);
+    }
+    const acId = value.slice(0, value.lastIndexOf("."));
+    const layer = value.slice(value.lastIndexOf(".") + 1);
+    return `${acId}.${normalizeProofLayerName(layer)}`;
+}
+export function isSelectedScopeFitSlice(value) {
+    return value === "none" || /^SFC-\d{3,}$/i.test(value);
+}

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

@@ -1,89 +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;
@@ -91,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,
@@ -103,13 +52,33 @@ 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(normalizeLayer),
+            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",
@@ -123,9 +92,9 @@ 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,
@@ -137,13 +106,31 @@ 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()),
+            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"
         };
@@ -152,28 +139,36 @@ 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([
-        ...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")
-    ]);
+    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: MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            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
@@ -223,6 +218,9 @@ function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
 function optionalArray(fields, name) {
     return fields[name] ? fieldArray(fields, name) : [];
 }
+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

@@ -86,9 +86,7 @@ function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
         }
         const name = match[1];
         if (!allowedFields.has(name)) {
-            if (name.includes("_")) {
-                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"));
-            }
+            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]) {

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

@@ -59,6 +59,7 @@ export type SuperpowersAcceptanceStatus = "not_run" | "complete" | "partial" | "
 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;
@@ -113,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>;
@@ -131,13 +146,33 @@ 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;
@@ -157,10 +192,28 @@ export interface SuperpowersAcceptanceCriterion {
     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;
 }
@@ -168,6 +221,10 @@ 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[];
@@ -252,6 +309,8 @@ 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[];