project-tiny-context-harness 0.2.80 → 0.2.82

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
+import { evaluateProofLayerAssertions } from "./superpowers-task-assertions.js";
 export async function deriveSuperpowersArtifacts(workdir) {
     const state = await loadSuperpowersState(workdir);
     const derived = deriveObjects(state);
@@ -10,6 +11,7 @@ export async function deriveSuperpowersArtifacts(workdir) {
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.json"), stableJson(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.json"), stableJson(derived.verdict));
     await writeDerived(files, path.join(derivedDir, "progress-ledger.json"), stableJson(derived.progress));
+    await writeDerived(files, path.join(derivedDir, "evidence-index.json"), stableJson(deriveEvidenceIndex(state)));
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.md"), matrixMarkdown(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.md"), verdictMarkdown(derived.verdict));
     await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state));
@@ -23,8 +25,10 @@ export function deriveObjects(state) {
     const matrixRows = Object.entries(state.graph.plan_items).map(([planItemId, item]) => {
         const relatedAcs = item.related_acs;
         const requiredLayers = item.required_proof_layers;
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
+        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
         const evidenceIds = evidenceForLayers(state, requiredLayers);
+        const invalidEvidence = invalidEvidenceSignals(assertionSummary);
         return {
             plan_item_id: planItemId,
             plan_requirement: item.requirement,
@@ -35,6 +39,15 @@ export function deriveObjects(state) {
             representative_samples: item.representative_samples,
             full_population_boundary: item.full_population_boundary,
             non_required_population: item.non_required_population,
+            owner_boundary: item.owner_boundary,
+            primary_capability_path: item.primary_capability_path,
+            trigger_contract: item.trigger_contract,
+            state_transition_contract: item.state_transition_contract,
+            observable_result_contract: item.observable_result_contract,
+            assertion_support: item.assertion_support,
+            required_assertion_commands: item.required_assertion_commands,
+            invalid_implementation_shortcuts: item.invalid_implementation_shortcuts,
+            blockers: item.blockers ?? [],
             conformance_type: item.owner_surfaces.length > 0 ? "product_surface" : "implementation",
             owner_surface: item.owner_surfaces[0] ?? "",
             forbidden_primary_surfaces: item.forbidden_surfaces,
@@ -51,16 +64,24 @@ export function deriveObjects(state) {
             required_proof_layers: requiredLayers,
             satisfied_proof_layers: requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied"),
             missing_required_layers: missingLayers,
+            assertion_status: assertionSummary.assertion_status,
+            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
+            negative_evidence_findings: assertionSummary.negative_evidence_findings,
+            invalid_evidence: invalidEvidence,
+            forbidden_shortcuts_hit: invalidEvidence.filter((item) => /forbidden shortcut|cannot satisfy/i.test(item)),
             evidence_ids: evidenceIds,
             scope_assessment: missingLayers.length === 0 ? "full" : "partial",
-            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers"
+            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers",
+            decision: missingLayers.length === 0 ? "accept" : "continue"
         };
     });
     const verdictRows = Object.entries(state.graph.acceptance_criteria).map(([acId, ac]) => {
         const requiredLayers = ac.required_proof_layers.map((layer) => `${acId}.${layer}`);
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
+        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
         const evidenceIds = evidenceForLayers(state, requiredLayers);
         const status = missingLayers.length === 0 && requiredLayers.length > 0 ? "complete" : evidenceIds.length > 0 ? "partial" : ac.status;
+        const invalidCompletionSignals = invalidEvidenceSignals(assertionSummary);
         return {
             ac_id: acId,
             related_plan_item_ids: ac.related_plan_items,
@@ -71,11 +92,23 @@ export function deriveObjects(state) {
             sample_boundary: ac.sample_boundary,
             full_population_required: ac.full_population_required,
             full_population_status: ac.full_population_required === true || ac.acceptance_scope === "full_population_operation" ? status : "not_in_scope",
+            assertion_command: ac.assertion_command ?? "",
+            assertion_artifacts: ac.assertion_artifacts ?? [],
+            positive_assertions: ac.positive_assertions ?? [],
+            negative_assertions: ac.negative_assertions ?? [],
+            machine_blocking: ac.machine_blocking ?? false,
+            invalid_completion_signals: ac.invalid_completion_signals ?? [],
+            assertion_result_required: ac.assertion_result_required ?? false,
             required_evidence: requiredLayers,
             required_proof_chain: requiredLayers,
             fresh_evidence: evidenceText(state, evidenceIds),
             missing_evidence: [],
             missing_required_layers: missingLayers,
+            assertion_status: assertionSummary.assertion_status,
+            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
+            negative_evidence_findings: assertionSummary.negative_evidence_findings,
+            invalid_evidence_findings: invalidCompletionSignals,
+            required_next_evidence: requiredNextEvidence(missingLayers, assertionSummary),
             contradictions: [],
             context_fact_refs: [],
             evidence_ids: evidenceIds,
@@ -88,6 +121,16 @@ export function deriveObjects(state) {
     const allComplete = verdictRows.length > 0 && verdictRows.every((row) => row.status === "complete");
     const progress = {
         ...state.progress,
+        acceptance_progress: {
+            status: allComplete ? "complete" : "partial",
+            complete_count: verdictRows.filter((row) => row.status === "complete").length,
+            required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length
+        },
+        engineering_implementation_progress: progressStatus(Object.values(state.graph.plan_items).map((item) => item.status)),
+        runtime_proof_progress: progressStatus(Object.values(state.graph.proof_layers).map((layer) => layer.status)),
+        proof_layer_milestones: Object.entries(state.graph.proof_layers).map(([layerId, layer]) => ({ layer_id: layerId, status: layer.status, evidence_ids: layer.evidence_ids })),
+        artifact_budget: { evidence_records: state.evidence.length, artifact_count: state.evidence.reduce((sum, item) => sum + item.artifact_paths.length, 0) },
+        workflow_overhead: { slices: state.slices.length, blockers: state.blockers.length },
         complete_count: verdictRows.filter((row) => row.status === "complete").length,
         partial_count: verdictRows.filter((row) => row.status === "partial").length,
         acceptance_required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length,
@@ -103,13 +146,60 @@ export function deriveObjects(state) {
         progress
     };
 }
+function invalidEvidenceSignals(summary) {
+    return [...summary.blocking_assertion_failures, ...summary.negative_evidence_findings].filter((item) => /invalid evidence|forbidden shortcut|cannot satisfy|negative evidence|forbidden text/i.test(item));
+}
+function requiredNextEvidence(missingLayers, summary) {
+    return [...missingLayers.map((layerId) => `fresh assertion-backed evidence for ${layerId}`), ...summary.blocking_assertion_failures, ...summary.negative_evidence_findings];
+}
+function progressStatus(statuses) {
+    const complete = statuses.filter((status) => status === "complete" || status === "satisfied").length;
+    return { status: statuses.length > 0 && complete === statuses.length ? "complete" : complete > 0 ? "partial" : "not_started", complete, total: statuses.length };
+}
 export async function derivedMatchesState(workdir, state) {
     const errors = [];
     const expected = deriveObjects(state);
     await assertDerivedJson(workdir, "plan-conformance-matrix", expected.matrix, errors);
     await assertDerivedJson(workdir, "final-acceptance-verdict", expected.verdict, errors);
+    await assertDerivedJson(workdir, "evidence-index", deriveEvidenceIndex(state), errors);
     return errors;
 }
+export function deriveEvidenceIndex(state) {
+    const evidenceById = Object.fromEntries((state.evidence ?? []).map((evidence) => [
+        evidence.evidence_id,
+        {
+            evidence_id: evidence.evidence_id,
+            type: evidence.type,
+            command: evidence.command ?? "",
+            command_exit_code: evidence.command_exit_code,
+            artifact_paths: evidence.artifact_paths,
+            proves: evidence.proves,
+            does_not_prove: evidence.does_not_prove,
+            assertion_result: evidence.assertion_result ?? null,
+            negative_evidence_scan: evidence.negative_evidence_scan ?? null,
+            freshness: evidence.freshness,
+            reviewability: evidence.reviewability,
+            redaction: evidence.redaction
+        }
+    ]));
+    const proofLayers = Object.fromEntries(Object.entries(state.graph.proof_layers ?? {}).map(([layerId, layer]) => {
+        const evaluation = evaluateProofLayerAssertions(state, layerId);
+        return [
+            layerId,
+            {
+                layer_id: layerId,
+                status: layer.status,
+                required: layer.required,
+                evidence_ids: layer.evidence_ids,
+                assertion_status: evaluation.assertion_status,
+                blocking_assertion_failures: evaluation.blocking_assertion_failures,
+                negative_evidence_findings: evaluation.negative_evidence_findings,
+                evidence: layer.evidence_ids.map((evidenceId) => evidenceById[evidenceId]).filter(Boolean)
+            }
+        ];
+    }));
+    return { proof_layers: proofLayers, evidence: evidenceById };
+}
 async function assertDerivedJson(workdir, basename, expected, errors) {
     const file = path.join(workdir, "derived", `${basename}.json`);
     if (!(await pathExists(file))) {
@@ -123,15 +213,35 @@ async function assertDerivedJson(workdir, basename, expected, errors) {
 function evidenceForLayers(state, layerIds) {
     return [...new Set(layerIds.flatMap((layerId) => state.graph.proof_layers[layerId]?.evidence_ids ?? []))];
 }
+function assertionSummaryForLayers(state, layerIds) {
+    const evaluations = layerIds.map((layerId) => evaluateProofLayerAssertions(state, layerId));
+    const applicable = evaluations.filter((item) => item.assertion_status !== "not_applicable");
+    const blocking_assertion_failures = applicable.flatMap((item) => item.blocking_assertion_failures);
+    const negative_evidence_findings = applicable.flatMap((item) => item.negative_evidence_findings);
+    const statuses = applicable.map((item) => item.assertion_status);
+    const assertion_status = applicable.length === 0
+        ? "not_applicable"
+        : statuses.includes("failed")
+            ? "failed"
+            : statuses.includes("stale")
+                ? "stale"
+                : statuses.includes("missing")
+                    ? "missing"
+                    : "passed";
+    return { assertion_status, blocking_assertion_failures, negative_evidence_findings };
+}
 function evidenceText(state, evidenceIds, type) {
     return evidenceIds
         .map((evidenceId) => state.evidence.find((item) => item.evidence_id === evidenceId))
-        .filter((item) => item && (!type || item.type === type || (type === "artifact" && item.artifact_paths.length > 0)))
+        .filter((item) => item && (!type || evidenceTypeMatches(item.type, type) || (type === "artifact" && item.artifact_paths.length > 0)))
         .map((item) => {
         const artifacts = item?.artifact_paths.join(", ");
         return `${item?.type} ${item?.command ?? ""} ${artifacts}`.trim();
     });
 }
+function evidenceTypeMatches(actual, expected) {
+    return actual === expected || actual.includes(expected) || (expected === "browser" && /\b(playwright|ui_browser|browser)_assertion\b/.test(actual));
+}
 function auditorStatus(state) {
     const auditor = state.gates.auditor;
     if (auditor && typeof auditor === "object" && !Array.isArray(auditor) && typeof auditor.auditor_status === "string") {
@@ -182,9 +292,16 @@ ${stableJson(progress)}
 `;
 }
 function evidenceMarkdown(state) {
+    const index = deriveEvidenceIndex(state);
+    const layers = Object.values(index.proof_layers);
     return [
         "# Evidence Index",
         "",
+        ...layers.map((item) => {
+            const evidenceIds = item.evidence_ids ?? [];
+            return `- ${item.layer_id}: ${item.assertion_status}; evidence ${evidenceIds.join(", ") || "(none)"}`;
+        }),
+        "",
         ...state.evidence.map((item) => `- ${item.evidence_id}: proves ${item.proves.join(", ")}; does_not_prove ${item.does_not_prove.join(", ")}`)
     ].join("\n");
 }

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

@@ -0,0 +1,22 @@
+export declare const PRODUCT_FIELDS: readonly ["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 declare const PLAN_FIELDS: readonly ["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 declare const ACCEPTANCE_FIELDS: readonly ["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 declare const PRODUCT_REQUIRED_FIELDS: readonly ["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 declare const PLAN_REQUIRED_FIELDS: readonly ["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 declare const ACCEPTANCE_REQUIRED_FIELDS: readonly ["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"];
+type FieldType = "array" | "boolean" | "enum" | "text";
+export declare const PRODUCT_FIELD_TYPES: Record<(typeof PRODUCT_FIELDS)[number], FieldType>;
+export declare const PLAN_FIELD_TYPES: Record<(typeof PLAN_FIELDS)[number], FieldType>;
+export declare const ACCEPTANCE_FIELD_TYPES: Record<(typeof ACCEPTANCE_FIELDS)[number], FieldType>;
+export declare const PRODUCT_DELIVERY_SCOPES: Set<string>;
+export declare const PLAN_DELIVERY_SCOPES: Set<string>;
+export declare const ACCEPTANCE_SCOPES: Set<string>;
+export declare const SCOPE_FIT_DECISIONS: Set<string>;
+export declare const CANONICAL_PROOF_LAYERS: readonly ["code", "api_schema", "worker_runtime", "data_artifact", "integration", "ui_browser", "security_redaction", "all_provider_all_runner", "cleanup_stale_scan", "test"];
+export declare const LEGACY_PROOF_LAYER_ALIASES: Record<string, string>;
+export declare const MACHINE_VERIFIABLE_LAYER_NAMES: Set<string>;
+export declare function fieldSet(fields: readonly string[]): Set<string>;
+export declare function normalizeProofLayerName(layer: string): string;
+export declare function normalizeProofLayerId(layerId: string): string;
+export declare function isSelectedScopeFitSlice(value: string): boolean;
+export {};

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-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;
+    });
+}