agent-project-sdlc 0.1.4 → 0.1.5

package/assets/agents/AGENTS_CORE.md

@@ -1,14 +1,14 @@
 # AI SDLC Harness Protocol
 
-本仓库使用 AI SDLC Harness 工作流。开始任何工作前，把 `.agent/` 和 `.docs/`
+本仓库使用 AI SDLC Harness 工作流。开始任何工作前，把 `.codex/` 和 `.docs/`
 视为项目事实源。
 
 ## 事实源
 
-- 生命周期状态：`.agent/state/lifecycle.yaml`
-- 执行计划：`.agent/state/plan.yaml`
-- 计划草案：`.agent/state/plan.draft.yaml`
-- 项目长期记忆：`.agent/state/memory.md`
+- 生命周期状态：`.codex/state/lifecycle.yaml`
+- 执行计划：`.codex/state/plan.yaml`
+- 计划草案：`.codex/state/plan.draft.yaml`
+- 项目长期记忆：`.codex/state/memory.md`
 - 产品文档：`.docs/01_product/`
 - 架构文档：`.docs/02_architecture/`
 - 技术方案：`.docs/03_tech_plan/`
@@ -18,6 +18,7 @@
 - 发布文档：`.docs/08_release/`
 - RFC 文档：`.docs/rfc/`
 - 全局文档索引：`.docs/INDEX.md`
+- Harness authoring skills（如果存在）：`.codex/skills/authoring/`，只在维护 Harness/workflow/npm package 源码或本仓库自举规则时读取，不作为用户项目默认分发内容
 
 ## 派生视图
 
@@ -39,20 +40,20 @@
 - 历史 task 查询默认面向产物结果和变更意图，读取模块级 implementation doc、RFC、PRD、tech plan 和代码；task id 和 commit 只作为 provenance，`allowed_paths`、`required_gates`、临时 `working_notes` 是执行期约束，不作为历史查询 API。
 - 过去 phase/task/gate 执行流水不是默认上下文；除非用户明确要求 forensic/audit/regression 追溯，否则不要读取或恢复历史执行信息。
 
-## Prompt Language Contract
+## Skill Language Contract
 
 - 面向人阅读的说明、规则、SOP、检查清单使用中文。
 - 机器契约保持英文，包括字段名、路径、命令、阶段枚举、状态枚举、脚本参数。
-- 不翻译 `.agent/state/*.yaml`、`.agent/pjsdlc_managed/policies/*.yaml` 中的 key。
+- 不翻译 `.codex/state/*.yaml`、`.codex/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/pjsdlc_managed/templates/*.md` 时，遵循“中文解释 + 英文精确标识符”。Harness 根目录由 `package.json#sdlcHarness.harnessFolderName` 或 `sdlc-harness.config.json#harnessFolderName` 决定；未配置的项目默认使用 `.agent`。
+- 不翻译 `make validate-*`、`python3 tools/transition.py --to <PHASE>`、`.docs/01_product/`、`.codex/state/plan.yaml` 等命令和路径。
+- 后续更新 `.codex/skills/*/SKILL.md`、`.codex/skills/authoring/*/SKILL.md` 或 `.codex/pjsdlc_managed/templates/*.md` 时，遵循“中文解释 + 英文精确标识符”。Harness 根目录由 `package.json#sdlcHarness.harnessFolderName` 或 `sdlc-harness.config.json#harnessFolderName` 决定；本仓库显式配置为 `.codex`。
 
 ## 通用执行原则
 
-以下原则完整迁移自 `multica-ai/andrej-karpathy-skills` 的 MIT guideline，并按本仓库的 Prompt Language Contract 转为“中文说明 + 英文关键词”形式，与阶段化 Harness 协议合并执行。
+以下原则完整迁移自 `multica-ai/andrej-karpathy-skills` 的 MIT guideline，并按本仓库的 Skill Language Contract 转为“中文说明 + 英文关键词”形式，与阶段化 Harness 协议合并执行。
 
 ### Karpathy Guidelines（MIT 完整本地化）
 
@@ -122,15 +123,15 @@ Strong success criteria 可以让你 independent loop。Weak criteria，例如
 
 ### Harness 补充原则
 
-1. 阶段约束优先：除非用户明确要求其它工作流动作，否则使用 `active_skill` 指定的 Skill，并服从当前阶段的 allowed paths、required gates 和交付物边界。
+1. 阶段约束优先：除非用户明确要求其它工作流动作，否则使用 `active_skill` 指定的 workflow skill，并服从当前阶段的 allowed paths、required gates 和交付物边界。
 2. 文档先于实现：产品文档和技术方案未形成前，不写业务代码；需求变更必须进入 RFC 工作流。
 3. 验证闭环：多步骤工作先给出简短计划，并为关键步骤绑定验证方式。除非被阻塞，否则持续迭代到对应 `required_gates`、阶段 gate 或明确的人工验收标准满足。
 4. 派生物可再生成：`overview.md`、包内 assets 等 generated artifact 必须由对应命令刷新，不手写局部补丁。
 
 ## 工作规则
 
-1. 选择任何角色或 Skill 前，先读取 `.agent/state/lifecycle.yaml`。
-2. 除非用户明确要求其它工作流动作，否则使用 `active_skill` 指定的 Skill。
+1. 选择任何角色或 skill 前，先读取 `.codex/state/lifecycle.yaml`。
+2. 除非用户明确要求其它工作流动作，否则使用 `active_skill` 指定的 workflow skill。
 3. 产品文档和技术方案未形成前，不写业务代码。
 4. 在 `SPRINTING` 阶段，一次只执行一个任务。
 5. 在 `SPRINTING` 阶段，只编辑当前 open task 的 `allowed_paths` 允许的文件。
@@ -138,7 +139,7 @@ Strong success criteria 可以让你 independent loop。Weak criteria，例如
 7. 代码 gate 通过后，更新相关 implementation doc 和 `.docs/INDEX.md`。
 8. `reviewer` 角色只读，不直接修改源码。
 9. 需求变更必须进入 RFC 工作流。
-10. task/release 历史动作记录使用 git commit、tag 或外部 release 系统，不维护 `.agent/archive/` 常规归档。
+10. task/release 历史动作记录使用 git commit、tag 或外部 release 系统，不维护 `<harnessRoot>/archive/` 常规归档。
 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` 中包含完整执行合同，再继续推进或交接。
@@ -148,27 +149,31 @@ Strong success criteria 可以让你 independent loop。Weak criteria，例如
 
 ## 自然语言与宏指令
 
-用户不需要记忆或使用宏指令。自然语言意图和约定宏指令是两层入口：自然语言是默认控制方式，`/xxx` 是快捷入口、调试入口或自动化入口。两者应映射到同一组 workflow action。
+用户不需要记忆或使用宏指令。自然语言意图和约定宏指令是两层入口：自然语言是默认控制方式，`/xxx` 是更完整、更细节的提示词别名，也可作为调试入口或自动化入口。两者应映射到同一组 workflow action；自然语言入口成本更低，但细节约束更依赖 Agent 根据上下文判断。
 
-当用户用自然语言表达意图时，Agent 应先读取 `.agent/state/lifecycle.yaml` 和必要的 `.agent/state/plan.yaml`，再映射到对应 workflow action：
+当用户用自然语言表达意图时，Agent 应先读取 `.codex/state/lifecycle.yaml` 和必要的 `.codex/state/plan.yaml`，再映射到对应 workflow action：
 
 - “现在到哪了 / 状态如何” → 等价 `/status`。
 - “继续 / 下一步 / 推进” → 等价 `/next`。
 - “能进入下一阶段吗 / 进入下一步” → 等价 `/advance`。
 - “需求变了 / 这个设计要改” → 进入 RFC workflow。
+- “完善产品方案 / 写 PRD / 我提供信息，你帮我完善产品方案” → 等价 `/prd`。
+- “设计技术方案 / 做架构方案 / 根据 PRD 做技术方案” → 等价 `/design`。
 - “开始开发 / 做当前任务 / 做下一个任务” → 等价 `/dev`。
 - “开始循环：写任务，执行任务 / 把开发循环跑完” → 等价 `/devloop`。
 - “跑测试 / 验证一下” → 运行当前 task 或阶段对应 gate。
 - “准备 review / 帮我 review” → 进入只读 Review workflow。
 - “刷新文档总览 / 同步 overview” → 等价 `/overview`。
-- `/plan` 和 `/goal` 是客户端模式入口，不由 Harness 自动开启；用户可以手动组合，例如 `/plan 完善产品方案`、`/goal /devloop` 或 `/goal 开始循环：写任务，执行任务`。
+- `/plan` 和 `/goal` 是客户端模式入口，不由 Harness 自动开启；用户可以手动组合，例如 `/plan /prd`、`/plan 完善产品方案`、`/goal /devloop` 或 `/goal 开始循环：写任务，执行任务`。
 
 如果自然语言意图会改变阶段、创建或删除 task、提交、push 或发布，Agent 先用一句话说明将执行的动作和验证方式，再继续。
 
 - `/status`：报告当前阶段、角色、任务、阻塞项和下一步动作。
-- `/next`：运行当前阶段映射的 Skill。
+- `/next`：运行当前阶段映射的 workflow skill。
 - `/advance`：校验当前阶段出口 gate，通过后才尝试流转。
 - `/rfc <file>`：挂起当前流程并进入 RFC recalibration。
+- `/prd`：在 `REQUIREMENT_GATHERING` 调用产品方案工作流，澄清需求并更新 PRD、验收标准、open questions、`.docs/INDEX.md` 和 overview。
+- `/design`：在 `ARCHITECTING` 调用架构和技术方案工作流，基于 PRD 更新 architecture、tech plan 和 `plan.draft.yaml`。
 - `/dev`：在 `SPRINTING` 创建或选择下一个最小 DEV task，执行一个 task，跑 gate，更新模块级 implementation doc，按两段 commit/push 闭环后停止。
 - `/devloop`：在 `SPRINTING` 连续运行 `/dev` 循环，直到没有明确可创建/执行的任务，或遇到需求、架构、allowed_paths、gate、commit/push blocker。
 - `/syncdocs`：同步 `.docs/INDEX.md` 与当前文档事实源。
@@ -178,11 +183,11 @@ Strong success criteria 可以让你 independent loop。Weak criteria，例如
 
 ## 阶段流转
 
-正常阶段流转不要手动编辑 `.agent/state/lifecycle.yaml`。使用：
+正常阶段流转不要手动编辑 `.codex/state/lifecycle.yaml`。使用：
 
 ```sh
 python3 tools/transition.py --to <PHASE>
 ```
 
 流转前先运行阶段 gate，通常使用 `make validate-current`，或使用
-`.agent/pjsdlc_managed/policies/phase_contracts.yaml` 中列出的具体 `make validate-*` 目标。
+`.codex/pjsdlc_managed/policies/phase_contracts.yaml` 中列出的具体 `make validate-*` 目标。

package/assets/skills/pjsdlc_dev_sprint/SKILL.md

@@ -47,7 +47,7 @@ description: Use during SPRINTING to execute one task from plan.yaml, respecting
 - 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。
+- gate 通过后调用 `pjsdlc_implementation_doc`，由该 Skill 按真实实现更新或新增 `.docs/04_implementation/` 模块级 slice。
 - 如果一个任务实际变成多个独立实现边界，应停止扩大范围，拆分后续任务或回到任务规划。
 - `/dev` 是单任务执行入口：没有 open task 时，先根据 PRD、architecture、tech plan 和 `plan.draft.yaml` 创建一个最小 open task；已有 open task 时，直接执行该 task；完成后停止。
 - `/devloop` 是连续执行入口：每完成一个 task 并 push 两段提交后，重新读取 lifecycle、plan、PRD、architecture 和 tech plan，再决定是否创建/执行下一个最小 task；没有明确任务或出现 blocker 时停止并报告。
@@ -73,7 +73,7 @@ done task 的执行流水不在当前 `plan.yaml` 长期保留，也不是默认
 4. 必须运行当前 task 的 `required_gates`。
 5. 如果 gate 因代码或测试逻辑失败，在任务范围内修复。
 6. 如果 gate 因基础设施、凭证缺失、产品行为不清或高风险架构变化失败，进入 `BLOCKED`。
-7. gate 通过后调用 `implementation_doc`。
+7. gate 通过后调用 `pjsdlc_implementation_doc`。
 8. 只有 gate 通过且 implementation doc 校验通过后，才能把任务标记为 `done`。
 9. 任务完成并写入或更新相关 implementation doc、刷新 `overview.md`、记录 gate 后，先创建 task implementation commit；此时不要移除该 task。
 10. task implementation commit 必须发生在 task 移除前；后续默认不要读取其中的执行期字段，历史查询以模块级 implementation doc、RFC、PRD、tech plan 和代码为主。

package/assets/skills/pjsdlc_manager/SKILL.md

@@ -16,7 +16,9 @@ Skill、执行出口 gate，并记录 blocker。
 
 与用户对话时，先读取 lifecycle 和 plan，再说明当前阶段、active_skill、当前任务、阻塞项和下一步。不要基于猜测切换阶段；如果用户要求的动作与当前阶段冲突，说明冲突、可选路径和推荐处理方式。
 
-自然语言是默认控制方式，约定宏指令是等价快捷入口。用户说“状态如何”“继续”“下一步”“开始开发”“开始循环：写任务，执行任务”“跑测试”“准备 review”“需求变了”等，不应要求用户记忆 `/xxx`；你应先读取 lifecycle 和 plan，再把意图映射到对应 workflow action。执行 `/status`、`/next`、`/advance`、`/rfc`、`/dev`、`/devloop` 等宏指令时，输出要短而明确：当前事实是什么、将调用哪个 gate 或 Skill、成功后会进入哪里、失败时如何保持状态安全。
+自然语言是默认控制方式，约定宏指令是更完整、更细节的提示词别名。用户说“状态如何”“继续”“下一步”“完善产品方案”“设计技术方案”“开始开发”“开始循环：写任务，执行任务”“跑测试”“准备 review”“需求变了”等，不应要求用户记忆 `/xxx`；你应先读取 lifecycle 和 plan，再把意图映射到对应 workflow action。执行 `/status`、`/next`、`/advance`、`/rfc`、`/prd`、`/design`、`/dev`、`/devloop` 等宏指令时，输出要短而明确：当前事实是什么、将调用哪个 gate 或 Skill、成功后会进入哪里、失败时如何保持状态安全。
+
+自然语言和宏指令必须进入同一组 workflow action；区别在于 `/xxx` 入口携带更稳定的细节约束，简单自然语言入口更低成本，但需要你根据当前阶段、plan 和文档上下文补足细节。
 
 ## 输入
 
@@ -35,19 +37,21 @@ Skill、执行出口 gate，并记录 blocker。
 6. 用户输入 `/status` 时，运行 `make status`。
 7. 用户输入 `/next` 时，调用 `active_skill` 映射的 Skill。
 8. 用户输入 `/advance` 时，运行 `make validate-current`，通过后流转到配置的 `next` 阶段。
-9. 用户输入 `/rfc <file>` 时，流转到 `RFC_RECALIBRATION` 并调用 `rfc_recalibrate`。
+9. 用户输入 `/rfc <file>` 时，流转到 `RFC_RECALIBRATION` 并调用 `pjsdlc_rfc_recalibrate`。
 10. 如果当前 task 处于 `blocked` 或缺少 open task 必需的 plan 字段，不要推进阶段，先要求 `plan.yaml` 完整。
 11. 用户自然语言询问状态时，等价执行 `/status`。
 12. 用户自然语言要求继续、推进或下一步时，等价执行 `/next`。
 13. 用户自然语言要求进入下一阶段或检查是否可进入下一阶段时，等价执行 `/advance`。
 14. 用户自然语言表达需求或设计变化时，进入 RFC workflow。
-15. 用户输入 `/dev`，或自然语言要求“开始开发”“做当前任务”“做下一个任务”“继续开发下一个任务”时，如果 `current_phase` 是 `SPRINTING`，创建或选择一个最小 DEV task 并执行一个 task 闭环；否则说明当前阶段冲突和推荐路径。
-16. 用户输入 `/devloop`，或自然语言要求“开始循环：写任务，执行任务”“把开发循环跑完”“连续开发”时，如果 `current_phase` 是 `SPRINTING`，连续运行 `/dev` 循环，直到没有明确可做任务或遇到 blocker；否则说明当前阶段冲突和推荐路径。
-17. 用户自然语言要求跑测试或验证时，运行当前 task 或当前阶段的对应 gate。
-18. 用户自然语言要求 review 时，进入只读 Review workflow，不直接改源码。
-19. 用户自然语言要求刷新文档总览时，运行 `make docs-overview`。
-20. `/plan` 和 `/goal` 是客户端模式入口，不由 Harness 自动开启；如果用户手动组合 `/plan` 或 `/goal` 与自然语言或宏指令，应按对应 workflow action 继续执行。
-21. 如果动作会改变阶段、创建或删除 task、提交、push 或发布，先用一句话说明即将执行的动作和验证方式，再继续。
+15. 用户输入 `/prd`，或自然语言要求“完善产品方案”“写 PRD”“我提供信息，你帮我完善产品方案”时，如果 `current_phase` 是 `REQUIREMENT_GATHERING`，调用产品方案工作流并更新 PRD、验收标准和 open questions；否则说明当前阶段冲突和推荐路径。
+16. 用户输入 `/design`，或自然语言要求“设计技术方案”“做架构方案”“根据 PRD 做技术方案”时，如果 `current_phase` 是 `ARCHITECTING`，调用架构和技术方案工作流并更新 architecture、tech plan 和 `plan.draft.yaml`；否则说明当前阶段冲突和推荐路径。
+17. 用户输入 `/dev`，或自然语言要求“开始开发”“做当前任务”“做下一个任务”“继续开发下一个任务”时，如果 `current_phase` 是 `SPRINTING`，创建或选择一个最小 DEV task 并执行一个 task 闭环；否则说明当前阶段冲突和推荐路径。
+18. 用户输入 `/devloop`，或自然语言要求“开始循环：写任务，执行任务”“把开发循环跑完”“连续开发”时，如果 `current_phase` 是 `SPRINTING`，连续运行 `/dev` 循环，直到没有明确可做任务或遇到 blocker；否则说明当前阶段冲突和推荐路径。
+19. 用户自然语言要求跑测试或验证时，运行当前 task 或当前阶段的对应 gate。
+20. 用户自然语言要求 review 时，进入只读 Review workflow，不直接改源码。
+21. 用户自然语言要求刷新文档总览时，运行 `make docs-overview`。
+22. `/plan` 和 `/goal` 是客户端模式入口，不由 Harness 自动开启；如果用户手动组合 `/plan` 或 `/goal` 与自然语言或宏指令，应按对应 workflow action 继续执行。
+23. 如果动作会改变阶段、创建或删除 task、提交、push 或发布，先用一句话说明即将执行的动作和验证方式，再继续。
 
 ## Plan Protocol
 

package/dist/commands/index.js

@@ -21,7 +21,7 @@ export const commands = {
 export function help() {
     console.log(`sdlc-harness commands:
   init [--adopt] [--harness-folder <path>]
-                       Initialize a new project or adopt an existing one
+                       Initialize/adopt a project; without --harness-folder, choose target agent first
   sync                 Materialize canonical assets into the workspace
   upgrade              Run migrations and then sync
   doctor               Diagnose project configuration and drift

package/dist/commands/init.d.ts

@@ -1,2 +1,3 @@
 export declare function init(args: string[]): Promise<void>;
 export declare function resolveInitHarnessRoot(projectRoot: string, args: string[]): Promise<string | undefined>;
+export declare function resolveAgentHarnessFolderName(agentAnswer: string, customFolderAnswer?: string): string;

package/dist/commands/init.js

@@ -4,6 +4,15 @@ import { runInit } from "../lib/init.js";
 import { normalizeHarnessFolderName, readHarnessRootConfig } from "../lib/harness-root.js";
 import { writePackageHarnessRoot } from "../lib/package-json-config.js";
 import { DEFAULT_HARNESS_ROOT } from "../lib/paths.js";
+const AGENT_HARNESS_OPTIONS = [
+    { key: "codex", label: "Codex", harnessFolderName: ".codex" },
+    { key: "claude", label: "Claude Code", harnessFolderName: ".claude" },
+    { key: "cursor", label: "Cursor", harnessFolderName: ".cursor" },
+    { key: "cline", label: "Cline", harnessFolderName: ".cline" },
+    { key: "roo", label: "Roo Code", harnessFolderName: ".roo" },
+    { key: "gemini", label: "Gemini CLI", harnessFolderName: ".gemini" },
+    { key: "other", label: "Other" }
+];
 export async function init(args) {
     const adopt = args.includes("--adopt");
     const force = args.includes("--force");
@@ -27,21 +36,64 @@ export async function resolveInitHarnessRoot(projectRoot, args) {
     if (current.source !== "default") {
         return undefined;
     }
-    return promptHarnessRoot(DEFAULT_HARNESS_ROOT);
+    return promptAgentHarnessRoot();
 }
-async function promptHarnessRoot(defaultRoot) {
+async function promptAgentHarnessRoot() {
     if (!input.isTTY || !output.isTTY) {
-        return defaultRoot;
+        return resolveAgentHarnessFolderName("");
     }
     const rl = readline.createInterface({ input, output });
     try {
-        const answer = await rl.question(`Harness folder name (default ${defaultRoot}; press Enter to use default): `);
-        return normalizeHarnessFolderName(answer.trim() || defaultRoot);
+        const agent = await questionUntilValid(rl, `${formatAgentChoices()}\nTarget agent (default 1 Codex): `);
+        const option = agentOptionForAnswer(agent);
+        if (option?.harnessFolderName) {
+            return normalizeHarnessFolderName(option.harnessFolderName);
+        }
+        const folder = await rl.question(`Harness folder name (default ${DEFAULT_HARNESS_ROOT}; press Enter to use default): `);
+        return normalizeHarnessFolderName(folder.trim() || DEFAULT_HARNESS_ROOT);
     }
     finally {
         rl.close();
     }
 }
+async function questionUntilValid(rl, query) {
+    while (true) {
+        const answer = await rl.question(query);
+        if (agentOptionForAnswer(answer)) {
+            return answer;
+        }
+        console.log("Unknown agent choice. Enter a number, agent name, or Other.");
+    }
+}
+function formatAgentChoices() {
+    const lines = ["Choose target agent:"];
+    AGENT_HARNESS_OPTIONS.forEach((option, index) => {
+        const folder = option.harnessFolderName ? ` -> ${option.harnessFolderName}` : "";
+        lines.push(`${index + 1}) ${option.label}${folder}`);
+    });
+    return lines.join("\n");
+}
+export function resolveAgentHarnessFolderName(agentAnswer, customFolderAnswer = "") {
+    const option = agentOptionForAnswer(agentAnswer);
+    if (!option) {
+        throw new Error("Unknown agent choice");
+    }
+    return normalizeHarnessFolderName(option.harnessFolderName ?? (customFolderAnswer.trim() || DEFAULT_HARNESS_ROOT));
+}
+function agentOptionForAnswer(answer) {
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized) {
+        return AGENT_HARNESS_OPTIONS[0];
+    }
+    const index = Number.parseInt(normalized, 10);
+    if (Number.isInteger(index) && String(index) === normalized) {
+        return AGENT_HARNESS_OPTIONS[index - 1];
+    }
+    return AGENT_HARNESS_OPTIONS.find((option) => {
+        const label = option.label.toLowerCase();
+        return option.key === normalized || label === normalized || label.replace(/\s+/g, "-") === normalized;
+    });
+}
 function valueForArg(args, name) {
     const prefix = `${name}=`;
     const inline = args.find((arg) => arg.startsWith(prefix));

package/dist/lib/migrations.js

@@ -1,7 +1,7 @@
 import path from "node:path";
-import { rename, rm } from "node:fs/promises";
+import { readdir, rename, rm } from "node:fs/promises";
 import { readConfig } from "./config.js";
-import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { ensureDir, listFiles, 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";
@@ -49,12 +49,15 @@ async function migrateConfig(projectRoot, root, report) {
     }
 }
 async function migrateLegacyManagedPaths(projectRoot, root, report) {
+    await movePromptTreeToSkillsIfDestinationMissing(projectRoot, harnessPath(root, "prompts"), harnessPath(root, "skills"), report);
+    await moveIfDestinationMissing(projectRoot, ".agents/skills", harnessPath(root, "skills"), report);
+    await moveIfDestinationMissing(projectRoot, ".harness/agents/skills", harnessPath(root, "skills"), 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) {
+async function movePromptTreeToSkillsIfDestinationMissing(projectRoot, legacyRelativePath, nextRelativePath, report) {
     const legacyPath = path.join(projectRoot, legacyRelativePath);
     if (!(await pathExists(legacyPath))) {
         report.skipped.push(legacyRelativePath);
@@ -67,6 +70,37 @@ async function moveIfDestinationMissing(projectRoot, legacyRelativePath, nextRel
     }
     await ensureDir(path.dirname(nextPath));
     await rename(legacyPath, nextPath);
+    const workflowPath = path.join(nextPath, "workflow");
+    if (await pathExists(workflowPath)) {
+        for (const entry of await readdir(workflowPath)) {
+            await rename(path.join(workflowPath, entry), path.join(nextPath, entry));
+        }
+        await rm(workflowPath, { recursive: true, force: true });
+    }
+    for (const file of await listFiles(nextPath)) {
+        if (path.basename(file) === "PROMPT.md") {
+            await rename(file, path.join(path.dirname(file), "SKILL.md"));
+        }
+    }
+    report.changed.push(`${legacyRelativePath} -> ${nextRelativePath}`);
+}
+async function moveIfDestinationMissing(projectRoot, legacyRelativePath, nextRelativePath, report) {
+    const legacyPath = path.join(projectRoot, legacyRelativePath);
+    const nextPath = path.join(projectRoot, nextRelativePath);
+    if (legacyPath === nextPath) {
+        report.skipped.push(legacyRelativePath);
+        return;
+    }
+    if (!(await pathExists(legacyPath))) {
+        report.skipped.push(legacyRelativePath);
+        return;
+    }
+    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) {
@@ -87,7 +121,10 @@ function migrateManagedFiles(managedFiles, root) {
         migrated.push(item);
     };
     for (const item of managedFiles) {
-        if (item.path === ".agents/skills" || item.path === ".harness/agents/skills") {
+        if (item.path === ".agents/skills" ||
+            item.path === ".harness/agents/skills" ||
+            item.path === harnessPath(root, "skills") ||
+            item.path === harnessPath(root, "prompts")) {
             push({ path: harnessPath(root, "skills"), strategy: "managed" });
             continue;
         }
@@ -126,11 +163,19 @@ async function migrateLifecycle(projectRoot, root, report) {
     }
     const data = (parseYaml(await readText(lifecyclePath)) ?? {});
     let changed = false;
-    const activeSkill = String(data.active_skill ?? "");
+    const activeSkill = String(data.active_skill ?? data.active_prompt ?? "");
     if (SKILL_RENAMES[activeSkill]) {
         data.active_skill = SKILL_RENAMES[activeSkill];
         changed = true;
     }
+    else if (activeSkill && !data.active_skill) {
+        data.active_skill = activeSkill;
+        changed = true;
+    }
+    if ("active_prompt" in data) {
+        delete data.active_prompt;
+        changed = true;
+    }
     if ("history" in data) {
         delete data.history;
         changed = true;

package/dist/lib/package-source.js

@@ -81,7 +81,11 @@ async function renderMapping(projectRoot, mapping) {
             if (path.basename(file) === ".gitkeep") {
                 continue;
             }
-            rendered.push({ relative: path.relative(source, file), content: await readText(file) });
+            const relative = path.relative(source, file);
+            if (isExcluded(relative, mapping.exclude ?? [])) {
+                continue;
+            }
+            rendered.push({ relative, content: await readText(file) });
         }
         return rendered;
     }
@@ -101,6 +105,17 @@ async function renderMapping(projectRoot, mapping) {
     }
     throw new Error(`Unsupported source mapping mode: ${mapping.mode}`);
 }
+function isExcluded(relativePath, patterns) {
+    const normalized = relativePath.split(path.sep).join("/");
+    return patterns.some((pattern) => {
+        const normalizedPattern = pattern.replace(/\\/g, "/");
+        if (normalizedPattern.endsWith("/**")) {
+            const prefix = normalizedPattern.slice(0, -3);
+            return normalized === prefix || normalized.startsWith(`${prefix}/`);
+        }
+        return normalized === normalizedPattern;
+    });
+}
 function normalize(content) {
     return content.replace(/\r\n/g, "\n").trimEnd();
 }

package/dist/lib/sync-engine.js

@@ -30,12 +30,14 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         await syncMakefileInclude(destination, root, report);
         return;
     }
-    if (managedFile.path === path.join(root, "skills") || managedFile.path === ".harness/agents/skills") {
+    if (managedFile.path === path.join(root, "skills")) {
         await syncTree(packageAssetPath("skills"), destination, report);
         return;
     }
-    if (managedFile.path === ".agents/skills" && root !== ".agents") {
-        await syncTree(packageAssetPath("skills"), destination, report);
+    if (managedFile.path === path.join(root, "skills") ||
+        managedFile.path === ".harness/agents/skills" ||
+        (managedFile.path === ".agents/skills" && root !== ".agents")) {
+        await syncTree(packageAssetPath("skills"), path.join(projectRoot, root, "skills"), report);
         return;
     }
     if (managedFile.path === path.join(root, "pjsdlc_managed", "templates")) {
@@ -88,7 +90,7 @@ async function syncAgentsBlock(destination, root, report) {
     }
 }
 function renderAgentsCore(content, root) {
-    return content.replaceAll(".agent", root);
+    return content.replaceAll(".agent", root).replaceAll(".codex", root);
 }
 async function syncMakefileInclude(destination, root, report) {
     const existing = (await pathExists(destination)) ? await readText(destination) : "";

package/dist/lib/types.d.ts

@@ -15,6 +15,7 @@ export interface ManagedFile {
 export interface SourceMapping {
     source: string;
     target: string;
+    exclude?: string[];
     mode: "extract-managed-block" | "copy-tree" | "copy-file" | "extract-harness-targets";
 }
 export interface SourceMappingsFile {

package/package.json

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

package/source-mappings.yaml

@@ -2,16 +2,18 @@ source_mappings:
   - source: "AGENTS.md"
     target: "packages/sdlc-harness/assets/agents/AGENTS_CORE.md"
     mode: "extract-managed-block"
-  - source: ".agent/skills"
+  - source: ".codex/skills"
     target: "packages/sdlc-harness/assets/skills"
     mode: "copy-tree"
-  - source: ".agent/pjsdlc_managed/templates"
+    exclude:
+      - "authoring/**"
+  - source: ".codex/pjsdlc_managed/templates"
     target: "packages/sdlc-harness/assets/templates"
     mode: "copy-tree"
-  - source: ".agent/pjsdlc_managed/policies"
+  - source: ".codex/pjsdlc_managed/policies"
     target: "packages/sdlc-harness/assets/policies"
     mode: "copy-tree"
-  - source: ".agent/pjsdlc_managed/make/sdlc-harness.mk"
+  - source: ".codex/pjsdlc_managed/make/sdlc-harness.mk"
     target: "packages/sdlc-harness/assets/make/sdlc-harness.mk"
     mode: "copy-file"
   - source: ".github/workflows/harness.yml"