project-tiny-context-harness 0.2.81 → 0.2.82

package/README.md

@@ -100,6 +100,8 @@ The three inputs also carry capability-first delivery boundaries. Product / Arch
 
 `ty-context composite-long-task compile` uses a strict heading-based grammar for that packet. Product / Architecture Source is one document-level object with fixed fields. Technical Realization Plan items are definitions only when written as Markdown headings such as `## PI-001: ...`; Acceptance Checklist items are definitions only when written as headings such as `## AC-001: ...`. Fields inside those sections must use fixed `key: value`, indented-list or `key: |` syntax. Plain prose, tables, mapping previews and ordinary lists that mention `PI-001` or `AC-001` are references, not definitions; old list-style definitions such as `- PI-001: ...` followed by delivery fields now fail at compile time with file and line guidance.
 
+Strict V2 packets also require canonical Product / PI / AC field groups. Product Source carries Scope Fit and owner-boundary fields such as `scope_fit_decision`, `selected_scope_fit_slice`, `owner_boundary`, `primary_capability_path`, `non_completing_outcomes` and `assertion_policy`; PI items carry owner, trigger, state-transition, observable-result and assertion-support fields; ACs carry `assertion_command`, `assertion_artifacts`, `positive_assertions`, `negative_assertions`, `machine_blocking`, `invalid_completion_signals` and `assertion_result_required`. Unknown, duplicate, table or missing canonical fields fail compile. Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; aliases such as `runtime`, `browser`, `api`, `data` and `security` compile to the canonical names, and `code` cannot complete a machine-backed AC by itself. The generated evidence index is available as both `derived/evidence-index.md` and `derived/evidence-index.json`.
+
 For non-trivial Superpowers-backed slices, the workflow protocol requires a structured `slice-delta.json`. The executor applies it with `ty-context composite-long-task apply-slice-delta <workdir> <slice-delta.json>`, then runs `ty-context composite-long-task derive` and `ty-context composite-long-task slice-gate`. Each delta records touched plan items/ACs, code changes, closed and remaining proof layers, blockers, cleanup assertions, `progress_value` and canonical evidence records with `proves`, `does_not_prove`, freshness, redaction, reviewability, command exit code when applicable, assertion result and negative evidence scan. Default slice guidance is to group 2-4 strongly related missing layers that share an AC, runtime scenario, proof environment or verification path, while single-gap slices are reserved for blockers, contradictions or small metadata cleanup. The protocol also asks executors to classify missing layers, reuse DB/API/Browser environments only with unique proof prefixes and cleanup assertions, and run a stale/overclaim scan after deriving artifacts.
 
 The generated Superpowers prompt uses Slice Gate / Epoch Gate / Final Gate cadence instead of running a full final gate after every slice. Progress Accounting tracks AC acceptance completion, engineering implementation progress, runtime/proof progress, system capability progress, representative sample progress, real object coverage, full population operation progress, artifact budget, proof-layer milestone status and workflow overhead in state and generated `derived/progress-ledger.*`. Workflow overhead backpressure asks executors to batch shared provider/browser/runtime/security epoch proof environments, prune stale artifacts and choose the Next 3-5 high-value clusters that close the most blocking AC/proof-layer gaps.
@@ -163,7 +165,7 @@ npm ci
 npm run smoke:quickstart
 npm run preview:pack
 cd /path/to/your/test-repo
-npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.81.tgz
+npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.82.tgz
 npx --no-install ty-context init --adopt
 make validate-context
 ```

package/assets/README.md

@@ -94,7 +94,7 @@ That smoke packs the local workspace, installs it into a disposable repo, runs `
 ```sh
 npm run preview:pack
 cd /path/to/your/test-repo
-npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.81.tgz
+npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.82.tgz
 npx --no-install ty-context init --adopt
 make validate-context
 ```
@@ -144,6 +144,8 @@ The three inputs also carry capability-first delivery boundaries. Product / Arch
 
 `ty-context composite-long-task compile` uses a strict heading-based grammar for that packet. Product / Architecture Source is one document-level object with fixed fields. Technical Realization Plan items are definitions only when written as Markdown headings such as `## PI-001: ...`; Acceptance Checklist items are definitions only when written as headings such as `## AC-001: ...`. Fields inside those sections must use fixed `key: value`, indented-list or `key: |` syntax. Plain prose, tables, mapping previews and ordinary lists that mention `PI-001` or `AC-001` are references, not definitions; old list-style definitions such as `- PI-001: ...` followed by delivery fields now fail at compile time with file and line guidance.
 
+Strict V2 packets also require canonical Product / PI / AC field groups. Product Source carries Scope Fit and owner-boundary fields such as `scope_fit_decision`, `selected_scope_fit_slice`, `owner_boundary`, `primary_capability_path`, `non_completing_outcomes` and `assertion_policy`; PI items carry owner, trigger, state-transition, observable-result and assertion-support fields; ACs carry `assertion_command`, `assertion_artifacts`, `positive_assertions`, `negative_assertions`, `machine_blocking`, `invalid_completion_signals` and `assertion_result_required`. Unknown, duplicate, table or missing canonical fields fail compile. Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; aliases such as `runtime`, `browser`, `api`, `data` and `security` compile to the canonical names, and `code` cannot complete a machine-backed AC by itself. The generated evidence index is available as both `derived/evidence-index.md` and `derived/evidence-index.json`.
+
 For non-trivial Superpowers-backed slices, the workflow protocol requires a structured `slice-delta.json`. The executor applies it with `ty-context composite-long-task apply-slice-delta <workdir> <slice-delta.json>`, then runs `ty-context composite-long-task derive` and `ty-context composite-long-task slice-gate`. Each delta records touched plan items/ACs, code changes, closed and remaining proof layers, blockers, cleanup assertions, `progress_value` and canonical evidence records with `proves`, `does_not_prove`, freshness, redaction, reviewability, command exit code when applicable, assertion result and negative evidence scan. Default slice guidance is to group 2-4 strongly related missing layers that share an AC, runtime scenario, proof environment or verification path, while single-gap slices are reserved for blockers, contradictions or small metadata cleanup. The protocol also asks executors to classify missing layers, reuse DB/API/Browser environments only with unique proof prefixes and cleanup assertions, and run a stale/overclaim scan after deriving artifacts.
 
 The generated Superpowers prompt uses Slice Gate / Epoch Gate / Final Gate cadence instead of running a full final gate after every slice. Progress Accounting tracks AC acceptance completion, engineering implementation progress, runtime/proof progress, system capability progress, representative sample progress, real object coverage, full population operation progress, artifact budget, proof-layer milestone status and workflow overhead in state and generated `derived/progress-ledger.*`. Workflow overhead backpressure asks executors to batch shared provider/browser/runtime/security epoch proof environments, prune stale artifacts and choose the Next 3-5 high-value clusters that close the most blocking AC/proof-layer gaps.

package/assets/README.zh-CN.md

@@ -62,6 +62,8 @@ Machine-verifiable proof layer（如 UI/browser、runtime、API/schema、data ar
 
 `ty-context composite-long-task compile` 对这三份输入使用严格的 heading-based grammar。Product / Architecture Source 是一个文档级对象，只读固定字段。Technical Realization Plan 里的 PI 只有写成 `## PI-001: ...` 这类 Markdown heading 才是正式定义；Acceptance Checklist 里的 AC 也只有 `## AC-001: ...` 这类 heading 才是正式定义。heading section 内字段必须使用固定 `key: value`、缩进列表或 `key: |` 多行块。正文、表格、mapping preview、`related_acs` / `related_plan_items` 和普通列表里出现的 `PI-001` / `AC-001` 都只是引用；旧式 `- PI-001: ...` 或 `- AC-001: ...` 后面跟字段的写法会在 compile 阶段带文件和行号报错。
 
+Strict V2 输入还要求 canonical Product / PI / AC 字段组。Product Source 必须包含 `scope_fit_decision`、`selected_scope_fit_slice`、`owner_boundary`、`primary_capability_path`、`non_completing_outcomes`、`assertion_policy` 等 Scope Fit / owner 字段；PI 必须包含 owner、trigger、state transition、observable result 和 assertion support 字段；AC 必须包含 `assertion_command`、`assertion_artifacts`、`positive_assertions`、`negative_assertions`、`machine_blocking`、`invalid_completion_signals` 和 `assertion_result_required`。未知字段、重复字段、表格字段和缺失 canonical 字段都会 compile fail。Canonical proof layers 是 `code`、`api_schema`、`worker_runtime`、`data_artifact`、`integration`、`ui_browser`、`security_redaction`、`all_provider_all_runner`、`cleanup_stale_scan` 和 `test`；`runtime` / `browser` / `api` / `data` / `security` 只是 legacy alias，会编译到 canonical 名称，且 `code` 不能单独完成 machine-backed AC。Evidence index 同时生成 `derived/evidence-index.md` 和 `derived/evidence-index.json`。
+
 对于非平凡 slice，生成的 composite workflow prompt 要求使用结构化 `slice-delta.json`。executor 通过 `ty-context composite-long-task apply-slice-delta <workdir> <slice-delta.json>` 应用 delta，然后运行 `ty-context composite-long-task derive` 和 `ty-context composite-long-task slice-gate`。每个 delta 记录 touched plan items / ACs、code changes、closed / remaining proof layers、blockers、cleanup assertions、`progress_value`，以及带有 `proves`、`does_not_prove`、freshness、redaction 和 reviewability 的 canonical evidence records。默认 slice 策略是把同一 AC、runtime 场景、proof 环境或验证路径下的 2-4 个强相关 missing layers 合并处理；单 gap slice 只留给 blocker、contradiction 或小型 metadata cleanup。prompt 还会要求先分类 missing layer、复用 DB/API/Browser 环境时使用唯一 proof prefix 和 cleanup assertion，并在生成 derived artifacts 后做 stale/overclaim scan。
 
 当 slice 声称关闭 machine-verifiable layer 时，`slice-delta.json` 的 evidence record 还应包含 `command_exit_code`、`assertion_result`，UI/browser 等需要时还应包含 `negative_evidence_scan`；derived matrix/verdict 只展示 assertion status 和 blocker，不能替代 assertion 执行。

package/assets/skills/composite-long-task-workflow/SKILL.md

@@ -86,6 +86,8 @@ Strict input grammar:
 - Plain prose, lists, tables, mapping previews and `related_*` fields that mention PI/AC IDs are references, not definitions.
 - Legacy list-style definitions such as `- PI-001: ...` or `- AC-001: ...` followed by delivery fields are invalid.
 
+Strict V2 canonical fields are code-owned by `superpowers-task-fields.ts` and must be present in the three sources. Product Source includes Scope Fit fields such as `scope_fit_decision`, `selected_scope_fit_slice`, `owner_boundary`, `primary_capability_path`, `non_completing_outcomes` and `assertion_policy`. PI items include owner/trigger/state/observable/assertion fields such as `owner_boundary`, `primary_capability_path`, `trigger_contract`, `state_transition_contract`, `observable_result_contract`, `assertion_support`, `required_assertion_commands` and `invalid_implementation_shortcuts`. ACs include assertion-gate fields such as `assertion_command`, `assertion_artifacts`, `positive_assertions`, `negative_assertions`, `machine_blocking`, `invalid_completion_signals` and `assertion_result_required`. Unknown fields, duplicate fields, table fields and missing canonical fields fail compile; this Skill must not infer, repair or backfill them.
+
 ## Authority Model
 
 - Product / Architecture Source owns intent, scope and boundaries.
@@ -171,7 +173,7 @@ Superpowers review and verification remain useful execution checks, but they can
 
 Agents must not hand-set `product_goal_complete`. Implementation / execution goals complete only when final gate computes `product_goal_complete=true`.
 
-For UI/browser/API/runtime/worker/data/integration/security/test/all-provider/cleanup proof layers, do not mark ACs complete from screenshots, final cards, validator passes, matrix/verdict rows or prose evidence. Required machine-verifiable layers need passed `assertion_result`, zero command/assertion exit codes, target AC/layer coverage, passed positive and negative assertions and no failed/stale `negative_evidence_scan`.
+Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; legacy source aliases map `runtime -> worker_runtime`, `browser -> ui_browser`, `api -> api_schema`, `data -> data_artifact` and `security -> security_redaction`. `code` cannot complete a machine-backed AC by itself. For UI/browser/API/worker/data/integration/security/test/all-provider/cleanup proof layers, do not mark ACs complete from screenshots, final cards, validator passes, matrix/verdict rows or prose evidence. Required machine-verifiable layers need passed `assertion_result`, zero command/assertion exit codes, target AC/layer coverage, passed positive and negative assertions, reviewable artifacts and no failed/stale `negative_evidence_scan` with matching target proof layers and checked invalid completion signals.
 
 If `audit_task_complete` is true but `acceptance_target_status` is not complete, report:
 

package/assets/skills/composite-long-task-workflow/assets/goal-objective.template.md

@@ -9,14 +9,14 @@ First read and obey:
 - task-state.json and generated derived/** views
 
 Persistent contract:
-Product / Architecture Source owns intent, scope and boundaries. Technical Realization Plan owns PI implementation and plan conformance. Acceptance Checklist owns AC completion semantics and proof layers. task-state.json is the only execution state source; events.ndjson is append-only; derived/** is generated and must not be hand-edited as authority.
+Product / Architecture Source owns intent, scope, Scope Fit, owner boundaries and assertion policy. Technical Realization Plan owns PI implementation, plan conformance, trigger/state/observable contracts and required assertion commands. Acceptance Checklist owns AC completion semantics, proof layers, assertion_command/artifacts, positive/negative assertions, machine_blocking, invalid_completion_signals and assertion_result_required. task-state.json is the only execution state source; events.ndjson is append-only; derived/** is generated and must not be hand-edited as authority.
 
 Use workflow-protocol.md to combine Tiny Context gates with official Superpowers execution. It is not business Context and must not be registered in project_context/context.toml. Do not redefine, duplicate or fork Superpowers mechanics. Prefer superpowers:subagent-driven-development when subagents are available, otherwise use superpowers:executing-plans. Use TDD for behavior gaps and superpowers:verification-before-completion before completion claims.
 
 Work in slices. Each slice must update state through slice-delta.json, canonical evidence records, derive, and slice-gate. Run epoch-gate for shared provider/browser/runtime/security proof environments. Preserve Context Delta, plan conformance, acceptance proof layers, redaction, reviewability and sample/full-population boundaries.
 
 Forbidden shortcuts:
-Do not mark UI/runtime/API/data/integration/test ACs complete from screenshots, final cards, validator passes, matrix/verdict rows or prose. Required machine-verifiable layers need assertion_result.status=passed, zero command/assertion exit codes, target AC/layer coverage, passed positive and negative assertions, reviewable artifacts and no failed/stale negative_evidence_scan.
+Do not mark UI/worker/API/data/integration/test ACs complete from screenshots, final cards, validator passes, matrix/verdict rows or prose. Canonical layers are code, api_schema, worker_runtime, data_artifact, integration, ui_browser, security_redaction, all_provider_all_runner, cleanup_stale_scan and test; code cannot complete a machine-backed AC alone. Required machine-verifiable layers need assertion_result.status=passed, zero command/assertion exit codes, target AC/layer coverage, passed positive and negative assertions, reviewable artifacts and no failed/stale negative_evidence_scan with matching target proof layers.
 Tests alone do not prove plan conformance. Superpowers review does not override Tiny Context gates. Sample evidence does not prove full population unless AC allows. Manual edits under derived/** are not authority. Local audit cannot mark final completion. Do not claim full implementation while Context Delta is required but Context is not updated, or while Source-to-Context Coverage / Context-to-Implementation Binding has unresolved required gaps.
 
 Completion:

package/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md

@@ -37,11 +37,13 @@ Implementation advances through coherent slices. Each slice selects related PI /
 
 Evidence is canonical state, not prose. Every proof record enters `task-state.evidence[]` with evidence id, slice id, type, command or artifact paths, command exit code when applicable, `proves`, `does_not_prove`, freshness, redaction, reviewability / reproduction data and, for machine-verifiable layers, an `assertion_result`. Evidence must be fresh, reviewable and free of secrets, raw credentials, tokens, cookies and long raw payloads.
 
-Machine-verifiable layers such as `ui_browser`, `api_schema`, `runtime`, `worker_runtime`, `data_artifact`, `integration`, `security_redaction`, `test`, `all_provider_all_runner` and `cleanup_stale_scan` are not complete from descriptions, screenshots, final cards, validator passes, matrix rows or verdict rows. They require `assertion_result.schema_version=assertion-result-v1`, `assertion_result.status=passed`, assertion exit code `0`, command exit code `0` when present, target AC/layer coverage, passed positive and negative assertions and reviewable artifacts. UI/browser layers also require owner surface, route/path, user action, browser/playwright/UI assertion evidence and a passed `negative_evidence_scan`.
+Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; legacy aliases map `runtime -> worker_runtime`, `browser -> ui_browser`, `api -> api_schema`, `data -> data_artifact` and `security -> security_redaction`. `code` cannot complete a machine-backed AC by itself. Machine-verifiable layers are not complete from descriptions, screenshots, final cards, validator passes, matrix rows or verdict rows. They require `assertion_result.schema_version=assertion-result-v1`, `assertion_result.status=passed`, assertion exit code `0`, command exit code `0` when present, target AC/layer coverage, passed positive and negative assertions and reviewable artifacts. UI/browser layers also require owner surface, route/path, user action, browser/playwright/UI assertion evidence and a passed `negative_evidence_scan` with matching target proof layers and checked invalid completion signals.
+
+Strict V2 source fields are canonical. Product Source must carry Scope Fit, owner, primary capability and assertion policy fields. PI items must carry owner boundary, primary capability path, trigger/state/observable contracts, assertion support, required assertion commands and invalid implementation shortcuts. ACs must carry assertion command, artifacts, positive/negative assertions, machine-blocking flag, invalid completion signals and assertion-result requirement. Unknown, duplicate, table or missing canonical fields block compile; the workflow must not generate, infer, rewrite or repair the Technical Realization Plan or Acceptance Checklist.
 
 ## Derived Views
 
-`derived/**` contains generated reading views only: local audit, plan-conformance matrix, final acceptance verdict, progress ledger, evidence index, context alignment and final summary. Matrix and verdict views may summarize `assertion_status`, blocking assertion failures and negative evidence findings, but they never replace assertion execution and never rewrite Product / Architecture Source, Technical Realization Plan, Acceptance Checklist or `task-state.json`.
+`derived/**` contains generated reading views only: local audit, plan-conformance matrix, final acceptance verdict, progress ledger, evidence index (`md` and `json`), context alignment and final summary. Matrix, verdict and evidence-index views may summarize `assertion_status`, blocking assertion failures and negative evidence findings, but they never replace assertion execution and never rewrite Product / Architecture Source, Technical Realization Plan, Acceptance Checklist or `task-state.json`.
 
 ## Gates
 
@@ -306,6 +308,8 @@ does_not_prove
 freshness
 redaction
 reviewability / reproduction_steps
+assertion_result for machine-verifiable layers
+negative_evidence_scan with target_proof_layers where invalid completion signals must be ruled out
 ```
 
 `proves` and `does_not_prove` are both required because evidence must say what it proves and what it does not prove. This prevents samples, passing tests, screenshots, mocks or local audit text from being reused as full acceptance.
@@ -331,6 +335,7 @@ derived/local-audit.md
 derived/plan-conformance-matrix.md
 derived/final-acceptance-verdict.md
 derived/progress-ledger.md
+derived/evidence-index.json
 derived/evidence-index.md
 derived/context-alignment.md
 derived/final-summary.md

package/dist/lib/superpowers-task-assertion-normalizers.js

@@ -1,3 +1,4 @@
+import { normalizeProofLayerId } from "./superpowers-task-fields.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
 export function normalizeAssertionResult(value) {
     if (!isRecord(value)) {
@@ -9,7 +10,7 @@ export function normalizeAssertionResult(value) {
         runner: String(value.runner ?? ""),
         exit_code: numberValue(value.exit_code),
         target_ac_ids: stringArray(value.target_ac_ids),
-        target_proof_layers: stringArray(value.target_proof_layers),
+        target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
         owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
         route: value.route === undefined ? undefined : String(value.route),
         action: value.action === undefined ? undefined : String(value.action),
@@ -26,6 +27,8 @@ export function normalizeNegativeEvidenceScan(value) {
         schema_version: String(value.schema_version ?? ""),
         status: String(value.status ?? ""),
         target_ac_ids: stringArray(value.target_ac_ids),
+        target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
+        invalid_completion_signals_checked: stringArray(value.invalid_completion_signals_checked),
         owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
         route: value.route === undefined ? undefined : String(value.route),
         forbidden_findings: findingArray(value.forbidden_findings),

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

@@ -1,16 +1,6 @@
+import { MACHINE_VERIFIABLE_LAYER_NAMES, normalizeProofLayerId, normalizeProofLayerName } from "./superpowers-task-fields.js";
 export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
-export const MACHINE_VERIFIABLE_PROOF_LAYERS = new Set([
-    "ui_browser",
-    "api_schema",
-    "runtime",
-    "worker_runtime",
-    "data_artifact",
-    "integration",
-    "security_redaction",
-    "test",
-    "all_provider_all_runner",
-    "cleanup_stale_scan"
-]);
+export const MACHINE_VERIFIABLE_PROOF_LAYERS = new Set(MACHINE_VERIFIABLE_LAYER_NAMES);
 export const UI_BROWSER_ASSERTION_TYPES = new Set(["browser_assertion", "playwright_assertion", "ui_browser_assertion"]);
 const DEFAULT_UI_FORBIDDEN_FINAL_STATES = ["未验证", "不可用", "暂不可用", "页面无明显变化"];
 const GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS = [
@@ -33,7 +23,8 @@ const GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS = [
     /\bsample[-_ ]?for[-_ ]?full[-_ ]?population\b/i
 ];
 export function proofLayerName(layerId) {
-    return layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+    return normalizeProofLayerName(raw);
 }
 export function proofLayerAcId(layerId) {
     return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
@@ -139,7 +130,9 @@ export function evaluateAssertionEvidence(evidence, layerId) {
     if (!assertion.target_ac_ids.includes(acId)) {
         failures.push(`${label} assertion target ACs ${assertion.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
     }
-    if (!assertion.target_proof_layers.includes(layerId) && !assertion.target_proof_layers.includes(layerName)) {
+    const assertionTargetLayers = assertion.target_proof_layers.map(normalizeProofLayerId);
+    const normalizedLayerId = normalizeProofLayerId(layerId);
+    if (!assertionTargetLayers.includes(normalizedLayerId) && !assertionTargetLayers.includes(layerName)) {
         failures.push(`${label} assertion target_proof_layers ${assertion.target_proof_layers.join(", ") || "(none)"} do not include ${layerId} or ${layerName}`);
     }
     failures.push(...checkAssertions(`${label} positive assertion`, assertion.positive_assertions));
@@ -205,6 +198,14 @@ export function evaluateNegativeEvidence(evidence, layerId) {
     if (!scan.target_ac_ids.includes(acId)) {
         findings.push(`${label} negative evidence scan target ACs ${scan.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
     }
+    const targetLayers = (scan.target_proof_layers ?? []).map(normalizeProofLayerId);
+    const normalizedLayerId = normalizeProofLayerId(layerId);
+    if (targetLayers.length === 0) {
+        findings.push(`${label} negative evidence scan target proof layers are missing; expected ${normalizedLayerId}`);
+    }
+    else if (!targetLayers.includes(normalizedLayerId) && !targetLayers.includes(proofLayerName(layerId))) {
+        findings.push(`${label} negative evidence scan target proof layers ${targetLayers.join(", ") || "(none)"} do not include ${normalizedLayerId}`);
+    }
     for (const finding of scan.forbidden_findings ?? []) {
         if (finding.status === "found") {
             findings.push(`${label} negative evidence found forbidden text ${finding.forbidden_text ?? finding.id}: ${finding.actual ?? ""}`.trim());
@@ -226,7 +227,7 @@ function invalidEvidenceReason(evidence, layerName) {
     if (genericShortcut) {
         return `matches invalid completion evidence ${genericShortcut}`;
     }
-    if ((layerName === "runtime" || layerName === "worker_runtime" || layerName === "integration" || layerName === "ui_browser") && /\b(unit|mock|viewmodel)\b/i.test(evidence.type)) {
+    if ((layerName === "worker_runtime" || layerName === "integration" || layerName === "ui_browser") && /\b(unit|mock|viewmodel)\b/i.test(evidence.type)) {
         return "unit, mock or viewmodel evidence is auxiliary only for runtime, worker, integration and UI layers";
     }
     if (layerName === "ui_browser" && /\b(api|schema)\b/i.test(evidence.type)) {
@@ -235,7 +236,7 @@ function invalidEvidenceReason(evidence, layerName) {
     if (layerName === "ui_browser" && /^screenshot$/i.test(evidence.type)) {
         return "screenshot-only evidence cannot satisfy UI Path AC";
     }
-    if ((layerName === "runtime" || layerName === "worker_runtime" || layerName === "data_artifact" || layerName === "security_redaction") && /\b(ui|browser|playwright|screenshot)\b/i.test(evidence.type)) {
+    if ((layerName === "worker_runtime" || layerName === "data_artifact" || layerName === "security_redaction") && /\b(ui|browser|playwright|screenshot)\b/i.test(evidence.type)) {
         return "UI-only evidence cannot satisfy runtime, data or security proof layers";
     }
     return undefined;

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

@@ -1,23 +1,6 @@
 import { computeScopeConflicts } from "./superpowers-task-compile.js";
+import { ACCEPTANCE_SCOPES, isSelectedScopeFitSlice, PLAN_DELIVERY_SCOPES, PRODUCT_DELIVERY_SCOPES, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
-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"
-]);
 export function validateDeliveryContract(state, errors) {
     const product = state.delivery?.product_architecture_scope;
     if (!isRecord(product)) {
@@ -29,6 +12,17 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, "Product / Architecture Source representative_samples_validate", product.representative_samples_validate);
         requireArray(errors, "Product / Architecture Source representative_samples_do_not_validate", product.representative_samples_do_not_validate);
         requireArray(errors, "Product / Architecture Source out_of_scope_backlog", product.out_of_scope_backlog);
+        requireEnum(errors, "Product / Architecture Source scope_fit_decision", product.scope_fit_decision, SCOPE_FIT_DECISIONS);
+        requireText(errors, "Product / Architecture Source selected_scope_fit_slice", product.selected_scope_fit_slice);
+        if (typeof product.selected_scope_fit_slice === "string" && product.selected_scope_fit_slice && !isSelectedScopeFitSlice(product.selected_scope_fit_slice)) {
+            errors.push(`Product / Architecture Source selected_scope_fit_slice must be none or SFC-###: ${product.selected_scope_fit_slice}`);
+        }
+        requireText(errors, "Product / Architecture Source owner_boundary", product.owner_boundary);
+        requireText(errors, "Product / Architecture Source primary_capability_path", product.primary_capability_path);
+        requireArray(errors, "Product / Architecture Source non_completing_outcomes", product.non_completing_outcomes);
+        requireText(errors, "Product / Architecture Source assertion_policy", product.assertion_policy);
+        requireText(errors, "Product / Architecture Source source_authority", product.source_authority);
+        requireText(errors, "Product / Architecture Source product_goal", product.product_goal);
     }
     for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
         requireEnum(errors, `${planId} delivery_scope`, item.delivery_scope, PLAN_DELIVERY_SCOPES);
@@ -36,6 +30,15 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, `${planId} representative_samples`, item.representative_samples);
         requireText(errors, `${planId} full_population_boundary`, item.full_population_boundary);
         requireArray(errors, `${planId} non_required_population`, item.non_required_population);
+        requireText(errors, `${planId} owner_boundary`, item.owner_boundary);
+        requireText(errors, `${planId} primary_capability_path`, item.primary_capability_path);
+        requireText(errors, `${planId} trigger_contract`, item.trigger_contract);
+        requireText(errors, `${planId} state_transition_contract`, item.state_transition_contract);
+        requireText(errors, `${planId} observable_result_contract`, item.observable_result_contract);
+        requireText(errors, `${planId} assertion_support`, item.assertion_support);
+        requireArray(errors, `${planId} required_assertion_commands`, item.required_assertion_commands);
+        requireArray(errors, `${planId} invalid_implementation_shortcuts`, item.invalid_implementation_shortcuts);
+        requireArray(errors, `${planId} implementation_paths`, item.implementation_paths);
     }
     for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
         requireEnum(errors, `${acId} acceptance_scope`, ac.acceptance_scope, ACCEPTANCE_SCOPES);
@@ -43,6 +46,15 @@ export function validateDeliveryContract(state, errors) {
         requireArray(errors, `${acId} ac_does_not_validate`, ac.ac_does_not_validate);
         requireText(errors, `${acId} sample_boundary`, ac.sample_boundary);
         requireBoolean(errors, `${acId} full_population_required`, ac.full_population_required);
+        requireArray(errors, `${acId} related_plan_items`, ac.related_plan_items);
+        requireArray(errors, `${acId} required_proof_layers`, ac.required_proof_layers);
+        requireText(errors, `${acId} assertion_command`, ac.assertion_command);
+        requireArray(errors, `${acId} assertion_artifacts`, ac.assertion_artifacts);
+        requireArray(errors, `${acId} positive_assertions`, ac.positive_assertions);
+        requireArray(errors, `${acId} negative_assertions`, ac.negative_assertions);
+        requireBoolean(errors, `${acId} machine_blocking`, ac.machine_blocking);
+        requireArray(errors, `${acId} invalid_completion_signals`, ac.invalid_completion_signals);
+        requireBoolean(errors, `${acId} assertion_result_required`, ac.assertion_result_required);
     }
 }
 export function validateScopeConflicts(state, errors) {

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

@@ -11,3 +11,4 @@ export declare function deriveObjects(state: SuperpowersTaskState): {
     progress: Record<string, unknown>;
 };
 export declare function derivedMatchesState(workdir: string, state: SuperpowersTaskState): Promise<string[]>;
+export declare function deriveEvidenceIndex(state: SuperpowersTaskState): Record<string, unknown>;

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

@@ -11,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));
@@ -38,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,
@@ -82,6 +92,13 @@ 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),
@@ -90,7 +107,7 @@ export function deriveObjects(state) {
             assertion_status: assertionSummary.assertion_status,
             blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
             negative_evidence_findings: assertionSummary.negative_evidence_findings,
-            invalid_completion_signals: invalidCompletionSignals,
+            invalid_evidence_findings: invalidCompletionSignals,
             required_next_evidence: requiredNextEvidence(missingLayers, assertionSummary),
             contradictions: [],
             context_fact_refs: [],
@@ -144,8 +161,45 @@ export async function derivedMatchesState(workdir, state) {
     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))) {
@@ -238,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 {};