agent-project-sdlc 0.1.0 → 0.1.2

package/assets/agents/AGENTS_CORE.md

@@ -29,23 +29,26 @@
 
 ## Plan Protocol
 
-- `plan.yaml` 是当前执行计划事实源。open task 直接包含 `allowed_paths`、`required_gates`、`acceptance_criteria` 和必要的 `working_notes`。
-- task 完成并写入 implementation doc 后，删除 open task 的详细执行字段，只保留简短 `summary`、`implementation_doc` 和 `gate_result`。
+- `plan.yaml` 是当前和未来任务的短期执行计划事实源。open task 直接包含 `allowed_paths`、`required_gates`、`acceptance_criteria` 和必要的 `working_notes`。
+- `next_task_sequence` 记录下一个可分配的 `DEV-*` 序号，避免删除历史 task 后发生 id 冲突。
+- task 完成并写入 implementation doc 后，从 `plan.yaml` 的 `tasks` 列表移除该 task；不要长期保留 done/cancelled task 摘要。
 - `plan.draft.yaml` 是架构阶段生成的计划草案，不自动覆盖 `plan.yaml`。
 - 不维护 checkpoint 文件；任务现场只存在于 open task 的 plan 条目里。
 - 历史动作记录以 git commit 为准，产物结果以 implementation doc 为准。
-- `SPRINTING` 阶段每完成一个 task，先在 open task 仍保留完整 `allowed_paths`、`required_gates`、`acceptance_criteria` 等执行合同时创建 task implementation commit；随后再压缩 `plan.yaml` 为 done 摘要并创建 task completion ledger commit。两段提交 push 成功前不进入下一个 task。
+- `SPRINTING` 阶段每完成一个 task，先在 task 仍位于 `plan.yaml` 时创建 task implementation commit；随后再从 `plan.yaml` 移除该 task 并创建 task completion ledger commit。两段提交 push 成功前不进入下一个 task。
+- 历史 task 查询默认面向产物结果和变更意图，读取 implementation doc、RFC、PRD、tech plan 和代码；`allowed_paths`、`required_gates`、临时 `working_notes` 是执行期约束，不作为历史查询 API。
+- 过去 phase/task/gate 执行流水不是默认上下文；除非用户明确要求 forensic/audit/regression 追溯，否则不要读取或恢复历史执行信息。
 
 ## Prompt Language Contract
 
 - 面向人阅读的说明、规则、SOP、检查清单使用中文。
 - 机器契约保持英文，包括字段名、路径、命令、阶段枚举、状态枚举、脚本参数。
-- 不翻译 `.agent/state/*.yaml`、`.agent/managed/policies/*.yaml` 中的 key。
+- 不翻译 `.agent/state/*.yaml`、`.agent/pjsdlc_managed/policies/*.yaml` 中的 key。
 - 不翻译 `current_phase`、`active_skill`、`allowed_paths`、`required_gates`、`implementation_doc` 等字段名。
 - 不翻译 `REQUIREMENT_GATHERING`、`ARCHITECTING`、`SPRINTING`、`REVIEWING`、`TESTING`、`RELEASING`、`RFC_RECALIBRATION`、`BLOCKED` 等阶段枚举。
 - 不翻译 `pending`、`in_progress`、`done`、`blocked`、`pending_revision`、`cancelled` 等任务状态。
 - 不翻译 `make validate-*`、`python3 tools/transition.py --to <PHASE>`、`.docs/01_product/`、`.agent/state/plan.yaml` 等命令和路径。
-- 后续更新 `.agent/skills/*/SKILL.md` 或 `.agent/managed/templates/*.md` 时，遵循“中文解释 + 英文精确标识符”。Harness 根目录由 `package.json#sdlcHarness.harnessFolderName` 或 `sdlc-harness.config.json#harnessFolderName` 决定；未配置的项目默认使用 `.agent`。
+- 后续更新 `.agent/skills/*/SKILL.md` 或 `.agent/pjsdlc_managed/templates/*.md` 时，遵循“中文解释 + 英文精确标识符”。Harness 根目录由 `package.json#sdlcHarness.harnessFolderName` 或 `sdlc-harness.config.json#harnessFolderName` 决定；未配置的项目默认使用 `.agent`。
 
 ## 通用执行原则
 
@@ -136,13 +139,30 @@ Strong success criteria 可以让你 independent loop。Weak criteria，例如
 8. `reviewer` 角色只读，不直接修改源码。
 9. 需求变更必须进入 RFC 工作流。
 10. task/release 历史动作记录使用 git commit、tag 或外部 release 系统，不维护 `.agent/archive/` 常规归档。
-11. 在 `SPRINTING` 阶段，task 完成闭环必须先提交保留完整 open task 合同的 task implementation commit，再提交压缩 `plan.yaml` 后的 task completion ledger commit；如果没有 remote/upstream、权限或凭证导致无法 push，不要开始下一个 task，先报告 blocker。
+11. 在 `SPRINTING` 阶段，task 完成闭环必须先创建 task implementation commit，再提交移除该 task 后的 task completion ledger commit；如果没有 remote/upstream、权限或凭证导致无法 push，不要开始下一个 task，先报告 blocker。
 12. 文档 slice 发生变化后，运行 `make docs-overview` 刷新对应 `overview.md`。
 13. open task 必须在 `plan.yaml` 中包含完整执行合同，再继续推进或交接。
-14. 如果信息缺失，或 gate 因基础设施原因失败，停止推进并报告 blocker。
+14. 默认不读取过去 task 或 phase 执行流水；修 bug、补功能和阶段交付以当前代码、测试、PRD、技术方案和 implementation doc 为准。
+15. gate 证据写入当前 task `working_notes` 或 implementation doc 的 `Verification`；不要维护独立 gate results state。
+16. 如果信息缺失，或 gate 因基础设施原因失败，停止推进并报告 blocker。
 
 ## 宏指令
 
+用户不需要记忆或使用宏指令。自然语言是主要控制方式；以下 `/xxx` 只作为快捷入口、调试入口或自动化入口保留。
+
+当用户用自然语言表达意图时，Agent 应先读取 `.agent/state/lifecycle.yaml` 和必要的 `.agent/state/plan.yaml`，再映射到对应 workflow action：
+
+- “现在到哪了 / 状态如何” → 等价 `/status`。
+- “继续 / 下一步 / 推进” → 等价 `/next`。
+- “能进入下一阶段吗 / 进入下一步” → 等价 `/advance`。
+- “需求变了 / 这个设计要改” → 进入 RFC workflow。
+- “开始开发 / 做当前任务” → 在 `SPRINTING` 执行当前 open task。
+- “跑测试 / 验证一下” → 运行当前 task 或阶段对应 gate。
+- “准备 review / 帮我 review” → 进入只读 Review workflow。
+- “刷新文档总览 / 同步 overview” → 等价 `/overview`。
+
+如果自然语言意图会改变阶段、创建或删除 task、提交、push 或发布，Agent 先用一句话说明将执行的动作和验证方式，再继续。
+
 - `/status`：报告当前阶段、角色、任务、阻塞项和下一步动作。
 - `/next`：运行当前阶段映射的 Skill。
 - `/advance`：校验当前阶段出口 gate，通过后才尝试流转。
@@ -161,4 +181,4 @@ python3 tools/transition.py --to <PHASE>
 ```
 
 流转前先运行阶段 gate，通常使用 `make validate-current`，或使用
-`.agent/policies/phase_contracts.yaml` 中列出的具体 `make validate-*` 目标。
+`.agent/pjsdlc_managed/policies/phase_contracts.yaml` 中列出的具体 `make validate-*` 目标。

package/assets/policies/allowed_paths.yaml

@@ -27,7 +27,6 @@ phases:
       - ".docs/04_implementation/**"
       - ".docs/INDEX.md"
       - "<harnessRoot>/state/plan.yaml"
-      - "<harnessRoot>/state/gate_results.log"
 
   REVIEWING:
     read_only_source: true

package/assets/policies/phase_contracts.yaml

@@ -2,7 +2,7 @@ phases:
   IDLE:
     goal: "等待项目启动"
     role: "manager"
-    skill: "manager"
+    skill: "pjsdlc_manager"
     inputs:
       - "<harnessRoot>/state/lifecycle.yaml"
     outputs:
@@ -13,7 +13,7 @@ phases:
   REQUIREMENT_GATHERING:
     goal: "收集需求并形成产品方案"
     role: "pm"
-    skill: "pm_prd"
+    skill: "pjsdlc_pm_prd"
     inputs:
       - ".docs/00_raw/"
     outputs:
@@ -26,7 +26,7 @@ phases:
   ARCHITECTING:
     goal: "根据产品方案生成架构设计、技术方案和任务草案"
     role: "architect"
-    skill: "architect_design"
+    skill: "pjsdlc_architect_design"
     inputs:
       - ".docs/01_product/"
       - ".docs/02_architecture/"
@@ -41,7 +41,7 @@ phases:
   SPRINTING:
     goal: "按任务状态执行开发、测试和实现文档沉淀"
     role: "developer"
-    skill: "dev_sprint"
+    skill: "pjsdlc_dev_sprint"
     inputs:
       - "<harnessRoot>/state/plan.yaml"
       - "current open task plan contract"
@@ -51,7 +51,6 @@ phases:
       - "src/"
       - "tests/"
       - ".docs/04_implementation/"
-      - "<harnessRoot>/state/gate_results.log"
     gates:
       - "make validate-dev"
     next: "REVIEWING"
@@ -59,7 +58,7 @@ phases:
   REVIEWING:
     goal: "只读审查实现质量、需求一致性和架构风险"
     role: "reviewer"
-    skill: "reviewer"
+    skill: "pjsdlc_reviewer"
     inputs:
       - ".docs/01_product/"
       - ".docs/03_tech_plan/"
@@ -74,7 +73,7 @@ phases:
   TESTING:
     goal: "形成测试矩阵并完成回归验证"
     role: "tester"
-    skill: "tester"
+    skill: "pjsdlc_tester"
     inputs:
       - ".docs/01_product/"
       - ".docs/03_tech_plan/"
@@ -90,7 +89,7 @@ phases:
   RELEASING:
     goal: "发布准备、发布检查和回滚方案"
     role: "release_manager"
-    skill: "release_manager"
+    skill: "pjsdlc_release_manager"
     inputs:
       - ".docs/07_test/"
       - "build artifacts"
@@ -103,7 +102,7 @@ phases:
   COMPLETED:
     goal: "当前里程碑已完成"
     role: "manager"
-    skill: "manager"
+    skill: "pjsdlc_manager"
     inputs:
       - ".docs/08_release/"
     outputs:
@@ -114,7 +113,7 @@ phases:
   RFC_RECALIBRATION:
     goal: "处理需求变更、影响分析、局部补丁和任务回退"
     role: "rfc_owner"
-    skill: "rfc_recalibrate"
+    skill: "pjsdlc_rfc_recalibrate"
     inputs:
       - ".docs/rfc/"
       - ".docs/01_product/"
@@ -131,7 +130,7 @@ phases:
   BLOCKED:
     goal: "等待人工补充信息、授权或基础设施处理"
     role: "manager"
-    skill: "manager"
+    skill: "pjsdlc_manager"
     inputs:
       - "<harnessRoot>/state/lifecycle.yaml"
     outputs:

package/assets/skills/{architect_design → pjsdlc_architect_design}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: architect_design
+name: pjsdlc_architect_design
 description: Use during ARCHITECTING to create architecture docs, technical plans, interface contracts, and task drafts.
 ---
 
@@ -23,8 +23,8 @@ description: Use during ARCHITECTING to create architecture docs, technical plan
 - 相关 `.docs/01_product/` PRD
 - 现有 `.docs/02_architecture/`
 - 当前代码结构概览
-- `<harnessRoot>/managed/templates/TECH_DESIGN_TEMPLATE.md`
-- `<harnessRoot>/managed/templates/PLAN_TEMPLATE.yaml`
+- `<harnessRoot>/pjsdlc_managed/templates/TECH_DESIGN_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/PLAN_TEMPLATE.yaml`
 
 ## 输出
 
@@ -48,7 +48,7 @@ description: Use during ARCHITECTING to create architecture docs, technical plan
 1. 技术方案必须引用 PRD 路径和 requirement IDs。
 2. 每个 open task 必须包含 `id`、`title`、`status`、`summary`、`docs`、`allowed_paths`、`required_gates`、`acceptance_criteria` 和 `implementation_doc`。
 3. `plan.draft.yaml` 不得自动覆盖 `plan.yaml`。
-4. 风险或不清晰的问题按 `<harnessRoot>/managed/policies/risk_matrix.yaml` 标记。
+4. 风险或不清晰的问题按 `<harnessRoot>/pjsdlc_managed/policies/risk_matrix.yaml` 标记。
 5. 任务边界应足够小，能在一次开发执行和一份 implementation doc 内闭环。
 
 ## 完成检查

package/assets/skills/{dev_sprint → pjsdlc_dev_sprint}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: dev_sprint
+name: pjsdlc_dev_sprint
 description: Use during SPRINTING to execute one task from plan.yaml, respecting the active plan contract.
 ---
 
@@ -15,7 +15,7 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 
 开始编码前，先确认当前 open task 是否完整，修改范围是否覆盖必要文件，验收标准是否能被测试或 gate 验证。如果发现任务边界、产品行为或技术方案不清晰，要停下来说明 blocker、给出可能解释和推荐下一步，而不是扩大范围继续写。
 
-实现时遵循小步闭环：先检查 `git status`，确认工作区没有未归属到当前 task 的脏变更；再定位相关代码和测试，做必要修改，运行 gate，修复失败，写 implementation doc 并刷新文档派生视图。此时先不要压缩 `plan.yaml`，要在当前 task 仍保留完整执行合同的状态下创建 task implementation commit；随后再压缩 task，创建 task completion ledger commit，并 push 两个 commit。不要顺手重构、重排格式或处理无关问题；如果发现无关风险，只记录或报告。
+实现时遵循小步闭环：先检查 `git status`，确认工作区没有未归属到当前 task 的脏变更；再定位相关代码和测试，做必要修改，运行 gate，修复失败，写 implementation doc 并刷新文档派生视图。此时先不要从 `plan.yaml` 移除当前 task，要在当前 task 仍位于 `plan.yaml` 时创建 task implementation commit；随后再移除 task，创建 task completion ledger commit，并 push 两个 commit。不要顺手重构、重排格式或处理无关问题；如果发现无关风险，只记录或报告。
 
 ## 输入
 
@@ -29,11 +29,11 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 - 当前 task `allowed_paths` 范围内的源码改动
 - 当前 task `allowed_paths` 范围内的测试改动
 - `.docs/04_implementation/` 下的 implementation doc
-- `<harnessRoot>/state/gate_results.log` 中的 gate 结果
+- 当前 task `working_notes` 或 implementation doc `Verification` 中的 gate evidence
 - 更新后的 `<harnessRoot>/state/plan.yaml`
 - 更新后的 `.docs/INDEX.md`
-- 保留完整 open task 合同的 task implementation commit
-- 压缩 `plan.yaml` 后的 task completion ledger commit
+- 当前 task 移除前创建的 task implementation commit
+- 从 `plan.yaml` 移除当前 task 后的 task completion ledger commit
 - 已 push 到当前 upstream branch 的远端提交
 
 ## 语义切片
@@ -41,8 +41,8 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 - `SPRINTING` 阶段的执行单元是 `current_task_id`，不要在开发中重新生成整个 Sprint 计划。
 - 当前任务就是开发阶段的主要语义切片，代码、测试、gate 记录和 implementation doc 都围绕该任务闭环。
 - open task 在 `plan.yaml` 中直接保存 `docs`、`allowed_paths`、`required_gates`、`acceptance_criteria` 和必要的 `working_notes`。
-- task implementation commit 必须发生在 task 压缩之前，此时 `plan.yaml` 中当前 task 仍保留 `docs`、`allowed_paths`、`required_gates`、`acceptance_criteria` 和必要 `working_notes`。
-- task completion ledger commit 发生在 implementation commit 之后，只负责将该 task 压缩为 `summary`、`implementation_doc`、`gate_result` 等简短摘要。
+- task implementation commit 必须发生在 task 移除之前，避免实现变更和计划短期化混在同一个提交里。
+- task completion ledger commit 发生在 implementation commit 之后，只负责将该 task 从当前 `plan.yaml` 移除。
 - 一个开发 task 默认对应一个主要 implementation commit 和一个轻量 completion ledger commit。implementation commit message 应包含 task id，例如 `DEV-003: implement login rate limit`；push 成功前，不进入下一个 task。
 - 本 Skill 不直接重切 PRD 或 tech plan；如果发现上游语义边界错误，进入 `BLOCKED`、创建 RFC，或请求回到 `ARCHITECTING`。
 - gate 通过后调用 `implementation_doc`，由该 Skill 按真实实现生成 `.docs/04_implementation/` slice。
@@ -55,9 +55,11 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 1. `current_task_id` 指向正在执行的 open task。
 2. open task 直接声明 `docs`、`allowed_paths`、`required_gates`、`acceptance_criteria`。
 3. 任务执行中只保留恢复所需的简短 `working_notes`。
-4. gate、implementation doc、`.docs/INDEX.md` 和 `overview.md` 完成后，先保持 open task 完整合同不变，创建 task implementation commit。
-5. implementation commit 完成后，再把 task 标记为 `done`，并移除 `docs`、`allowed_paths`、`required_gates`、`acceptance_criteria`、`working_notes`。
-6. 将压缩后的 `plan.yaml` 和必要 gate 记录提交为 task completion ledger commit，并 `git push` 两个 commit 到当前 upstream branch。
+4. gate、implementation doc、`.docs/INDEX.md` 和 `overview.md` 完成后，在当前 task 仍位于 `plan.yaml` 时创建 task implementation commit。
+5. implementation commit 完成后，再把该 task 从 `plan.yaml` 的 `tasks` 列表移除，并保留/递增 `next_task_sequence`。
+6. 将移除当前 task 后的 `plan.yaml` 提交为 task completion ledger commit，并 `git push` 两个 commit 到当前 upstream branch。
+
+done task 的执行流水不在当前 `plan.yaml` 长期保留，也不是默认上下文。修 bug、补功能和继续开发时，优先读取当前代码、测试、PRD、技术方案和 implementation doc；历史 task 查询主要看“做了什么、为什么做、产物在哪里、验证了什么”。`allowed_paths`、`required_gates`、临时 `working_notes` 是执行期约束，不作为历史查询 API。只有用户明确要求 forensic/audit/regression 追溯时，才临时使用 git、PR 或 CI 记录。
 
 ## 规则
 
@@ -69,10 +71,11 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 6. 如果 gate 因基础设施、凭证缺失、产品行为不清或高风险架构变化失败，进入 `BLOCKED`。
 7. gate 通过后调用 `implementation_doc`。
 8. 只有 gate 通过且 implementation doc 校验通过后，才能把任务标记为 `done`。
-9. 任务完成并写入 implementation doc、刷新 `overview.md`、记录 gate 后，先创建 task implementation commit；此时不要压缩该 task。
-10. task implementation commit 必须包含未压缩的 open task 合同，确保 git history 能看到当时的 `allowed_paths`、`required_gates` 和 `acceptance_criteria`。
-11. implementation commit 完成后，压缩该 task，只保留简短摘要和 gate 结果，并创建 task completion ledger commit。
-12. 两个 commit 后必须 `git push` 到当前 upstream branch；如果没有 remote/upstream、权限或凭证导致无法 push，停止推进并报告 blocker。
+9. 任务完成并写入 implementation doc、刷新 `overview.md`、记录 gate 后，先创建 task implementation commit；此时不要移除该 task。
+10. task implementation commit 必须发生在 task 移除前；后续默认不要读取其中的执行期字段，历史查询以 implementation doc、RFC、PRD、tech plan 和代码为主。
+11. implementation commit 完成后，从当前 `plan.yaml` 移除该 task，并创建 task completion ledger commit。
+12. 默认不追溯已完成 task 的执行流水；只有显式 forensic/audit/regression 任务才临时查询 git、PR 或 CI 记录。
+13. 两个 commit 后必须 `git push` 到当前 upstream branch；如果没有 remote/upstream、权限或凭证导致无法 push，停止推进并报告 blocker。
 
 ## 完成检查
 
@@ -81,9 +84,9 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 - [ ] open task 在 `plan.yaml` 中包含完整执行合同。
 - [ ] 当前任务仍然是单一清晰的开发语义切片。
 - [ ] implementation doc 已生成并反映真实代码。
-- [ ] 任务状态和 gate 结果已更新。
-- [ ] task implementation commit 已在 task 压缩前创建，且包含完整 open task 合同。
-- [ ] done task 已在 implementation commit 之后压缩为简短摘要。
+- [ ] gate 结果已写入 implementation doc `Verification`，必要时当前 task `working_notes` 也记录了恢复现场所需的 gate evidence。
+- [ ] task implementation commit 已在 task 移除前创建。
+- [ ] done task 已在 implementation commit 之后从当前 `plan.yaml` 移除。
 - [ ] `.docs/INDEX.md` 已链接 implementation doc。
 - [ ] 已运行 `make docs-overview` 刷新 `.docs/<stage>/overview.md`。
 - [ ] 已创建 task completion ledger commit。

package/assets/skills/{implementation_doc → pjsdlc_implementation_doc}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: implementation_doc
+name: pjsdlc_implementation_doc
 description: Use after a development task passes code gates to document the real implementation and plan deviations.
 ---
 
@@ -24,7 +24,7 @@ description: Use after a development task passes code gates to document the real
 - 关联 PRD
 - 关联技术方案
 - 变更后的源码和测试文件
-- `<harnessRoot>/managed/templates/IMPLEMENTATION_DOC_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/IMPLEMENTATION_DOC_TEMPLATE.md`
 
 ## 输出
 

package/assets/skills/{manager → pjsdlc_manager}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: manager
+name: pjsdlc_manager
 description: Use when checking project phase, routing macro commands, validating exit gates, or switching lifecycle phase.
 ---
 
@@ -16,14 +16,14 @@ Skill、执行出口 gate，并记录 blocker。
 
 与用户对话时，先读取 lifecycle 和 plan，再说明当前阶段、active_skill、当前任务、阻塞项和下一步。不要基于猜测切换阶段；如果用户要求的动作与当前阶段冲突，说明冲突、可选路径和推荐处理方式。
 
-执行 `/status`、`/next`、`/advance`、`/rfc` 等宏指令时，输出要短而明确：当前事实是什么、将调用哪个 gate 或 Skill、成功后会进入哪里、失败时如何保持状态安全。
+自然语言是默认控制方式。用户说“状态如何”“继续”“下一步”“开始开发”“跑测试”“准备 review”“需求变了”等，不应要求用户记忆 `/xxx`；你应先读取 lifecycle 和 plan，再把意图映射到对应 workflow action。执行 `/status`、`/next`、`/advance`、`/rfc` 等宏指令时，输出要短而明确：当前事实是什么、将调用哪个 gate 或 Skill、成功后会进入哪里、失败时如何保持状态安全。
 
 ## 输入
 
 - `<harnessRoot>/state/lifecycle.yaml`
 - `<harnessRoot>/state/plan.yaml`
 - `.docs/INDEX.md`
-- `<harnessRoot>/managed/policies/phase_contracts.yaml`
+- `<harnessRoot>/pjsdlc_managed/policies/phase_contracts.yaml`
 
 ## 规则
 
@@ -37,14 +37,25 @@ Skill、执行出口 gate，并记录 blocker。
 8. 用户输入 `/advance` 时，运行 `make validate-current`，通过后流转到配置的 `next` 阶段。
 9. 用户输入 `/rfc <file>` 时，流转到 `RFC_RECALIBRATION` 并调用 `rfc_recalibrate`。
 10. 如果当前 task 处于 `blocked` 或缺少 open task 必需的 plan 字段，不要推进阶段，先要求 `plan.yaml` 完整。
+11. 用户自然语言询问状态时，等价执行 `/status`。
+12. 用户自然语言要求继续、推进或下一步时，等价执行 `/next`。
+13. 用户自然语言要求进入下一阶段或检查是否可进入下一阶段时，等价执行 `/advance`。
+14. 用户自然语言表达需求或设计变化时，进入 RFC workflow。
+15. 用户自然语言要求开始开发或做当前任务时，如果 `current_phase` 是 `SPRINTING`，执行当前 open task；否则说明当前阶段冲突和推荐路径。
+16. 用户自然语言要求跑测试或验证时，运行当前 task 或当前阶段的对应 gate。
+17. 用户自然语言要求 review 时，进入只读 Review workflow，不直接改源码。
+18. 用户自然语言要求刷新文档总览时，运行 `make docs-overview`。
+19. 如果动作会改变阶段、创建或删除 task、提交、push 或发布，先用一句话说明即将执行的动作和验证方式，再继续。
 
 ## Plan Protocol
 
-每个 open task 都必须在 `plan.yaml` 中包含 `docs`、`allowed_paths`、`required_gates` 和 `acceptance_criteria`；done/cancelled task 只保留简短摘要、implementation doc 和 gate result。完成后的历史事实以 git commit 与 implementation doc 为准。
+每个 open task 都必须在 `plan.yaml` 中包含 `docs`、`allowed_paths`、`required_gates` 和 `acceptance_criteria`；done/cancelled task 不长期留在当前 `plan.yaml`。完成后的产物事实以 implementation doc 为准，动作历史以 git/PR/CI/release 系统作为 cold archive，`next_task_sequence` 负责继续分配后续 task id。
+
+`lifecycle.yaml` 和 `plan.yaml` 只用于当前可执行状态。默认不要读取过去 phase/task/gate 执行流水；只有用户明确要求 forensic/audit/regression 追溯时，才临时查询 git、PR、CI 或 release 记录。
 
 ## 完成检查
 
 - [ ] 已确认 `current_phase`、`active_role`、`active_skill` 和下一阶段。
-- [ ] gate 结果已记录到 `<harnessRoot>/state/gate_results.log`。
+- [ ] 当前 task/phase 的 gate 结果已进入 task notes、implementation doc、CI 或 release 记录。
 - [ ] 如当前 task 是 open task，`plan.yaml` 中的执行合同完整。
 - [ ] 生命周期只通过 `tools/transition.py` 发生变化。

package/assets/skills/{pm_prd → pjsdlc_pm_prd}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: pm_prd
+name: pjsdlc_pm_prd
 description: Use during REQUIREMENT_GATHERING to turn raw input into PRD slices with acceptance criteria and boundaries.
 ---
 
@@ -23,7 +23,7 @@ description: Use during REQUIREMENT_GATHERING to turn raw input into PRD slices
 - `.docs/00_raw/`
 - 现有 `.docs/01_product/`
 - 现有 `.docs/rfc/`
-- `<harnessRoot>/managed/templates/PRD_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/PRD_TEMPLATE.md`
 
 ## 输出
 

package/assets/skills/{release_manager → pjsdlc_release_manager}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: release_manager
+name: pjsdlc_release_manager
 description: Use during RELEASING to prepare release notes, smoke evidence, deployment checks, and rollback plan.
 ---
 
@@ -22,7 +22,7 @@ Release note 面向人类读者，必须说明变更价值、影响范围和注
 - `.docs/07_test/`
 - build artifacts
 - changelog 或 task list
-- `<harnessRoot>/managed/templates/RELEASE_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/RELEASE_TEMPLATE.md`
 
 ## 输出
 

package/assets/skills/{reviewer → pjsdlc_reviewer}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: reviewer
+name: pjsdlc_reviewer
 description: Use during REVIEWING for read-only review of requirement fit, implementation risk, and test adequacy.
 ---
 
@@ -24,7 +24,7 @@ Review 时先建立证据链：PRD 说什么、技术方案承诺什么、implem
 - `.docs/04_implementation/`
 - `git diff`
 - gate/test 结果
-- `<harnessRoot>/managed/templates/REVIEW_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/REVIEW_TEMPLATE.md`
 
 ## 输出
 

package/assets/skills/{rfc_recalibrate → pjsdlc_rfc_recalibrate}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: rfc_recalibrate
+name: pjsdlc_rfc_recalibrate
 description: Use during RFC_RECALIBRATION to process requirement changes with impact analysis and localized patches.
 ---
 
@@ -17,6 +17,8 @@ description: Use during RFC_RECALIBRATION to process requirement changes with im
 
 输出应包含 impact analysis、受影响产物、任务状态调整、回归要求和恢复路径。只修改受影响 slice；如果变化跨越多个独立能力，应拆分 RFC 或生成增量任务。
 
+影响面分析必须先于补丁。至少检查 docs/state/skills/policies/templates/tools/package assets/tests/migrations/generated artifacts 是否受影响；如果某一类不受影响，也要显式说明不受影响或不需要修改。对于 Harness package 相关变更，还要检查 `sync`、`upgrade`、source mappings、package assets 和用户项目迁移行为。
+
 ## 输入
 
 - `.docs/rfc/RFC_*.md`
@@ -37,14 +39,14 @@ description: Use during RFC_RECALIBRATION to process requirement changes with im
 
 - `.docs/rfc/` 按一次需求变更切片，一份 RFC 只描述一个可独立评估、实现和回归的变更。
 - 如果用户一次提出多个互不依赖的变更，应拆成多份 RFC。
-- RFC 的 impact analysis 负责判断是否需要重切 PRD、tech plan、implementation doc 或 test plan。
+- RFC 的 impact analysis 负责判断是否需要重切 PRD、tech plan、implementation doc 或 test plan，并覆盖 state、tools、package assets、tests、migration 和 generated overview。
 - 对受影响产物做局部补丁，不重写无关稳定 slice。
 - 每次 RFC 影响了文档边界，都要更新 `.docs/INDEX.md` 并记录受影响任务状态。
 
 ## 规则
 
 1. 影响已接受产物的需求变化，必须先进入本 Skill。
-2. 修改下游文档或任务前，先运行 impact analysis。
+2. 修改下游文档或任务前，先运行 impact analysis，并列出受影响/不受影响的文件类别。
 3. 受影响的已完成任务标记为 `pending_revision`。
 4. 受影响的 `pending` 或 `in_progress` 任务追加 revision notes。
 5. 不重写无关的稳定文档。
@@ -55,6 +57,7 @@ description: Use during RFC_RECALIBRATION to process requirement changes with im
 - [ ] RFC 包含有效 status 和 acceptance criteria。
 - [ ] Product impact 和 technical impact 已记录。
 - [ ] 已判断 RFC 是否需要拆分，以及是否影响其它阶段 slice。
+- [ ] 已列出 docs/state/skills/policies/templates/tools/package assets/tests/migrations/generated artifacts 的影响面。
 - [ ] 受影响任务已标记或新增。
 - [ ] Regression requirements 已明确。
 - [ ] `.docs/INDEX.md` 已链接 RFC 和受影响产物。

package/assets/skills/{tester → pjsdlc_tester}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: tester
+name: pjsdlc_tester
 description: Use during TESTING to produce a test matrix, run regression, and document coverage gaps.
 ---
 
@@ -24,7 +24,7 @@ description: Use during TESTING to produce a test matrix, run regression, and do
 - `.docs/04_implementation/`
 - `.docs/06_review/REVIEW_REPORT.md`
 - 现有测试
-- `<harnessRoot>/managed/templates/TEST_PLAN_TEMPLATE.md`
+- `<harnessRoot>/pjsdlc_managed/templates/TEST_PLAN_TEMPLATE.md`
 
 ## 输出
 

package/assets/templates/PLAN_TEMPLATE.yaml

@@ -1,10 +1,11 @@
 current_phase: "SPRINTING"
 current_task_id: "DEV-001"
+next_task_sequence: 2
 tasks:
   - id: "DEV-001"
     title: "实现示例任务"
     status: "pending"
-    summary: "一句话描述任务目标和交付边界；done 后保留这类简短摘要。"
+    summary: "一句话描述任务目标和交付边界。"
     docs:
       product:
         - ".docs/01_product/example.md"
@@ -18,8 +19,7 @@ tasks:
       - "make lint"
       - "make test-current-domain"
     acceptance_criteria:
-      - "验收标准写在 open task 内，完成后可压缩删除。"
+      - "验收标准写在 open task 内，完成后从当前 plan 删除。"
     working_notes:
       - "执行现场备注只在 open task 保留。"
     implementation_doc: ".docs/04_implementation/example/dev_001.md"
-    gate_result: ""

package/dist/lib/config.js

@@ -1,24 +1,27 @@
 import path from "node:path";
+import { createRequire } from "node:module";
 import { harnessConfigPath, harnessPath, harnessRoot } from "./harness-root.js";
 import { pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { parseYaml, stringifyYaml } from "./yaml.js";
+const require = createRequire(import.meta.url);
+const packageMetadata = require("../../package.json");
 export function defaultConfig(root) {
     return {
         core: {
             package: "agent-project-sdlc",
-            version: "0.1.0",
+            version: packageMetadata.version ?? "0.0.0",
             schema_version: "1"
         },
         managed_files: [
             { path: "AGENTS.md", strategy: "merge-block" },
             { path: "Makefile", strategy: "merge-block" },
             { path: harnessPath(root, "skills"), strategy: "managed" },
-            { path: harnessPath(root, "managed", "templates"), strategy: "managed" },
-            { path: harnessPath(root, "managed", "policies"), strategy: "merge-with-local" },
-            { path: harnessPath(root, "managed", "make", "sdlc-harness.mk"), strategy: "managed" },
+            { path: harnessPath(root, "pjsdlc_managed", "templates"), strategy: "managed" },
+            { path: harnessPath(root, "pjsdlc_managed", "policies"), strategy: "merge-with-local" },
+            { path: harnessPath(root, "pjsdlc_managed", "make", "sdlc-harness.mk"), strategy: "managed" },
             { path: ".github/workflows/harness.yml", strategy: "create-if-missing" }
         ],
-        local_overrides: [harnessPath(root, "overrides/**"), harnessPath(root, "managed", "policies", "*.local.yaml")],
+        local_overrides: [harnessPath(root, "overrides/**"), harnessPath(root, "pjsdlc_managed", "policies", "*.local.yaml")],
         never_overwrite: [".docs/**", harnessPath(root, "state/**"), "src/**", "tests/**"]
     };
 }

package/dist/lib/init.js

@@ -51,11 +51,10 @@ async function createProjectState(projectRoot, root, report) {
     const files = [
         [
             harnessPath(root, "state", "lifecycle.yaml"),
-            `project_name: "Project"\nversion: "v0.1"\ncurrent_phase: "REQUIREMENT_GATHERING"\nactive_role: "pm"\nactive_skill: "pm_prd"\ncurrent_milestone: "MVP"\nblocked_reason: ""\nsuspended_phase: ""\nallowed_next_phases:\n  - "ARCHITECTING"\nhistory: []\n`
+            `project_name: "Project"\nversion: "v0.1"\ncurrent_phase: "REQUIREMENT_GATHERING"\nactive_role: "pm"\nactive_skill: "pjsdlc_pm_prd"\ncurrent_milestone: "MVP"\nblocked_reason: ""\nsuspended_phase: ""\nallowed_next_phases:\n  - "ARCHITECTING"\n`
         ],
-        [harnessPath(root, "state", "plan.yaml"), `current_phase: "SPRINTING"\ncurrent_task_id: ""\ntasks: []\n`],
-        [harnessPath(root, "state", "plan.draft.yaml"), `current_phase: "SPRINTING"\ncurrent_task_id: ""\ntasks: []\n`],
-        [harnessPath(root, "state", "gate_results.log"), "# Gate results are appended by sdlc-harness.\n"],
+        [harnessPath(root, "state", "plan.yaml"), `current_phase: "SPRINTING"\ncurrent_task_id: ""\nnext_task_sequence: 1\ntasks: []\n`],
+        [harnessPath(root, "state", "plan.draft.yaml"), `current_phase: "SPRINTING"\ncurrent_task_id: ""\nnext_task_sequence: 1\ntasks: []\n`],
         [harnessPath(root, "state", "memory.md"), "# Project Memory\n\n短期执行计划写入 plan.yaml；长期稳定知识简短记录在这里，并链接到 `.docs/` 正式出处。\n"]
     ];
     for (const [relative, content] of files) {

package/dist/lib/managed-file.d.ts

@@ -1,6 +1,17 @@
-export declare const MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
-export declare const MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
-export declare const MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
-export declare const MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
-export declare const MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
+export interface ManagedBlockMarkers {
+    start: string;
+    end: string;
+}
+export declare const MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
+export declare const MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
+export declare const LEGACY_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
+export declare const LEGACY_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
+export declare const MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
+export declare const MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
+export declare const LEGACY_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
+export declare const LEGACY_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
+export declare const MANAGED_METADATA_START = "<!-- pjsdlc:sdlc-harness-managed";
+export declare const LEGACY_MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
 export declare const MANAGED_METADATA_END = "-->";
+export declare const AGENTS_BLOCK_MARKERS: ManagedBlockMarkers[];
+export declare const MAKEFILE_BLOCK_MARKERS: ManagedBlockMarkers[];

package/dist/lib/managed-file.js

@@ -1,6 +1,19 @@
-export const MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
-export const MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
-export const MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
-export const MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
-export const MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
+export const MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
+export const MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
+export const LEGACY_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
+export const LEGACY_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
+export const MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
+export const MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
+export const LEGACY_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
+export const LEGACY_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
+export const MANAGED_METADATA_START = "<!-- pjsdlc:sdlc-harness-managed";
+export const LEGACY_MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
 export const MANAGED_METADATA_END = "-->";
+export const AGENTS_BLOCK_MARKERS = [
+    { start: MANAGED_BLOCK_START, end: MANAGED_BLOCK_END },
+    { start: LEGACY_MANAGED_BLOCK_START, end: LEGACY_MANAGED_BLOCK_END }
+];
+export const MAKEFILE_BLOCK_MARKERS = [
+    { start: MAKEFILE_BLOCK_START, end: MAKEFILE_BLOCK_END },
+    { start: LEGACY_MAKEFILE_BLOCK_START, end: LEGACY_MAKEFILE_BLOCK_END }
+];

package/dist/lib/migrations.js

@@ -1,17 +1,31 @@
 import path from "node:path";
-import { rm } from "node:fs/promises";
+import { rename, rm } from "node:fs/promises";
 import { readConfig } from "./config.js";
-import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { harnessConfigPath, harnessPath, harnessRoot } from "./harness-root.js";
 import { parseYaml, stringifyYaml } from "./yaml.js";
 export const CURRENT_SCHEMA_VERSION = "1";
 export const migrations = [];
+const SKILL_RENAMES = {
+    manager: "pjsdlc_manager",
+    pm_prd: "pjsdlc_pm_prd",
+    architect_design: "pjsdlc_architect_design",
+    dev_sprint: "pjsdlc_dev_sprint",
+    implementation_doc: "pjsdlc_implementation_doc",
+    reviewer: "pjsdlc_reviewer",
+    tester: "pjsdlc_tester",
+    release_manager: "pjsdlc_release_manager",
+    rfc_recalibrate: "pjsdlc_rfc_recalibrate"
+};
 export async function runMigrations(projectRoot) {
     const report = { changed: [], skipped: [] };
     const root = await harnessRoot(projectRoot);
     await migrateConfig(projectRoot, root, report);
+    await migrateLegacyManagedPaths(projectRoot, root, report);
+    await migrateLifecycle(projectRoot, root, report);
     await migratePlan(projectRoot, root, report, "plan.yaml", "tasks.yaml");
     await migratePlan(projectRoot, root, report, "plan.draft.yaml", "tasks.draft.yaml");
+    await removeLegacyGateResults(projectRoot, root, report);
     await removeLegacyCheckpoints(projectRoot, root, report);
     await ensureMemory(projectRoot, root, report);
     return report;
@@ -26,7 +40,7 @@ async function migrateConfig(projectRoot, root, report) {
     const config = await readConfig(projectRoot);
     config.core.schema_version = CURRENT_SCHEMA_VERSION;
     config.managed_files = migrateManagedFiles(config.managed_files, root);
-    config.local_overrides = config.local_overrides.map((item) => item === ".harness/policies/*.local.yaml" ? harnessPath(root, "managed", "policies", "*.local.yaml") : item);
+    config.local_overrides = config.local_overrides.map((item) => migrateLocalOverride(item, root));
     if (await writeTextIfChanged(configPath, stringifyYaml(config))) {
         report.changed.push(relativeConfigPath);
     }
@@ -34,6 +48,34 @@ async function migrateConfig(projectRoot, root, report) {
         report.skipped.push(relativeConfigPath);
     }
 }
+async function migrateLegacyManagedPaths(projectRoot, root, report) {
+    await moveIfDestinationMissing(projectRoot, harnessPath(root, "managed"), harnessPath(root, "pjsdlc_managed"), report);
+    await moveIfDestinationMissing(projectRoot, harnessPath(root, "templates"), harnessPath(root, "pjsdlc_managed", "templates"), report);
+    await moveIfDestinationMissing(projectRoot, harnessPath(root, "policies"), harnessPath(root, "pjsdlc_managed", "policies"), report);
+    await moveIfDestinationMissing(projectRoot, harnessPath(root, "make"), harnessPath(root, "pjsdlc_managed", "make"), report);
+}
+async function moveIfDestinationMissing(projectRoot, legacyRelativePath, nextRelativePath, report) {
+    const legacyPath = path.join(projectRoot, legacyRelativePath);
+    if (!(await pathExists(legacyPath))) {
+        report.skipped.push(legacyRelativePath);
+        return;
+    }
+    const nextPath = path.join(projectRoot, nextRelativePath);
+    if (await pathExists(nextPath)) {
+        report.skipped.push(`${legacyRelativePath} -> ${nextRelativePath}`);
+        return;
+    }
+    await ensureDir(path.dirname(nextPath));
+    await rename(legacyPath, nextPath);
+    report.changed.push(`${legacyRelativePath} -> ${nextRelativePath}`);
+}
+function migrateLocalOverride(item, root) {
+    if (item === ".harness/policies/*.local.yaml" ||
+        item === harnessPath(root, "managed", "policies", "*.local.yaml")) {
+        return harnessPath(root, "pjsdlc_managed", "policies", "*.local.yaml");
+    }
+    return item;
+}
 function migrateManagedFiles(managedFiles, root) {
     const migrated = [];
     const seen = new Set();
@@ -49,16 +91,16 @@ function migrateManagedFiles(managedFiles, root) {
             push({ path: harnessPath(root, "skills"), strategy: "managed" });
             continue;
         }
-        if (item.path === ".harness/templates") {
-            push({ path: harnessPath(root, "managed", "templates"), strategy: "managed" });
+        if (item.path === ".harness/templates" || item.path === harnessPath(root, "managed", "templates")) {
+            push({ path: harnessPath(root, "pjsdlc_managed", "templates"), strategy: "managed" });
             continue;
         }
-        if (item.path === ".harness/policies") {
-            push({ path: harnessPath(root, "managed", "policies"), strategy: "merge-with-local" });
+        if (item.path === ".harness/policies" || item.path === harnessPath(root, "managed", "policies")) {
+            push({ path: harnessPath(root, "pjsdlc_managed", "policies"), strategy: "merge-with-local" });
             continue;
         }
-        if (item.path === ".harness/make/sdlc-harness.mk") {
-            push({ path: harnessPath(root, "managed", "make", "sdlc-harness.mk"), strategy: "managed" });
+        if (item.path === ".harness/make/sdlc-harness.mk" || item.path === harnessPath(root, "managed", "make", "sdlc-harness.mk")) {
+            push({ path: harnessPath(root, "pjsdlc_managed", "make", "sdlc-harness.mk"), strategy: "managed" });
             continue;
         }
         push(item);
@@ -75,6 +117,35 @@ function migrateManagedFiles(managedFiles, root) {
     }
     return migrated;
 }
+async function migrateLifecycle(projectRoot, root, report) {
+    const relativeLifecyclePath = harnessPath(root, "state", "lifecycle.yaml");
+    const lifecyclePath = path.join(projectRoot, relativeLifecyclePath);
+    if (!(await pathExists(lifecyclePath))) {
+        report.skipped.push(relativeLifecyclePath);
+        return;
+    }
+    const data = (parseYaml(await readText(lifecyclePath)) ?? {});
+    let changed = false;
+    const activeSkill = String(data.active_skill ?? "");
+    if (SKILL_RENAMES[activeSkill]) {
+        data.active_skill = SKILL_RENAMES[activeSkill];
+        changed = true;
+    }
+    if ("history" in data) {
+        delete data.history;
+        changed = true;
+    }
+    if (!changed) {
+        report.skipped.push(relativeLifecyclePath);
+        return;
+    }
+    if (await writeTextIfChanged(lifecyclePath, stringifyYaml(data))) {
+        report.changed.push(relativeLifecyclePath);
+    }
+    else {
+        report.skipped.push(relativeLifecyclePath);
+    }
+}
 async function migratePlan(projectRoot, root, report, planFileName, legacyFileName) {
     const relativePlanPath = harnessPath(root, "state", planFileName);
     const planPath = path.join(projectRoot, relativePlanPath);
@@ -99,9 +170,18 @@ async function migratePlan(projectRoot, root, report, planFileName, legacyFileNa
         changed = true;
     }
     if (Array.isArray(data.tasks)) {
+        const retainedTasks = [];
+        let maxTaskSequence = 0;
         for (const task of data.tasks) {
-            if (!isRecord(task))
+            if (!isRecord(task)) {
+                retainedTasks.push(task);
                 continue;
+            }
+            const taskId = String(task.id ?? "");
+            const match = taskId.match(/^DEV-(\d+)$/);
+            if (match) {
+                maxTaskSequence = Math.max(maxTaskSequence, Number(match[1]));
+            }
             if ("checkpoint" in task) {
                 const checkpoint = String(task.checkpoint ?? "");
                 if (isOpenTask(task) && checkpoint) {
@@ -115,7 +195,30 @@ async function migratePlan(projectRoot, root, report, planFileName, legacyFileNa
                 delete task.checkpoint;
                 changed = true;
             }
+            if ("gate_result" in task && isOpenTask(task)) {
+                delete task.gate_result;
+                changed = true;
+            }
+            if (["done", "cancelled"].includes(String(task.status))) {
+                changed = true;
+                continue;
+            }
+            retainedTasks.push(task);
         }
+        if (retainedTasks.length !== data.tasks.length) {
+            data.tasks = retainedTasks;
+            changed = true;
+        }
+        const nextTaskSequence = data.next_task_sequence;
+        if (!Number.isInteger(nextTaskSequence) || Number(nextTaskSequence) <= maxTaskSequence) {
+            data.next_task_sequence = maxTaskSequence + 1;
+            changed = true;
+        }
+    }
+    const currentTaskId = String(data.current_task_id ?? "");
+    if (currentTaskId && !taskById(data, currentTaskId)) {
+        data.current_task_id = "";
+        changed = true;
     }
     if (changed || sourcePath !== planPath) {
         if (await writeTextIfChanged(planPath, stringifyYaml(data))) {
@@ -139,6 +242,10 @@ function isRecord(value) {
 function isOpenTask(task) {
     return ["pending", "in_progress", "blocked", "pending_revision"].includes(String(task.status));
 }
+function taskById(planData, taskId) {
+    const tasks = Array.isArray(planData.tasks) ? planData.tasks : [];
+    return tasks.find((task) => isRecord(task) && task.id === taskId);
+}
 async function readLegacyCheckpointContract(projectRoot, root, checkpoint) {
     const relative = checkpoint.replace("<harnessRoot>", root);
     const checkpointPath = path.join(projectRoot, relative);
@@ -162,6 +269,16 @@ async function removeLegacyCheckpoints(projectRoot, root, report) {
     await rm(checkpointPath, { recursive: true, force: true });
     report.changed.push(relativeCheckpointPath);
 }
+async function removeLegacyGateResults(projectRoot, root, report) {
+    const relativeGateResultsPath = harnessPath(root, "state", "gate_results.log");
+    const gateResultsPath = path.join(projectRoot, relativeGateResultsPath);
+    if (!(await pathExists(gateResultsPath))) {
+        report.skipped.push(relativeGateResultsPath);
+        return;
+    }
+    await rm(gateResultsPath, { force: true });
+    report.changed.push(relativeGateResultsPath);
+}
 async function ensureMemory(projectRoot, root, report) {
     const relativeMemoryPath = harnessPath(root, "state", "memory.md");
     const memoryPath = path.join(projectRoot, relativeMemoryPath);

package/dist/lib/package-source.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { ensureDir, listFiles, pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { MANAGED_BLOCK_END, MANAGED_BLOCK_START } from "./managed-file.js";
+import { AGENTS_BLOCK_MARKERS } from "./managed-file.js";
 import { SOURCE_MAPPINGS_PATH } from "./paths.js";
 import { parseYaml } from "./yaml.js";
 export async function syncSource(projectRoot) {
@@ -87,10 +87,12 @@ async function renderMapping(projectRoot, mapping) {
     }
     if (mapping.mode === "extract-managed-block") {
         const content = await readText(source);
-        const start = content.indexOf(MANAGED_BLOCK_START);
-        const end = content.indexOf(MANAGED_BLOCK_END);
-        if (start >= 0 && end > start) {
-            return `${content.slice(start + MANAGED_BLOCK_START.length, end).trim()}\n`;
+        for (const markers of AGENTS_BLOCK_MARKERS) {
+            const start = content.indexOf(markers.start);
+            const end = content.indexOf(markers.end);
+            if (start >= 0 && end > start) {
+                return `${content.slice(start + markers.start.length, end).trim()}\n`;
+            }
         }
         return content;
     }

package/dist/lib/sync-engine.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { readConfig } from "./config.js";
 import { harnessRoot } from "./harness-root.js";
 import { copyTree, listFiles, pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { MAKEFILE_BLOCK_END, MAKEFILE_BLOCK_START, MANAGED_BLOCK_END, MANAGED_BLOCK_START } from "./managed-file.js";
+import { AGENTS_BLOCK_MARKERS, MAKEFILE_BLOCK_END, MAKEFILE_BLOCK_MARKERS, MAKEFILE_BLOCK_START, MANAGED_BLOCK_END, MANAGED_BLOCK_START } from "./managed-file.js";
 import { packageAssetPath } from "./paths.js";
 export function emptySyncReport() {
     return {
@@ -38,16 +38,15 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         await syncTree(packageAssetPath("skills"), destination, report);
         return;
     }
-    if (managedFile.path === path.join(root, "managed", "templates") || managedFile.path === ".harness/templates") {
+    if (managedFile.path === path.join(root, "pjsdlc_managed", "templates")) {
         await syncTree(packageAssetPath("templates"), destination, report);
         return;
     }
-    if (managedFile.path === path.join(root, "managed", "policies") || managedFile.path === ".harness/policies") {
+    if (managedFile.path === path.join(root, "pjsdlc_managed", "policies")) {
         await syncTree(packageAssetPath("policies"), destination, report);
         return;
     }
-    if (managedFile.path === path.join(root, "managed", "make", "sdlc-harness.mk") ||
-        managedFile.path === ".harness/make/sdlc-harness.mk") {
+    if (managedFile.path === path.join(root, "pjsdlc_managed", "make", "sdlc-harness.mk")) {
         await syncFile(packageAssetPath("make", "sdlc-harness.mk"), destination, report, "skip-if-missing");
         return;
     }
@@ -73,8 +72,7 @@ async function syncAgentsBlock(destination, root, report) {
     const next = mergeManagedBlock({
         existing,
         block,
-        start: MANAGED_BLOCK_START,
-        end: MANAGED_BLOCK_END,
+        markers: AGENTS_BLOCK_MARKERS,
         pathLabel: "AGENTS.md",
         insert: "append",
         report
@@ -95,7 +93,7 @@ function renderAgentsCore(content, root) {
 async function syncMakefileInclude(destination, root, report) {
     const existing = (await pathExists(destination)) ? await readText(destination) : "";
     const resetDefaultGoal = shouldResetMakeDefaultGoal(existing);
-    const includePath = `${root.replace(/\\/g, "/")}/managed/make/sdlc-harness.mk`;
+    const includePath = `${root.replace(/\\/g, "/")}/pjsdlc_managed/make/sdlc-harness.mk`;
     const blockLines = [
         MAKEFILE_BLOCK_START,
         "# Included before project targets so project recipes win on name conflicts.",
@@ -109,8 +107,7 @@ async function syncMakefileInclude(destination, root, report) {
     const next = mergeManagedBlock({
         existing,
         block,
-        start: MAKEFILE_BLOCK_START,
-        end: MAKEFILE_BLOCK_END,
+        markers: MAKEFILE_BLOCK_MARKERS,
         pathLabel: "Makefile",
         insert: "prepend",
         report
@@ -129,36 +126,27 @@ function shouldResetMakeDefaultGoal(existing) {
     if (!existing.trim()) {
         return false;
     }
-    const startIndex = existing.indexOf(MAKEFILE_BLOCK_START);
-    const endIndex = existing.indexOf(MAKEFILE_BLOCK_END);
-    if (startIndex < 0 && endIndex < 0) {
+    const block = findManagedBlock(existing, MAKEFILE_BLOCK_MARKERS);
+    if (block.status === "missing") {
         return true;
     }
-    if (startIndex < 0 || endIndex < startIndex) {
+    if (block.status === "invalid") {
         return false;
     }
-    const before = existing.slice(0, startIndex);
-    const after = existing.slice(endIndex + MAKEFILE_BLOCK_END.length);
+    const before = existing.slice(0, block.startIndex);
+    const after = existing.slice(block.endIndex + block.markers.end.length);
     return !before.trim() && Boolean(after.trim());
 }
 function mergeManagedBlock(options) {
-    const { existing, block, start, end, pathLabel, insert, report } = options;
-    const startIndex = existing.indexOf(start);
-    const endIndex = existing.indexOf(end);
-    const hasStart = startIndex >= 0;
-    const hasEnd = endIndex >= 0;
-    if (hasStart !== hasEnd || (hasStart && endIndex < startIndex)) {
-        report.blocked.push(`${pathLabel}: incomplete managed block markers`);
+    const { existing, block, markers, pathLabel, insert, report } = options;
+    const found = findManagedBlock(existing, markers);
+    if (found.status === "invalid") {
+        report.blocked.push(`${pathLabel}: ${found.reason}`);
         return undefined;
     }
-    if (hasStart &&
-        (existing.indexOf(start, startIndex + start.length) >= 0 || existing.indexOf(end, endIndex + end.length) >= 0)) {
-        report.blocked.push(`${pathLabel}: duplicate managed block markers`);
-        return undefined;
-    }
-    if (hasStart) {
-        const before = existing.slice(0, startIndex);
-        const after = existing.slice(endIndex + end.length);
+    if (found.status === "found") {
+        const before = existing.slice(0, found.startIndex);
+        const after = existing.slice(found.endIndex + found.markers.end.length);
         return `${before}${block}${after}`;
     }
     if (!existing.trim()) {
@@ -169,6 +157,30 @@ function mergeManagedBlock(options) {
     }
     return `${existing.trimEnd()}\n\n${block}\n`;
 }
+function findManagedBlock(existing, markersList) {
+    const matches = [];
+    for (const markers of markersList) {
+        const startIndex = existing.indexOf(markers.start);
+        const endIndex = existing.indexOf(markers.end);
+        const hasStart = startIndex >= 0;
+        const hasEnd = endIndex >= 0;
+        if (!hasStart && !hasEnd) {
+            continue;
+        }
+        if (hasStart !== hasEnd || endIndex < startIndex) {
+            return { status: "invalid", reason: "incomplete managed block markers" };
+        }
+        if (existing.indexOf(markers.start, startIndex + markers.start.length) >= 0 ||
+            existing.indexOf(markers.end, endIndex + markers.end.length) >= 0) {
+            return { status: "invalid", reason: "duplicate managed block markers" };
+        }
+        matches.push({ markers, startIndex, endIndex });
+    }
+    if (matches.length > 1) {
+        return { status: "invalid", reason: "conflicting managed block marker namespaces" };
+    }
+    return matches[0] ? { status: "found", ...matches[0] } : { status: "missing" };
+}
 async function syncTree(source, destination, report) {
     if (!(await pathExists(source))) {
         report.skipped.push(path.basename(destination));

package/dist/lib/validators.js

@@ -33,8 +33,8 @@ async function validateHarness(projectRoot) {
         harnessPath(root, "state", "lifecycle.yaml"),
         harnessPath(root, "state", "plan.yaml"),
         harnessPath(root, "skills"),
-        harnessPath(root, "managed", "templates"),
-        harnessPath(root, "managed", "policies")
+        harnessPath(root, "pjsdlc_managed", "templates"),
+        harnessPath(root, "pjsdlc_managed", "policies")
     ]) {
         if (!(await pathExists(path.join(projectRoot, required)))) {
             errors.push(`missing ${required}`);
@@ -89,17 +89,28 @@ async function validateDev(projectRoot) {
     const root = await harnessRoot(projectRoot);
     const tasksData = await readYamlObject(path.join(projectRoot, root, "state", "plan.yaml"));
     const tasks = Array.isArray(tasksData.tasks) ? tasksData.tasks : [];
-    if (tasks.length === 0)
-        errors.push("plan.yaml must contain at least one task");
+    const nextTaskSequence = tasksData.next_task_sequence;
+    if (!Number.isInteger(nextTaskSequence) || Number(nextTaskSequence) <= 0) {
+        errors.push("plan.yaml must define positive integer next_task_sequence");
+    }
     const open = tasks.filter((task) => ["pending", "in_progress", "blocked", "pending_revision"].includes(String(task.status)));
     if (open.length > 0)
         errors.push(`Open tasks remain: ${open.map((task) => task.id).join(", ")}`);
+    let maxTaskSequence = 0;
     for (const task of tasks) {
         for (const field of ["id", "title", "status", "summary", "implementation_doc"]) {
             if (!task[field])
                 errors.push(`Task missing ${field}: ${String(task.id ?? "unknown")}`);
         }
+        const taskId = String(task.id ?? "");
+        const match = taskId.match(/^DEV-(\d+)$/);
+        if (match) {
+            maxTaskSequence = Math.max(maxTaskSequence, Number(match[1]));
+        }
         if (["pending", "in_progress", "blocked", "pending_revision"].includes(String(task.status))) {
+            if ("gate_result" in task) {
+                errors.push(`Open task ${task.id} must not define gate_result`);
+            }
             for (const field of ["docs", "allowed_paths", "required_gates", "acceptance_criteria"]) {
                 if (!task[field])
                     errors.push(`Open task ${task.id} missing ${field}`);
@@ -112,19 +123,15 @@ async function validateDev(projectRoot) {
             }
         }
         else {
-            for (const field of ["docs", "allowed_paths", "required_gates", "acceptance_criteria", "working_notes"]) {
+            errors.push(`Completed task ${task.id} must not remain in plan.yaml`);
+            for (const field of ["docs", "allowed_paths", "required_gates", "acceptance_criteria", "working_notes", "gate_result"]) {
                 if (task[field])
                     errors.push(`Closed task ${task.id} must not retain ${field}`);
             }
         }
     }
-    for (const task of tasks.filter((task) => task.status === "done")) {
-        if (task.gate_result !== "PASS")
-            errors.push(`Done task ${task.id} must have gate_result PASS`);
-        const implementationDoc = String(task.implementation_doc ?? "");
-        if (implementationDoc && !(await pathExists(path.join(projectRoot, implementationDoc)))) {
-            errors.push(`Implementation doc missing for ${task.id}: ${implementationDoc}`);
-        }
+    if (Number.isInteger(nextTaskSequence) && Number(nextTaskSequence) <= maxTaskSequence) {
+        errors.push("next_task_sequence must be greater than task ids currently in plan.yaml");
     }
     return { info: [`validate-dev checked ${tasks.length} task(s)`], errors };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-project-sdlc",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI and canonical assets for the AI SDLC Harness workflow.",
   "type": "module",
   "bin": {

package/source-mappings.yaml

@@ -5,15 +5,15 @@ source_mappings:
   - source: ".agent/skills"
     target: "packages/sdlc-harness/assets/skills"
     mode: "copy-tree"
-  - source: ".agent/managed/templates"
+  - source: ".agent/pjsdlc_managed/templates"
     target: "packages/sdlc-harness/assets/templates"
     mode: "copy-tree"
-  - source: ".agent/managed/policies"
+  - source: ".agent/pjsdlc_managed/policies"
     target: "packages/sdlc-harness/assets/policies"
     mode: "copy-tree"
-  - source: "Makefile"
+  - source: ".agent/pjsdlc_managed/make/sdlc-harness.mk"
     target: "packages/sdlc-harness/assets/make/sdlc-harness.mk"
-    mode: "extract-harness-targets"
+    mode: "copy-file"
   - source: ".github/workflows/harness.yml"
     target: "packages/sdlc-harness/assets/github/harness.yml"
     mode: "copy-file"