project-tiny-context-harness 0.2.78 → 0.2.79

package/README.md

@@ -96,7 +96,9 @@ The ordinary long-task path uses `/normal-long-task`. It is the non-Superpowers
 
 The Superpowers long-task path uses `/superpowers-long-task` when three inputs already exist: `Product / Architecture Source`, `Technical Realization Plan` and `Acceptance Checklist`. The product/architecture source preserves original intent and scope; the technical realization plan is the execution blueprint and plan-conformance source; the checklist is the acceptance authority. The Skill does not perform complexity routing: invocation means Superpowers long-task execution was already selected. Two-document compatibility is allowed only when the first document clearly contains both product/architecture source and technical realization plan sections. If only a product/architecture source and checklist exist, the Skill stops with a Missing Fields Report for a missing `Technical Realization Plan` instead of generating one. The technical realization plan must already satisfy the required Superpowers-ready Markdown implementation plan fields; if it does, the prompt binds it directly to Superpowers execution rather than regenerating the plan, and if it does not, the Skill stops before generating a prompt. The prompt is Tiny Context's adapter layer, aligned to the official Superpowers skills while remaining a Tiny Context-owned adapter rather than an upstream-owned schema. It may wrap Superpowers with Tiny Context authority, conformance and acceptance gates, but it must not redefine or fork Superpowers execution mechanics. It requires parent-level `Product Context Delta` and `Technical Context Delta` checks before implementation and uses a canonical state kernel under `tmp/ty-context/plan-acceptance/<plan-slug>/`: `task-state.json` is the only execution state source, `events.ndjson` is append-only and `derived/**` contains generated local audit, plan-conformance matrix, final acceptance verdict, progress ledger, evidence index, context alignment and final summary views. Complete acceptance rows are externally reviewable evidence claims derived from `task-state.evidence[]`: the checklist supplies the proof chain, fresh reviewable evidence must satisfy every required layer, and material drift, missing layers or unapproved sibling substitution prevent `complete`. Goal-mode wording separates `audit_task_complete`, `acceptance_target_status` and computed `product_goal_complete`: implementation / execution goals complete only when `ty-context superpowers final-gate` computes `product_goal_complete=true`; read-only audit goals may end at `audit_task_complete`, but a non-accepted verdict says `Audit workflow completed; acceptance target not complete.` and does not use unqualified `Goal achieved` or `update_goal(status="complete")` as acceptance of the user target.
 
-The three inputs also carry capability-first delivery boundaries. Product / Architecture Source declares `delivery_scope`, `full_population_required`, samples that validate the claim, samples that do not validate it and out-of-scope backlog. Each Technical Realization Plan item declares delivery scope, capability target, representative samples, full-population boundary and non-required population. Each Acceptance Checklist item declares acceptance scope, what it validates and does not validate, sample boundary and full-population requirement. `scope_conflict_requires_decision` blocks completion when source, plan and checklist disagree between system capability build, representative sample validation and full-population operation. Sample evidence or framework-only implementation cannot prove all-provider, all-interface, all-platform or full-population completion unless the AC explicitly allows it; when full population is not explicitly required, generated views report it as `not_in_scope`.
+The three inputs also carry capability-first delivery boundaries. Product / Architecture Source declares `delivery_scope`, `full_population_required`, samples that validate the claim, samples that do not validate it and out-of-scope backlog. Each Technical Realization Plan item declares delivery scope, capability target, representative samples, full-population boundary and non-required population. Each Acceptance Checklist item declares acceptance scope, what it validates and does not validate, sample boundary and full-population requirement. `scope_conflict_requires_decision` blocks completion when source, plan and checklist disagree between system capability build, representative sample validation and full-population operation. Sample evidence or framework-only implementation cannot prove all-provider, all-interface, all-platform or full-population completion unless the AC explicitly allows it; when full population is not explicitly required, generated views report it as `not_in_scope`.
+
+`ty-context superpowers 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.
 
 For non-trivial Superpowers slices, the generated prompt requires a structured `slice-delta.json`. The executor applies it with `ty-context superpowers apply-slice-delta <workdir> <slice-delta.json>`, then runs `ty-context superpowers derive` and `ty-context superpowers 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 and reviewability. 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 prompt 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.
 
@@ -159,7 +161,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.78.tgz
+npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.79.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.78.tgz
+npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.2.79.tgz
 npx --no-install ty-context init --adopt
 make validate-context
 ```
@@ -140,7 +140,9 @@ The ordinary long-task path uses `/normal-long-task`. It is the non-Superpowers
 
 The Superpowers long-task path uses `/superpowers-long-task` when three inputs already exist: `Product / Architecture Source`, `Technical Realization Plan` and `Acceptance Checklist`. The product/architecture source preserves original intent and scope; the technical realization plan is the execution blueprint and plan-conformance source; the checklist is the acceptance authority. The Skill does not perform complexity routing: invocation means Superpowers long-task execution was already selected. Two-document compatibility is allowed only when the first document clearly contains both product/architecture source and technical realization plan sections. If only a product/architecture source and checklist exist, the Skill stops with a Missing Fields Report for a missing `Technical Realization Plan` instead of generating one. The technical realization plan must already satisfy the required Superpowers-ready Markdown implementation plan fields; if it does, the prompt binds it directly to Superpowers execution rather than regenerating the plan, and if it does not, the Skill stops before generating a prompt. The prompt is Tiny Context's adapter layer, aligned to the official Superpowers skills while remaining a Tiny Context-owned adapter rather than an upstream-owned schema. It may wrap Superpowers with Tiny Context authority, conformance and acceptance gates, but it must not redefine or fork Superpowers execution mechanics. It requires parent-level `Product Context Delta` and `Technical Context Delta` checks before implementation and uses a canonical state kernel under `tmp/ty-context/plan-acceptance/<plan-slug>/`: `task-state.json` is the only execution state source, `events.ndjson` is append-only and `derived/**` contains generated local audit, plan-conformance matrix, final acceptance verdict, progress ledger, evidence index, context alignment and final summary views. Complete acceptance rows are externally reviewable evidence claims derived from `task-state.evidence[]`: the checklist supplies the proof chain, fresh reviewable evidence must satisfy every required layer, and material drift, missing layers or unapproved sibling substitution prevent `complete`. Goal-mode wording separates `audit_task_complete`, `acceptance_target_status` and computed `product_goal_complete`: implementation / execution goals complete only when `ty-context superpowers final-gate` computes `product_goal_complete=true`; read-only audit goals may end at `audit_task_complete`, but a non-accepted verdict says `Audit workflow completed; acceptance target not complete.` and does not use unqualified `Goal achieved` or `update_goal(status="complete")` as acceptance of the user target.
 
-The three inputs also carry capability-first delivery boundaries. Product / Architecture Source declares `delivery_scope`, `full_population_required`, samples that validate the claim, samples that do not validate it and out-of-scope backlog. Each Technical Realization Plan item declares delivery scope, capability target, representative samples, full-population boundary and non-required population. Each Acceptance Checklist item declares acceptance scope, what it validates and does not validate, sample boundary and full-population requirement. `scope_conflict_requires_decision` blocks completion when source, plan and checklist disagree between system capability build, representative sample validation and full-population operation. Sample evidence or framework-only implementation cannot prove all-provider, all-interface, all-platform or full-population completion unless the AC explicitly allows it; when full population is not explicitly required, generated views report it as `not_in_scope`.
+The three inputs also carry capability-first delivery boundaries. Product / Architecture Source declares `delivery_scope`, `full_population_required`, samples that validate the claim, samples that do not validate it and out-of-scope backlog. Each Technical Realization Plan item declares delivery scope, capability target, representative samples, full-population boundary and non-required population. Each Acceptance Checklist item declares acceptance scope, what it validates and does not validate, sample boundary and full-population requirement. `scope_conflict_requires_decision` blocks completion when source, plan and checklist disagree between system capability build, representative sample validation and full-population operation. Sample evidence or framework-only implementation cannot prove all-provider, all-interface, all-platform or full-population completion unless the AC explicitly allows it; when full population is not explicitly required, generated views report it as `not_in_scope`.
+
+`ty-context superpowers 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.
 
 For non-trivial Superpowers slices, the generated prompt requires a structured `slice-delta.json`. The executor applies it with `ty-context superpowers apply-slice-delta <workdir> <slice-delta.json>`, then runs `ty-context superpowers derive` and `ty-context superpowers 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 and reviewability. 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 prompt 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.
 

package/assets/README.zh-CN.md

@@ -56,7 +56,9 @@ Tiny Context 有两个核心层。Minimal Context 是长期事实源层：说明
 
 Superpowers 长程任务 Skill 用 `/superpowers-long-task`。如果下一步明确要 Superpowers 目标模式文本，推荐在三份输入都存在后调用：`Product / Architecture Source`（产品/架构原始意图源）、`Technical Realization Plan`（具体技术实现方案）和 `Acceptance Checklist`（验收清单）。它不做复杂度分流；调用它表示上游已经决定使用 Superpowers 长程执行。它不要求先跑 `/normal-long-task`，但也不会把产品方案现场翻译成技术方案；如果只有产品/架构方案和验收清单，Skill 会用 Missing Fields Report 停止并报告缺少 `Technical Realization Plan`。两份输入兼容只限第一份明确包含产品/架构源和技术实现方案两个章节。`Technical Realization Plan` 必须已经满足 Superpowers-ready Markdown implementation plan 的必填字段；满足时它跳过方案生成，直接绑定 Superpowers 执行，不满足时直接中断并报告缺失字段，不生成 prompt。它显式输出 `Superpowers 输入包` 和执行绑定，让未来 executor 清楚哪些输入进入 parent-level Product Context Delta / Technical Context Delta、slice-level new durable fact check、subagent/inline execution、TDD、`superpowers:verification-before-completion`、canonical `task-state.json`、append-only `events.ndjson`、generated `derived/**` views、proof-chain evidence 和 optional auditor review。这个 prompt 是面向 Superpowers workflow 的 Tiny Context 适配层，对齐官方 Superpowers skills，但不是上游维护的 schema；它可以在 Superpowers 外层增加 Tiny Context 的权威、对图纸和验收门禁，但不能重新定义、重复或分叉 Superpowers 执行机制。如果未来改动让 Tiny Context 新增步骤和官方 Superpowers 职责冲突、重复或覆盖，应停止修改并提示边界冲突，不要静默合并两套流程。它不生成技术方案或验收清单、不执行计划、不证明完成，也不会把临时 state、derived views 或 verdict 注册成 `project_context/**`。三输入是上游权威，state / derived views / validator / auditor 不能改写它们。`task-state.json` 是唯一执行状态源，`events.ndjson` 追加记录状态变更，`derived/**` 只生成 local audit、plan-conformance matrix、final acceptance verdict、progress ledger、evidence index、context alignment 和 final summary 等阅读视图。完整验收行按外部审计证据处理：proof chain 来自验收清单，fresh evidence 必须通过 `task-state.evidence[]` 满足每个 required layer，存在 material drift、缺 required layer 或未批准 sibling substitution 时不能标 `complete`。Goal mode 表述必须区分 `audit_task_complete`、`acceptance_target_status` 和 computed `product_goal_complete`：实现/执行目标只在 `ty-context superpowers final-gate` 计算出 `product_goal_complete=true` 时完成；只读审计目标可在 `audit_task_complete` 时结束，但 verdict 不是 accepted/complete 时，回复写 `Audit workflow completed; acceptance target not complete.`，不能用未限定的 `Goal achieved` 或 `update_goal(status="complete")` 表示用户验收目标已完成。
 
-三份输入还必须承载 capability-first delivery 边界。Product / Architecture Source 声明 `delivery_scope`、`full_population_required`、哪些 representative samples 能验证 claim、哪些不能验证、以及 `out_of_scope_backlog`。每个 Technical Realization Plan item 声明 delivery scope、capability target、representative samples、full-population boundary 和 non-required population。每个 Acceptance Checklist item 声明 acceptance scope、`ac_validates`、`ac_does_not_validate`、sample boundary 和 full-population requirement。source / plan / checklist 在 system capability build、representative sample validation、full population operation 之间冲突时，`scope_conflict_requires_decision` 阻塞完成。sample evidence 或 framework-only implementation 不能证明 all-provider、all-interface、all-platform 或 full-population 完成，除非 AC 明确批准；未显式要求 full population 时，generated views 必须报告 `not_in_scope`。
+三份输入还必须承载 capability-first delivery 边界。Product / Architecture Source 声明 `delivery_scope`、`full_population_required`、哪些 representative samples 能验证 claim、哪些不能验证、以及 `out_of_scope_backlog`。每个 Technical Realization Plan item 声明 delivery scope、capability target、representative samples、full-population boundary 和 non-required population。每个 Acceptance Checklist item 声明 acceptance scope、`ac_validates`、`ac_does_not_validate`、sample boundary 和 full-population requirement。source / plan / checklist 在 system capability build、representative sample validation、full population operation 之间冲突时，`scope_conflict_requires_decision` 阻塞完成。sample evidence 或 framework-only implementation 不能证明 all-provider、all-interface、all-platform 或 full-population 完成，除非 AC 明确批准；未显式要求 full population 时，generated views 必须报告 `not_in_scope`。
+
+`ty-context superpowers 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 阶段带文件和行号报错。
 
 对于非平凡 slice，生成的 Superpowers prompt 要求使用结构化 `slice-delta.json`。executor 通过 `ty-context superpowers apply-slice-delta <workdir> <slice-delta.json>` 应用 delta，然后运行 `ty-context superpowers derive` 和 `ty-context superpowers 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。
 

package/assets/skills/superpowers-long-task/SKILL.md

@@ -65,15 +65,24 @@ The input must fully expose these fields:
 - explicitly non-completing shortcuts, such as local-only enhancement, old page continuing to own a moved responsibility, sampled path, plan-only work or test-only patch.
 - full acceptance checklist path or pasted text.
 - acceptance items or AC IDs.
-- each Acceptance Checklist item delivery fields: `acceptance_scope` (`system_capability_build`, `representative_sample_validation`, `full_population_operation` or `full_population_not_required`), `ac_validates`, `ac_does_not_validate`, `sample_boundary` and `full_population_required`.
-- required evidence and verification method per AC.
-- required tests or explicit no-test scope.
-- valid and invalid evidence rules.
-- Completion State Machine rules.
-- UI-Facing Gate rules when any AC touches UI.
-- hard blockers or an explicit no-blocker statement.
-
-If any of these are missing required fields, stop. Do not generate the Superpowers target-mode prompt. Report whether each missing field belongs in Product / Architecture Source, Technical Realization Plan, Acceptance Checklist, blocker section or Context reference. If the user supplied only a product/architecture source plus checklist, report missing Technical Realization Plan.
+- each Acceptance Checklist item delivery fields: `acceptance_scope` (`system_capability_build`, `representative_sample_validation`, `full_population_operation` or `full_population_not_required`), `ac_validates`, `ac_does_not_validate`, `sample_boundary` and `full_population_required`.
+- required evidence and verification method per AC.
+- required tests or explicit no-test scope.
+- valid and invalid evidence rules.
+- Completion State Machine rules.
+- UI-Facing Gate rules when any AC touches UI.
+- hard blockers or an explicit no-blocker statement.
+
+Strict input grammar:
+
+- Product / Architecture Source is a single document-level object. Its delivery fields must use fixed `key: value`, indented-list or `key: |` syntax.
+- Technical Realization Plan items are definitions only when written as Markdown headings such as `## PI-001: ...` or `### PI-001: ...`.
+- Acceptance Checklist items are definitions only when written as Markdown headings such as `## AC-001: ...` or `### AC-001: ...`.
+- PI/AC fields are read only from the heading section until the next same-or-higher heading, and must use fixed `key: value`, indented-list or `key: |` syntax.
+- Plain prose, mapping previews, tables, `related_acs`, `related_plan_items` and ordinary lists that mention `PI-001` or `AC-001` are references, not definitions.
+- Legacy list-style definitions such as `- PI-001: ...` or `- AC-001: ...` followed by delivery fields are invalid. Stop and report the source file/line instead of accepting or repairing them.
+
+If any of these are missing required fields, stop. Do not generate the Superpowers target-mode prompt. Report whether each missing field belongs in Product / Architecture Source, Technical Realization Plan, Acceptance Checklist, blocker section or Context reference. If the user supplied only a product/architecture source plus checklist, report missing Technical Realization Plan.
 
 When blocked by missing input, return a structured Missing Fields Report with:
 
@@ -460,8 +469,9 @@ The local audit is process recovery only. It must not contain completion judgmen
 - The prompt must state that Tiny Context gates wrap Superpowers for source authority, conformance and acceptance, but do not redefine or fork Superpowers execution mechanics.
 - The prompt must identify the Superpowers workdir, Product / Architecture Source, Technical Realization Plan, Acceptance Checklist, `task-state.json`, `events.ndjson` and generated `derived/**` paths at the top.
 - The prompt must state that the Technical Realization Plan controls plan conformance, the Product / Architecture Source prevents scope shrinkage and the full checklist controls acceptance.
-- The prompt must state the capability-first delivery boundary: source/plan/AC fields distinguish system capability build, representative sample validation, full population operation and out-of-scope backlog; `scope_conflict_requires_decision` blocks completion; samples or framework-only evidence cannot prove full-population completion unless the AC explicitly allows it.
-- The prompt must state the Authority Model and that state/derived views/validator/auditor artifacts cannot rewrite source, plan or checklist authority.
+- The prompt must state the capability-first delivery boundary: source/plan/AC fields distinguish system capability build, representative sample validation, full population operation and out-of-scope backlog; `scope_conflict_requires_decision` blocks completion; samples or framework-only evidence cannot prove full-population completion unless the AC explicitly allows it.
+- The prompt must state that compile has a strict input grammar: PI and AC definitions are heading sections only, while ordinary PI/AC mentions in prose, lists, tables, mapping previews or `related_*` fields are references.
+- The prompt must state the Authority Model and that state/derived views/validator/auditor artifacts cannot rewrite source, plan or checklist authority.
 - The prompt must require Product Context Delta and Technical Context Delta evaluation before implementation.
 - The prompt must use parent-level Context Delta plus slice-level new durable fact checks.
 - The prompt must state that Evidence Ledger / proof index is a generated execution index, but complete rows and ACs require evidence traceability to fresh evidence through `task-state.evidence[]` and optional `evidence_id`.
@@ -538,8 +548,8 @@ Tiny Context adapter for Superpowers; aligned to official skills, not upstream s
 Superpowers input packet:
 - Source guards scope; plan controls matrix; checklist controls verdict; task-state is execution state and derived views are generated only.
 - Read Context/tests first; map gaps to test/API/UI/runtime/browser evidence.
-Authority: source/plan/checklist own scope/plan/acceptance; state/derived/validator/auditor cannot rewrite. Complete rows need task-state.evidence[]/evidence_id. Goal mode: implementation/execution complete only when final-gate computes product_goal_complete=true. Read-only audit may end at audit_task_complete; non-accepted verdict says "Audit workflow completed; acceptance target not complete."; no bare "Goal achieved" or update_goal complete.
-Delivery scope: source/plan/AC distinguish capability, samples, full population and backlog; scope_conflict_requires_decision blocks. Samples/framework-only evidence cannot prove full population unless AC allows.
+Authority: source/plan/checklist own scope/plan/acceptance; state/derived/validator/auditor cannot rewrite. Complete rows need task-state.evidence[]/evidence_id. Goal mode: implementation/execution complete only when final-gate computes product_goal_complete=true. Read-only audit may end at audit_task_complete; non-accepted verdict says "Audit workflow completed; acceptance target not complete."; no bare "Goal achieved" or update_goal complete.
+Delivery scope: source/plan/AC distinguish capability, samples, full population and backlog; scope_conflict_requires_decision blocks. Samples/framework-only evidence cannot prove full population unless AC allows.
 
 Execution order:
 1. Read inputs/Context. Task Contract: Product Context Delta none|required; Technical Context Delta none|required; any required -> Context Delta required. Not a validator gate.
@@ -553,8 +563,8 @@ Execution order:
 9. Acceptance Evidence Gate: checklist controls verdict; each AC records proof chain, fresh evidence, missing layers, drift and substitution. Current contradictions override old passes.
 10. Final gate: derive all -> verification-before-completion -> validate-superpowers-state -> validate-plan-acceptance -> auditor -> stale/overclaim scan -> superpowers final-gate. Auditor summary is not proof; rerun derive plus both validators after changes.
 
-Autonomy/blockers: self-serve under current permissions. Open app/browser/CLI/settings and reuse sessions/auth/helpers. Try authorized sudo/gsudo/admin. Pause only after missing login/session expiry/denied permission/MFA/approval; give page/system/field.
-Never complete on: audit/summary/final card, code/plan-only, partial/stale/sampled evidence, framework-only population proof, sample-as-full, missing layer, material drift, unapproved substitution/scope narrowing, unexercised runtime, unaccepted artifact, API/UI not reflected, missing validator pass or current API/UI/data/runtime/test contradiction.
+Autonomy/blockers: self-serve under current permissions. Open app/browser/CLI/settings and reuse sessions/auth/helpers. Try authorized sudo/gsudo/admin. Pause only after missing login/session expiry/denied permission/MFA/approval; give page/system/field.
+Never complete on: audit/summary/final card, code/plan-only, partial/stale/sampled evidence, framework-only population proof, sample-as-full, missing layer, material drift, unapproved substitution/scope narrowing, unexercised runtime, unaccepted artifact, API/UI not reflected, missing validator pass or current API/UI/data/runtime/test contradiction.
 ```
 
 Before final response, check the prompt length. If it exceeds 3850 characters, tighten wording while preserving paths, input roles, official Superpowers skill names, Product Context Delta, Technical Context Delta, plan-conformance matrix, final verdict, state machine, UI gate, blockers and invalid evidence.

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

@@ -2,8 +2,7 @@ import path from "node:path";
 import { readText } from "./fs.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState, refreshSourceHashes } from "./superpowers-task-state.js";
-import { asStringArray } from "./superpowers-task-state-schema.js";
-const DEFAULT_LAYERS = ["code", "test"];
+import { DEFAULT_LAYERS, parseAcceptanceCriteria, parsePlanItems, parseProductArchitectureScope } from "./superpowers-task-source-compile.js";
 export async function compileSuperpowersTask(workdir) {
     const state = await loadSuperpowersState(workdir);
     await refreshSourceHashes(workdir, state);
@@ -11,11 +10,11 @@ export async function compileSuperpowersTask(workdir) {
     const technicalPlan = await readText(path.join(workdir, state.sources.technical_realization_plan.path));
     const checklist = await readText(path.join(workdir, state.sources.acceptance_checklist.path));
     state.delivery = {
-        product_architecture_scope: parseProductArchitectureScope(productSource),
+        product_architecture_scope: parseProductArchitectureScope(productSource, state.sources.product_architecture_source.path),
         scope_conflicts: []
     };
-    const planItems = parsePlanItems(technicalPlan);
-    const acceptanceCriteria = parseAcceptanceCriteria(checklist);
+    const planItems = parsePlanItems(technicalPlan, state.sources.technical_realization_plan.path);
+    const acceptanceCriteria = parseAcceptanceCriteria(checklist, state.sources.acceptance_checklist.path);
     const acIds = Object.keys(acceptanceCriteria);
     for (const [planId, item] of Object.entries(planItems)) {
         if (item.related_acs.length === 0) {
@@ -47,90 +46,6 @@ export async function compileSuperpowersTask(workdir) {
     });
     return state;
 }
-function parseProductArchitectureScope(content) {
-    return {
-        delivery_scope: fieldText(content, "delivery_scope"),
-        full_population_required: fieldBoolean(content, "full_population_required"),
-        representative_samples_validate: field(content, "representative_samples_validate"),
-        representative_samples_do_not_validate: field(content, "representative_samples_do_not_validate"),
-        out_of_scope_backlog: field(content, "out_of_scope_backlog")
-    };
-}
-function parsePlanItems(content) {
-    const items = {};
-    const matches = [...content.matchAll(/\b(PI-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
-    for (const [index, match] of matches.entries()) {
-        const id = match[1].toUpperCase();
-        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
-        items[id] = {
-            requirement: cleanText(match[2]) || firstLine(block) || id,
-            delivery_scope: fieldText(block, "delivery_scope"),
-            capability_target: fieldText(block, "capability_target"),
-            representative_samples: field(block, "representative_samples"),
-            full_population_boundary: fieldText(block, "full_population_boundary"),
-            non_required_population: field(block, "non_required_population"),
-            owner_surfaces: field(block, "owner_surfaces"),
-            forbidden_surfaces: field(block, "forbidden_surfaces"),
-            implementation_paths: field(block, "implementation_paths"),
-            required_tests: field(block, "required_tests"),
-            status: "not_started",
-            related_acs: field(block, "related_acs").map((item) => item.toUpperCase()),
-            required_proof_layers: []
-        };
-    }
-    if (Object.keys(items).length === 0) {
-        items["PI-001"] = {
-            requirement: firstLine(content) || "Implement technical realization plan",
-            delivery_scope: "",
-            capability_target: "",
-            representative_samples: [],
-            full_population_boundary: "",
-            non_required_population: [],
-            owner_surfaces: [],
-            forbidden_surfaces: [],
-            implementation_paths: [],
-            required_tests: [],
-            status: "not_started",
-            related_acs: [],
-            required_proof_layers: []
-        };
-    }
-    return items;
-}
-function parseAcceptanceCriteria(content) {
-    const items = {};
-    const matches = [...content.matchAll(/\b(AC-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
-    for (const [index, match] of matches.entries()) {
-        const id = match[1].toUpperCase();
-        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
-        const layers = field(block, "required_proof_layers").map(normalizeLayer).filter(Boolean);
-        items[id] = {
-            scope: cleanText(match[2]) || firstLine(block) || id,
-            acceptance_scope: fieldText(block, "acceptance_scope"),
-            ac_validates: field(block, "ac_validates"),
-            ac_does_not_validate: field(block, "ac_does_not_validate"),
-            sample_boundary: fieldText(block, "sample_boundary"),
-            full_population_required: fieldBoolean(block, "full_population_required"),
-            related_plan_items: field(block, "related_plan_items").map((item) => item.toUpperCase()),
-            required_proof_layers: layers.length > 0 ? layers : DEFAULT_LAYERS,
-            status: "not_run"
-        };
-    }
-    if (Object.keys(items).length === 0) {
-        items["AC-001"] = {
-            scope: firstLine(content) || "Acceptance checklist item",
-            acceptance_scope: "",
-            ac_validates: [],
-            ac_does_not_validate: [],
-            sample_boundary: "",
-            full_population_required: null,
-            related_plan_items: [],
-            required_proof_layers: DEFAULT_LAYERS,
-            status: "not_run"
-        };
-    }
-    return items;
-}
 export function computeScopeConflicts(state) {
     const conflicts = [];
     const product = state.delivery?.product_architecture_scope;
@@ -187,37 +102,6 @@ function compileProgress(state) {
         }
     };
 }
-function blockAfter(content, start, end) {
-    return content.slice(start, end ?? content.length);
-}
-function field(block, name) {
-    const text = fieldText(block, name);
-    return text ? asStringArray(text) : [];
-}
-function fieldText(block, name) {
-    const pattern = new RegExp(`${name}\\s*:\\s*([^\\n]+)`, "i");
-    const match = pattern.exec(block);
-    return match ? cleanText(match[1]) : "";
-}
-function fieldBoolean(block, name) {
-    const value = fieldText(block, name).toLowerCase();
-    if (value === "true") {
-        return true;
-    }
-    if (value === "false") {
-        return false;
-    }
-    return null;
-}
-function normalizeLayer(value) {
-    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
-}
-function firstLine(content) {
-    return cleanText(content.split(/\r?\n/).find((line) => cleanText(line)) ?? "");
-}
-function cleanText(value) {
-    return value.replace(/^[-#*\s]+/, "").trim();
-}
 function unique(values) {
     return [...new Set(values.filter(Boolean))];
 }

package/dist/lib/superpowers-task-source-compile.d.ts

@@ -0,0 +1,5 @@
+import { type SuperpowersAcceptanceCriterion, type SuperpowersPlanItem, type SuperpowersProductArchitectureScope } from "./superpowers-task-state-schema.js";
+export declare const DEFAULT_LAYERS: string[];
+export declare function parseProductArchitectureScope(content: string, sourceFile: string): SuperpowersProductArchitectureScope;
+export declare function parsePlanItems(content: string, sourceFile: string): Record<string, SuperpowersPlanItem>;
+export declare function parseAcceptanceCriteria(content: string, sourceFile: string): Record<string, SuperpowersAcceptanceCriterion>;

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

@@ -0,0 +1,148 @@
+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"
+]);
+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"
+]);
+const ACCEPTANCE_FIELDS = new Set([
+    "acceptance_scope",
+    "ac_validates",
+    "ac_does_not_validate",
+    "sample_boundary",
+    "full_population_required",
+    "related_plan_items",
+    "required_proof_layers"
+]);
+export function parseProductArchitectureScope(content, sourceFile) {
+    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELDS);
+    const errors = [];
+    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)
+    };
+    throwCompileErrors(errors);
+    return scope;
+}
+export function parsePlanItems(content, sourceFile) {
+    const items = {};
+    const errors = [];
+    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELDS })) {
+        const fields = definition.fields;
+        items[definition.id] = {
+            requirement: definition.title,
+            source_file: definition.source_file,
+            source_start_line: definition.source_start_line,
+            source_end_line: definition.source_end_line,
+            delivery_scope: requireEnum(errors, definition.id, "delivery_scope", fields, PLAN_DELIVERY_SCOPES, sourceFile, definition.source_start_line),
+            capability_target: requireText(errors, definition.id, "capability_target", fields, sourceFile, definition.source_start_line),
+            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_surfaces: optionalArray(fields, "owner_surfaces"),
+            forbidden_surfaces: optionalArray(fields, "forbidden_surfaces"),
+            implementation_paths: optionalArray(fields, "implementation_paths"),
+            required_tests: optionalArray(fields, "required_tests"),
+            status: "not_started",
+            related_acs: optionalArray(fields, "related_acs").map((item) => item.toUpperCase()),
+            required_proof_layers: []
+        };
+    }
+    throwCompileErrors(errors);
+    return items;
+}
+export function parseAcceptanceCriteria(content, sourceFile) {
+    const items = {};
+    const errors = [];
+    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELDS })) {
+        const fields = definition.fields;
+        const layers = optionalArray(fields, "required_proof_layers").map(normalizeLayer).filter(Boolean);
+        items[definition.id] = {
+            scope: definition.title,
+            source_file: definition.source_file,
+            source_start_line: definition.source_start_line,
+            source_end_line: definition.source_end_line,
+            acceptance_scope: requireEnum(errors, definition.id, "acceptance_scope", fields, ACCEPTANCE_SCOPES, sourceFile, definition.source_start_line),
+            ac_validates: requireArray(errors, definition.id, "ac_validates", fields, sourceFile, definition.source_start_line),
+            ac_does_not_validate: requireArray(errors, definition.id, "ac_does_not_validate", fields, sourceFile, definition.source_start_line),
+            sample_boundary: requireText(errors, definition.id, "sample_boundary", fields, sourceFile, definition.source_start_line),
+            full_population_required: requireBoolean(errors, definition.id, "full_population_required", fields, sourceFile, definition.source_start_line),
+            related_plan_items: optionalArray(fields, "related_plan_items").map((item) => item.toUpperCase()),
+            required_proof_layers: layers.length > 0 ? layers : DEFAULT_LAYERS,
+            status: "not_run"
+        };
+    }
+    throwCompileErrors(errors);
+    return items;
+}
+function normalizeLayer(value) {
+    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
+}
+function requireEnum(errors, label, name, fields, allowed, sourceFile, fallbackLine) {
+    const value = fieldText(fields, name);
+    const line = fieldLine(fields, name) ?? fallbackLine;
+    if (!value) {
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        return "";
+    }
+    if (!allowed.has(value)) {
+        errors.push(`${label} invalid ${name}: ${value} at ${sourceFile}:${line}; allowed: ${[...allowed].join(", ")}`);
+    }
+    return value;
+}
+function requireText(errors, label, name, fields, sourceFile, fallbackLine) {
+    const value = fieldText(fields, name);
+    const line = fieldLine(fields, name) ?? fallbackLine;
+    if (!value) {
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+    }
+    return value;
+}
+function requireArray(errors, label, name, fields, sourceFile, fallbackLine) {
+    const line = fieldLine(fields, name) ?? fallbackLine;
+    if (!fields[name]) {
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        return [];
+    }
+    return fieldArray(fields, name);
+}
+function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
+    const line = fieldLine(fields, name) ?? fallbackLine;
+    if (!fields[name]) {
+        errors.push(`${label} missing ${name} at ${sourceFile}:${line}`);
+        return null;
+    }
+    const value = fieldBoolean(fields, name);
+    if (value === null) {
+        errors.push(`${label} invalid ${name}: ${fieldText(fields, name)} at ${sourceFile}:${line}; must be true or false`);
+    }
+    return value;
+}
+function optionalArray(fields, name) {
+    return fields[name] ? fieldArray(fields, name) : [];
+}
+function throwCompileErrors(errors) {
+    if (errors.length > 0) {
+        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
+    }
+}

package/dist/lib/superpowers-task-source-parser.d.ts

@@ -0,0 +1,23 @@
+export interface ParsedField {
+    value: string | string[];
+    line: number;
+}
+export interface ParsedDefinition {
+    id: string;
+    title: string;
+    fields: Record<string, ParsedField>;
+    source_file: string;
+    source_start_line: number;
+    source_end_line: number;
+}
+export interface DefinitionParseOptions {
+    kind: "PI" | "AC";
+    sourceFile: string;
+    allowedFields: Set<string>;
+}
+export declare function parseHeadingDefinitions(content: string, options: DefinitionParseOptions): ParsedDefinition[];
+export declare function parseDocumentFields(content: string, sourceFile: string, allowedFields: Set<string>): Record<string, ParsedField>;
+export declare function fieldText(fields: Record<string, ParsedField>, name: string): string;
+export declare function fieldArray(fields: Record<string, ParsedField>, name: string): string[];
+export declare function fieldBoolean(fields: Record<string, ParsedField>, name: string): boolean | null;
+export declare function fieldLine(fields: Record<string, ParsedField>, name: string): number | undefined;

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

@@ -0,0 +1,218 @@
+export function parseHeadingDefinitions(content, options) {
+    const lines = splitLines(content);
+    const errors = [];
+    rejectListStyleDefinitions(lines, options, errors);
+    const headings = findDefinitionHeadings(lines, options.kind);
+    const seen = new Map();
+    const definitions = [];
+    for (const heading of headings) {
+        const firstLine = seen.get(heading.id);
+        if (firstLine !== undefined) {
+            errors.push(`${heading.id} duplicate definition at ${options.sourceFile}:${firstLine} and ${options.sourceFile}:${heading.line}`);
+            continue;
+        }
+        seen.set(heading.id, heading.line);
+        const sourceEndLine = sectionEndLine(lines, heading.index, heading.level);
+        const section = lines.slice(heading.index, sourceEndLine);
+        definitions.push({
+            id: heading.id,
+            title: heading.title,
+            fields: parseFields(section, options.sourceFile, heading.line, options.allowedFields, errors),
+            source_file: options.sourceFile,
+            source_start_line: heading.line,
+            source_end_line: sourceEndLine
+        });
+    }
+    if (definitions.length === 0) {
+        errors.push(`${options.sourceFile} must define ${options.kind} items with Markdown headings like "## ${options.kind}-001: ..."`);
+    }
+    throwIfErrors(errors);
+    return definitions;
+}
+export function parseDocumentFields(content, sourceFile, allowedFields) {
+    const errors = [];
+    const fields = parseFields(splitLines(content), sourceFile, 1, allowedFields, errors);
+    throwIfErrors(errors);
+    return fields;
+}
+export function fieldText(fields, name) {
+    const field = fields[name];
+    if (!field) {
+        return "";
+    }
+    return Array.isArray(field.value) ? field.value.join("\n").trim() : field.value.trim();
+}
+export function fieldArray(fields, name) {
+    const field = fields[name];
+    if (!field) {
+        return [];
+    }
+    if (Array.isArray(field.value)) {
+        return field.value.flatMap(splitScalarArray).filter(Boolean);
+    }
+    return splitScalarArray(field.value);
+}
+export function fieldBoolean(fields, name) {
+    const value = fieldText(fields, name).toLowerCase();
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    return null;
+}
+export function fieldLine(fields, name) {
+    return fields[name]?.line;
+}
+function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
+    const fields = {};
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const lineNumber = startLine + index;
+        const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+        if (heading && allowedFields.has(heading[2].trim())) {
+            errors.push(`${sourceFile}:${lineNumber} field headings are not supported; use "${heading[2].trim()}: ..."`);
+            continue;
+        }
+        if (/^\s*\|/.test(line) && containsKnownField(line, allowedFields)) {
+            errors.push(`${sourceFile}:${lineNumber} table fields are not supported; use key: value fields`);
+            continue;
+        }
+        const match = /^([a-z][a-z0-9_]*)\s*:\s*(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const name = match[1];
+        if (!allowedFields.has(name)) {
+            if (name.includes("_")) {
+                errors.push(`${sourceFile}:${lineNumber} unknown field ${name}`);
+            }
+            continue;
+        }
+        if (fields[name]) {
+            errors.push(`${sourceFile}:${lineNumber} duplicate field ${name}`);
+            continue;
+        }
+        const parsed = parseFieldValue(lines, index, match[2], sourceFile, lineNumber, errors);
+        fields[name] = { value: parsed.value, line: lineNumber };
+        index = parsed.endIndex;
+    }
+    return fields;
+}
+function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
+    const trimmed = rest.trim();
+    if (trimmed === "|") {
+        const block = [];
+        let cursor = index + 1;
+        for (; cursor < lines.length; cursor++) {
+            const next = lines[cursor];
+            if (next.trim() && !/^\s/.test(next)) {
+                break;
+            }
+            block.push(next.replace(/^\s{0,2}/, ""));
+        }
+        if (block.length === 0) {
+            errors.push(`${sourceFile}:${lineNumber} block field must include indented text`);
+        }
+        return { value: block.join("\n").trim(), endIndex: cursor - 1 };
+    }
+    if (trimmed) {
+        return { value: cleanValue(trimmed), endIndex: index };
+    }
+    const values = [];
+    let cursor = index + 1;
+    for (; cursor < lines.length; cursor++) {
+        const next = lines[cursor];
+        if (!next.trim()) {
+            continue;
+        }
+        if (!/^\s/.test(next)) {
+            break;
+        }
+        const listItem = /^\s*[-*+]\s+(.+?)\s*$/.exec(next);
+        if (!listItem) {
+            errors.push(`${sourceFile}:${cursor + 1} field lists must use indented "- item" entries or key: | blocks`);
+            continue;
+        }
+        values.push(cleanValue(listItem[1]));
+    }
+    return { value: values, endIndex: cursor - 1 };
+}
+function rejectListStyleDefinitions(lines, options, errors) {
+    const idPattern = options.kind === "PI" ? "PI" : "AC";
+    const listPattern = new RegExp(`^\\s*[-*+]\\s+(${idPattern}-\\d{3,})\\b\\s*[:.-]?`, "i");
+    for (let index = 0; index < lines.length; index++) {
+        const match = listPattern.exec(lines[index]);
+        if (!match) {
+            continue;
+        }
+        const block = listItemBlock(lines, index);
+        if (!block.some((line) => containsKnownField(line, options.allowedFields))) {
+            continue;
+        }
+        const id = match[1].toUpperCase();
+        errors.push(`${id} list-style definition is not allowed at ${options.sourceFile}:${index + 1}; use "## ${id}: ..."`);
+    }
+}
+function listItemBlock(lines, start) {
+    const block = [lines[start]];
+    for (let index = start + 1; index < lines.length; index++) {
+        const line = lines[index];
+        if (line.trim() && !/^\s/.test(line)) {
+            break;
+        }
+        block.push(line);
+    }
+    return block;
+}
+function findDefinitionHeadings(lines, kind) {
+    const pattern = new RegExp(`^(#{1,6})\\s+(${kind}-\\d{3,})\\b(?:\\s*[:.-]\\s*|\\s+)?(.*?)\\s*$`, "i");
+    return lines.flatMap((line, index) => {
+        const match = pattern.exec(line);
+        if (!match) {
+            return [];
+        }
+        return [{
+                id: match[2].toUpperCase(),
+                level: match[1].length,
+                title: cleanValue(match[3]) || match[2].toUpperCase(),
+                index,
+                line: index + 1
+            }];
+    });
+}
+function sectionEndLine(lines, headingIndex, headingLevel) {
+    for (let index = headingIndex + 1; index < lines.length; index++) {
+        const match = /^(#{1,6})\s+/.exec(lines[index]);
+        if (match && match[1].length <= headingLevel) {
+            return index;
+        }
+    }
+    return lines.length;
+}
+function containsKnownField(line, allowedFields) {
+    for (const field of allowedFields) {
+        if (new RegExp(`\\b${field}\\b\\s*:`, "i").test(line) || new RegExp(`\\b${field}\\b`, "i").test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+function splitScalarArray(value) {
+    return value
+        .split(/[,;\n]/)
+        .map((item) => cleanValue(item))
+        .filter(Boolean);
+}
+function splitLines(content) {
+    return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+function cleanValue(value) {
+    return value.replace(/^[-#*\s]+/, "").trim();
+}
+function throwIfErrors(errors) {
+    if (errors.length > 0) {
+        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
+    }
+}

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

@@ -122,6 +122,9 @@ export interface SuperpowersProgressState {
 }
 export interface SuperpowersPlanItem {
     requirement: string;
+    source_file: string;
+    source_start_line: number;
+    source_end_line: number;
     delivery_scope: SuperpowersPlanDeliveryScope | "";
     capability_target: string;
     representative_samples: string[];
@@ -137,6 +140,9 @@ export interface SuperpowersPlanItem {
 }
 export interface SuperpowersAcceptanceCriterion {
     scope: string;
+    source_file: string;
+    source_start_line: number;
+    source_end_line: number;
     acceptance_scope: SuperpowersAcceptanceScope | "";
     ac_validates: string[];
     ac_does_not_validate: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.78",
+  "version": "0.2.79",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",