@elvis1513/auto-coding-skill 1.0.2 → 2.0.0

package/README.md

@@ -5,7 +5,7 @@ Engineering workflow skill for:
 - Claude Code
 - Codex CLI
 
-This skill targets Go backend + frontend monorepo projects that rely on Jenkins for build and deployment. The optimized default flow is lightweight locally, then Jenkins-first and target-environment-first for real verification.
+This skill targets Go backend + frontend monorepo projects that rely on Jenkins for build and deployment. The default `dev` mode is optimized for fast development: light gate, early closure record, commit, push, then move to the next task. Switch to `verify` mode when Jenkins and target-environment evidence must be completed before closure.
 
 `docs/ENGINEERING.md` is intentionally Git-tracked. The environment fields kept in that file are mandatory, must be filled with real values, and are committed as part of project maintenance. Unused environment items should be removed instead of being kept as placeholders.
 
@@ -39,9 +39,20 @@ npm install -g git+https://github.com/elvis1513/auto-coding-skill.git
 
 ## Optimized Standard Flow
 
-默认闭环：
+模式由 `docs/ENGINEERING.md` 顶部控制：
 
-`需求/任务记录 -> 最小设计 -> 开发 -> 本地轻量校验 -> commit/push -> Jenkins 构建部署 -> 目标环境验证 -> 闭环记录`
+```yaml
+workflow:
+  mode: "dev" # dev | verify
+```
+
+`dev` 默认闭环：
+
+`需求/任务记录 -> 最小设计 -> 开发 -> 本地轻量校验 -> 写 DEV-CLOSED 闭环 -> commit/push -> 结束`
+
+`verify` 完整闭环：
+
+`需求/任务记录 -> 最小设计 -> 开发 -> 本地轻量校验 -> commit/push -> Jenkins 构建部署验证 -> 目标环境验证 -> 写 PASS 闭环`
 
 具体执行顺序：
 
@@ -58,16 +69,18 @@ npm install -g git+https://github.com/elvis1513/auto-coding-skill.git
    - `git diff --check`
    - API 文档检查
    - Jenkins 配置检查
-5. 立即提交推送
-   - 本地轻量校验通过后，commit + push，触发 Jenkins。
+5. 提交推送
+   - `dev` 模式：轻量校验通过后，先写 `DEV-CLOSED` 闭环，再 commit + push，触发 Jenkins 后结束。
+   - `verify` 模式：commit + push 后继续等待 Jenkins 和目标环境验证。
 6. Jenkins 验证
-   - 看 Jenkins 构建、镜像、部署结果；失败则基于 Jenkins 日志修复并再次提交。
+   - 仅 `verify` 模式默认执行。看 Jenkins 构建、镜像、部署结果；失败则基于 Jenkins 日志修复并再次提交。
 7. 目标环境验证
-   - 在真实目标环境做健康检查、关键接口、关键页面或业务路径验证。
+   - 仅 `verify` 模式默认执行。在真实目标环境做健康检查、关键接口、关键页面或业务路径验证。
 8. 回归与证据记录
    - 只有真实执行过 Jenkins / 目标环境验证，或明确要求本地运行验证时，才把 regression matrix 写成 `PASS`。
 9. 闭环记录
-   - 每个任务默认必须留下轻量闭环记录。
+   - `dev` 模式记录 `DEV-CLOSED`，表示开发闭环完成但 Jenkins/目标环境未验证。
+   - `verify` 模式记录 `PASS` / `FAIL` / `PARTIAL`，必须基于真实验证结果。
 
 ## Default vs On-demand
 
@@ -112,12 +125,14 @@ This frontmatter is the only manual config source.
 It must be committed to Git. Do not add it to `.gitignore`.
 
 重点字段：
+- `workflow.mode`
 - `commands.*`
 - `target_env.*`
 - `jenkins.*`
 - `docs.*`
 
 默认必填：
+- `workflow.mode`
 - `project.name`
 - `commands.light_gate` 或 `commands.quick_test` 或 `commands.test` 或 `commands.build`
 - `target_env.name`
@@ -189,7 +204,8 @@ It must be committed to Git. Do not add it to `.gitignore`.
 ## Default Gate Policy
 - Default local gate is lightweight only.
 - Do not require local Docker Compose or full local regression unless the task explicitly needs local runtime diagnosis.
-- Push is not the finish line: Jenkins success, target environment verification, and closure record are mandatory.
+- In `dev` mode, push is the finish line after `DEV-CLOSED` is recorded.
+- In `verify` mode, Jenkins success, target environment verification, and closure record are mandatory.
 ```
 
 ## Docs Structure and Recording Rules
@@ -256,7 +272,7 @@ These categories require stronger verification and usually a DD:
 - File upload / download
 - Production configuration
 
-For these tasks, target environment verification is mandatory.
+For these tasks, use `workflow.mode: "verify"` or run an explicit verification pass after the fast `dev` closure.
 
 ## Commands
 
@@ -265,27 +281,32 @@ Recommended default flow:
 ```bash
 pip install pyyaml requests
 python3 docs/tools/autopipeline/ap.py doctor
-python3 docs/tools/autopipeline/ap.py light-gate
-python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --msg "<TASK_ID>: <summary>" --require-light-gate --require-jenkins
-python3 docs/tools/autopipeline/ap.py verify-jenkins-build --git-ref HEAD
-python3 docs/tools/autopipeline/ap.py wait-health --scope target
-python3 docs/tools/autopipeline/ap.py verify-target --backend-path /health --frontend-path /
-python3 docs/tools/autopipeline/ap.py record-closure <TASK_ID> --commit HEAD --jenkins <build-url> --result PASS --verification "health check" --verification "key api" --verification "key page"
+python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --msg "<TASK_ID>: <summary>"
 ```
 
-Or let `commit-push` append the closure record directly:
+Development mode can also be forced per run:
+
+```bash
+python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --mode dev --msg "<TASK_ID>: <summary>"
+```
+
+Verification mode runs the full Jenkins + target-environment loop:
 
 ```bash
 python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> \
+  --mode verify \
   --msg "<TASK_ID>: <summary>" \
-  --require-light-gate \
-  --require-jenkins \
-  --record-closure \
-  --jenkins-build <build-url> \
-  --result PASS \
-  --verification "health check" \
-  --verification "key api" \
-  --verification "key page"
+  --backend-path /health \
+  --frontend-path /
+```
+
+Manual verification commands remain available:
+
+```bash
+python3 docs/tools/autopipeline/ap.py verify-jenkins-build --git-ref HEAD
+python3 docs/tools/autopipeline/ap.py wait-health --scope target
+python3 docs/tools/autopipeline/ap.py verify-target --backend-path /health --frontend-path /
+python3 docs/tools/autopipeline/ap.py record-closure <TASK_ID> --commit HEAD --jenkins <build-url> --result PASS --verification "health check" --verification "key api" --verification "key page"
 ```
 
 Available on-demand commands:
@@ -328,7 +349,7 @@ python3 docs/tools/autopipeline/ap.py gen-summary <TASK_ID>
 - `verify-target`
   - Performs real target-environment verification beyond health checks when you provide key backend/frontend paths.
 - `commit-push --record-closure`
-  - Lets you append the closure record as part of the same close loop.
+  - Kept for compatibility; normal `commit-push` now records closure automatically based on `workflow.mode`.
 
 ## Publish (NPM)
 

package/cli/assets/skill/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: auto-coding-skill
-description: Use for a lightweight Jenkins-first engineering workflow in Claude/Codex. Initialize docs, fill docs/ENGINEERING.md once, then execute task->minimal-design->light-gate->push->jenkins->target-env->closure.
+description: Use for a Claude/Codex engineering workflow with dev and verify modes. Initialize docs, fill docs/ENGINEERING.md once, then execute task->minimal-design->light-gate->DEV-CLOSED->push in dev mode, or full Jenkins->target-env->PASS closure in verify mode.
 ---
 
 # Auto Coding Skill (Claude + Codex)
 
-This skill is for Go backend + frontend monorepo projects that rely on Jenkins to build and deploy after push. It supports both Claude and Codex. The default workflow is lightweight locally, then uses Jenkins and the real target environment as the authoritative verification path.
+This skill is for Go backend + frontend monorepo projects that rely on Jenkins to build and deploy after push. It supports both Claude and Codex. The default `dev` mode is optimized for fast development: lightweight local gate, early closure record, commit, push, then move to the next task. Use `verify` mode when Jenkins and the real target environment must be completed before closure.
 
 `docs/ENGINEERING.md` is intentionally Git-tracked in this workflow. The remaining environment fields in that file are mandatory, must be filled with real values, and are committed as part of the project baseline. Unused environment keys should be removed from the template instead of being left as placeholders.
 
@@ -66,6 +66,7 @@ Fill only:
 - `docs/ENGINEERING.md` frontmatter
 
 This contains all manual fields:
+- `workflow.mode`
 - `commands.*`
 - `runtime.*` (only for optional local diagnostics)
 - `target_env.*`
@@ -76,6 +77,7 @@ Do not duplicate config in other md/yaml files.
 Do not hide `docs/ENGINEERING.md` in `.gitignore`.
 
 Minimum required config for the default flow:
+- `workflow.mode`
 - `project.name`
 - `commands.light_gate` or `commands.quick_test` or `commands.test` or `commands.build`
 - `target_env.name`
@@ -108,16 +110,28 @@ Minimum required config for the default flow:
 
 ## Execution order
 
+Read `workflow.mode` from `docs/ENGINEERING.md` before choosing the path.
+
+`dev` mode:
+
 1) read `docs/ENGINEERING.md`
 2) read / update `docs/tasks/taskbook.md`
 3) write minimal design notes; create a DD only when the change is cross-module, API, DB, deployment, Jenkins, or key-page-flow related
 4) implement only the necessary changes
 5) run the default local lightweight gate
-6) commit + push
-7) verify Jenkins build / deployment result
-8) verify the real target environment
-9) append `docs/tasks/closure-log.md`
-10) use summary / deployment record / regression matrix only when the task actually requires them
+6) append `docs/tasks/closure-log.md` with `Result: DEV-CLOSED`
+7) commit + push
+8) stop and start the next development task
+
+`verify` mode:
+
+1) read / update the same authoritative docs
+2) run the default local lightweight gate
+3) commit + push
+4) verify Jenkins build / deployment result
+5) verify the real target environment
+6) append `docs/tasks/closure-log.md` with `Result: PASS / FAIL / PARTIAL`
+7) use summary / deployment record / regression matrix only when the task actually requires them
 
 ## Commands
 
@@ -125,12 +139,9 @@ Default commands:
 
 ```bash
 python3 docs/tools/autopipeline/ap.py doctor
-python3 docs/tools/autopipeline/ap.py light-gate
-python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --msg "<TASK_ID>: <summary>" --require-light-gate --require-jenkins
-python3 docs/tools/autopipeline/ap.py verify-jenkins-build --git-ref HEAD
-python3 docs/tools/autopipeline/ap.py wait-health --scope target
-python3 docs/tools/autopipeline/ap.py verify-target --backend-path /health --frontend-path /
-python3 docs/tools/autopipeline/ap.py record-closure <TASK_ID> --commit HEAD --jenkins <build-url> --result PASS --verification "health check" --verification "key api"
+python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --msg "<TASK_ID>: <summary>"
+python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --mode dev --msg "<TASK_ID>: <summary>"
+python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --mode verify --msg "<TASK_ID>: <summary>" --backend-path /health --frontend-path /
 ```
 
 On-demand commands:
@@ -146,12 +157,14 @@ python3 docs/tools/autopipeline/ap.py gen-summary <TASK_ID>
 ## Quality policy
 
 - Default local gate is lightweight and time-bounded: prefer one curated project command via `commands.light_gate`, then run only diff/API/Jenkins checks.
+- `workflow.mode: dev` closes development after light gate, closure record, commit, and push.
+- `workflow.mode: verify` closes only after Jenkins and target-environment verification.
 - `doctor` should be used early to catch missing or invalid config before the first implementation loop.
 - `light-gate` now fails if no usable fast gate command is configured.
 - `doctor`, `light-gate`, and `commit-push` all fail when required environment fields are missing, placeholder-like, or syntactically invalid.
 - Do not require local Docker Compose or full local regression for every small change.
-- Jenkins and target environment verification are more valuable than repeated local simulation of deploy-only problems.
+- Jenkins and target environment verification are mandatory in `verify` mode, not in default `dev` mode.
 - `verify-target` should be used for real target-environment API/page checks when the task touches user-visible or deploy-sensitive behavior.
-- `commit-push --record-closure` can close the loop in one command when Jenkins build URL and verification results are already known.
+- `commit-push` records closure automatically according to `workflow.mode`.
 - `regression-matrix.md` can mark `PASS` only after real execution with evidence.
 - High-risk changes must include target environment verification and usually a DD.

package/cli/assets/skill/data/templates/ENGINEERING.md

@@ -1,4 +1,7 @@
 ---
+workflow:
+  mode: "dev"
+
 project:
   name: ""
   repo_root: "."
@@ -66,8 +69,10 @@ docs:
 
 # docs/ENGINEERING.md — Lightweight Default Workflow (Source of Truth)
 
-目标：默认采用高效率开发闭环：  
-需求/任务记录 → 最小设计 → 开发实现 → 本地轻量校验 → commit/push → Jenkins 构建部署 → 目标环境验证 → 闭环记录
+目标：默认采用高效率开发闭环，并通过 `workflow.mode` 控制流程长度。
+
+- `dev`：开发模式，最快闭环。轻量门禁通过后，提前写 `DEV-CLOSED` 闭环，commit + push 触发 Jenkins 后结束。
+- `verify`：验证模式，完整闭环。轻量门禁、commit + push、Jenkins 构建验证、目标环境验证全部完成后，写 `PASS` 闭环。
 
 默认原则：
 - 默认不要求本地 Docker Compose 启动。
@@ -90,6 +95,7 @@ docs:
 ## 0. 配置填写（必须）
 
 先填写 `docs/ENGINEERING.md` frontmatter 中的所有空值。重点包括：
+- `workflow.mode`：`dev` 或 `verify`，默认推荐 `dev`
 - `commands.light_gate`：推荐配置一个项目级快速门禁命令，作为默认本地校验入口
 - `target_env.*`：目标环境前端 / 后端地址、用户名、密码，必须全部填写且真实可用
 - `jenkins.*`：Jenkins UI/API 用户名、密码、Job、分支、镜像、部署环境，必须全部填写且真实可用
@@ -102,6 +108,7 @@ docs:
 - `jenkins.api_user` / `jenkins.api_password`：Jenkins API 用户名 / 密码
 
 默认必填：
+- `workflow.mode`
 - `project.name`
 - `commands.light_gate` 或 `commands.quick_test` 或 `commands.test` 或 `commands.build`
 - `target_env.name`
@@ -181,6 +188,35 @@ docs:
 
 ## 2. 标准流程（默认）
 
+### 2.1 开发模式：`workflow.mode: "dev"`
+
+用于日常快速开发。默认闭环：
+
+需求确认 → 最小设计记录 → 开发实现 → 本地轻量校验 → 写 `DEV-CLOSED` 闭环 → commit + push → 结束
+
+规则：
+- 只跑最轻量门禁。
+- push 触发 Jenkins 后不等待、不轮询、不验证目标环境。
+- `closure-log.md` 必须提前写入本次提交。
+- 闭环结果写 `DEV-CLOSED`，不要伪装成完整 `PASS`。
+- Jenkins Build 写 `triggered by push, not verified in dev mode`。
+- Target Env 写 `not verified in dev mode`。
+
+### 2.2 验证模式：`workflow.mode: "verify"`
+
+用于发布前、验收、高风险变更或需要完整证据的任务。默认闭环：
+
+需求确认 → 最小设计 / 必要 DD → 开发实现 → 本地轻量校验 → commit + push → Jenkins 构建验证 → 目标环境验证 → 写 `PASS` 闭环
+
+规则：
+- Jenkins 构建必须成功。
+- 目标环境健康检查必须通过。
+- 关键接口 / 页面路径按任务需要补充验证。
+- 只有真实验证完成后，闭环结果才允许写 `PASS`。
+- 回归矩阵只有真实执行并有证据时才允许标 `PASS`。
+
+### 2.3 任务步骤
+
 1. 需求确认  
    明确任务范围、影响服务、是否涉及 API/数据库/部署/Jenkins/前端页面。
 
@@ -198,20 +234,20 @@ docs:
    - API 文档检查
    - Jenkins 配置检查
 
-5. 立即提交推送  
-   轻量校验通过后，commit + push，触发 Jenkins。
+5. 提交推送  
+   `dev` 模式先写开发闭环再 commit + push；`verify` 模式 commit + push 后继续验证 Jenkins 和目标环境。
 
 6. Jenkins 验证  
-   查看 Jenkins 构建、镜像、部署结果；失败则根据 Jenkins 日志修复，再次提交推送。
+   仅 `verify` 模式默认执行。查看 Jenkins 构建、镜像、部署结果；失败则根据 Jenkins 日志修复，再次提交推送。
 
 7. 目标环境验证  
-   在真实目标环境做健康检查、关键接口、关键页面或业务路径验证。
+   仅 `verify` 模式默认执行。在真实目标环境做健康检查、关键接口、关键页面或业务路径验证。
 
 8. 回归与证据记录  
    只有真实执行过 Jenkins / 目标环境验证，或显式要求本地运行验证时，才允许把 `regression-matrix.md` 标为 `PASS`。
 
 9. 闭环记录  
-   每个任务必须留下轻量闭环记录：任务 ID、提交号、Jenkins Build URL、目标环境验证结果、是否通过、遗留问题。
+   每个任务必须留下轻量闭环记录。`dev` 模式用 `DEV-CLOSED`，`verify` 模式用 `PASS` / `FAIL` / `PARTIAL`。
 
 10. 配置入库  
    `docs/ENGINEERING.md` 中保留下来的环境信息、前端/后端账号、Jenkins 账号与密码必须 100% 填写、正确填写，并提交 Git 作为项目权威配置持续维护。
@@ -231,7 +267,7 @@ docs:
 
 高风险变更至少额外要求：
 - 明确 DD
-- 目标环境真实验证
+- 使用 `workflow.mode: "verify"`，或在 `dev` 快速闭环后显式补目标环境真实验证
 - 闭环记录写清楚验证路径和结果
 - 必要时补 summary / deployment record / regression matrix
 
@@ -254,6 +290,8 @@ docs:
 
 统一使用：
 - `python3 docs/tools/autopipeline/ap.py doctor`
+- `python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --msg "<TASK_ID>: <summary>"`
+- `python3 docs/tools/autopipeline/ap.py commit-push <TASK_ID> --mode verify --msg "<TASK_ID>: <summary>" ...`
 - `python3 docs/tools/autopipeline/ap.py light-gate`
 - `python3 docs/tools/autopipeline/ap.py verify-jenkins-build ...`
 - `python3 docs/tools/autopipeline/ap.py wait-health --scope target`
@@ -263,6 +301,7 @@ docs:
 说明：
 - `doctor`：检查默认流程必填项和常见配置错误。
 - `light-gate`：默认轻量门禁，优先执行项目自定义快速门禁命令。
+- `commit-push`：按 `workflow.mode` 自动选择开发闭环或完整验证闭环。
 - `verify-target`：目标环境健康检查 + 按需关键 API / 页面验证。
 - `record-closure`：默认轻量闭环记录。
 - `check-matrix`、`gen-summary`、`runtime-up/down`：保留为按需工具。

package/cli/assets/skill/data/templates/docs/tasks/closure-log.md

@@ -2,9 +2,10 @@
 
 规则：
 1) 每个任务完成后，至少追加一条闭环记录
-2) 默认记录真实提交、Jenkins、目标环境验证结果
-3) Jenkins 失败后再修复的任务，应补充失败原因和修复提交
-4) 这里是默认闭环文档；长 summary 只用于高风险或复盘任务
+2) `dev` 模式记录开发闭环：轻量门禁通过、已提交推送、Jenkins 已由 push 触发但不等待验证
+3) `verify` 模式记录完整闭环：真实提交、Jenkins 构建、目标环境验证结果
+4) Jenkins 失败后再修复的任务，应补充失败原因和修复提交
+5) 这里是默认闭环文档；长 summary 只用于高风险或复盘任务
 
 ---
 
@@ -14,7 +15,7 @@
 - Jenkins Build: <build url>
 - Target Env: <env name / health url / page path>
 - Verification: <health / key api / key page / business path>
-- Result: PASS / FAIL / PARTIAL
+- Result: DEV-CLOSED / PASS / FAIL / PARTIAL
 - Follow-up: <none or todo>
 - Jenkins Failure: <optional>
 - Fix Commit: <optional>

package/cli/assets/skill/scripts/ap.py

@@ -317,12 +317,12 @@ def _resolve_jenkins_job_candidates(
 ) -> List[str]:
     jenkins_cfg = (cfg.get("jenkins") or {})
     effective_branch = str(branch_name or "").strip()
-    if not effective_branch:
+    effective_root = str(multibranch_root_job or "").strip()
+    if not effective_branch and effective_root:
         inferred_branch = _resolve_git_branch_name(repo, git_ref or "HEAD")
         if inferred_branch:
             effective_branch = inferred_branch
 
-    effective_root = str(multibranch_root_job or "").strip()
     explicit_url = str(job_url or "").strip()
     explicit_name = str(job_name or "").strip()
     configured_url = str(jenkins_cfg.get("job_url") or "").strip()
@@ -423,6 +423,8 @@ def cmd_gen_summary(args: argparse.Namespace) -> None:
     staged = run(["git", "diff", "--cached", "--name-only"], cwd=repo, check=False).stdout.strip()
     unstaged = run(["git", "diff", "--name-only"], cwd=repo, check=False).stdout.strip()
     status = run(["git", "status", "--porcelain=v1"], cwd=repo, check=False).stdout.strip()
+    staged_block = "- " + staged.replace("\n", "\n- ") if staged else "- (none)"
+    unstaged_block = "- " + unstaged.replace("\n", "\n- ") if unstaged else "- (none)"
 
     content = f"""# Task Summary — {task_id} — {title}
 
@@ -442,9 +444,9 @@ def cmd_gen_summary(args: argparse.Namespace) -> None:
 ## 2. 变更概览
 ### Git change snapshot
 - Staged files:
-{('- ' + staged.replace('\n','\n- ')) if staged else '- (none)'}
+{staged_block}
 - Unstaged files:
-{('- ' + unstaged.replace('\n','\n- ')) if unstaged else '- (none)'}
+{unstaged_block}
 - Status:
 ```text
 {status}
@@ -540,6 +542,15 @@ def _load_cfg(repo: Path) -> dict:
     return load_yaml(cfg_path)
 
 
+def _workflow_mode(cfg: dict, args: Optional[argparse.Namespace] = None) -> str:
+    explicit = str(getattr(args, "mode", "") or "").strip().lower() if args else ""
+    configured = str(((cfg.get("workflow") or {}).get("mode")) or "dev").strip().lower()
+    mode = explicit or configured or "dev"
+    if mode not in {"dev", "verify"}:
+        raise APError("workflow.mode must be 'dev' or 'verify'.")
+    return mode
+
+
 def _text(value: object) -> str:
     return str(value or "").strip()
 
@@ -740,6 +751,7 @@ def cmd_verify_target(args: argparse.Namespace) -> None:
 
     summary = ", ".join(checks) if checks else "health-only"
     print(f"[verify-target] OK: {summary}")
+    return summary
 
 
 def cmd_verify_jenkins(args: argparse.Namespace) -> None:
@@ -771,6 +783,7 @@ def cmd_verify_jenkins(args: argparse.Namespace) -> None:
 def cmd_doctor(args: argparse.Namespace) -> None:
     repo = Path(args.repo).resolve()
     cfg = _load_cfg(repo)
+    workflow_cfg = (cfg.get("workflow") or {})
     project_cfg = (cfg.get("project") or {})
     commands = (cfg.get("commands") or {})
     target_cfg = (cfg.get("target_env") or {})
@@ -781,6 +794,9 @@ def cmd_doctor(args: argparse.Namespace) -> None:
     missing: List[str] = []
     warnings: List[str] = []
 
+    mode = str(workflow_cfg.get("mode") or "dev").strip().lower()
+    if mode not in {"dev", "verify"}:
+        missing.append("workflow.mode (must be dev or verify)")
     if not str(project_cfg.get("name") or "").strip():
         missing.append("project.name")
     if not (
@@ -868,7 +884,9 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
     max_builds = int(args.max_builds or 20)
     timeout_s = int(args.timeout_sec or 300)
     poll_s = int(args.poll_sec or 5)
-    inferred_branch = _resolve_git_branch_name(repo, git_ref)
+    inferred_branch = ""
+    if args.multibranch_root_job and not args.branch_name:
+        inferred_branch = _resolve_git_branch_name(repo, git_ref)
     branch_hint = str(args.branch_name or inferred_branch or "").strip()
     root_hint = str(
         args.multibranch_root_job
@@ -910,15 +928,16 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
             f"#{payload.get('number')} {payload.get('url')}",
             args.allow_no_deploy,
         )
+        build_url = str(payload.get("url") or "").strip()
         print(
             "[verify-jenkins-build] OK: "
             f"job={job_label} "
             f"build=#{payload.get('number')} "
             f"result={result} "
             f"description={description} "
-            f"url={payload.get('url')}"
+            f"url={build_url}"
         )
-        return
+        return build_url
 
     git_short_sha = _resolve_git_short_sha(repo, git_ref)
     matched = None
@@ -949,6 +968,7 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
         f"#{matched.get('number')} {matched.get('url')}",
         args.allow_no_deploy,
     )
+    build_url = str(matched.get("url") or "").strip()
     print(
         "[verify-jenkins-build] OK: "
         f"commit={git_short_sha} "
@@ -956,8 +976,9 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
         f"build=#{matched.get('number')} "
         f"result={result} "
         f"description={description} "
-        f"url={matched.get('url')}"
+        f"url={build_url}"
     )
+    return build_url
 
 
 def cmd_verify_api_docs(args: argparse.Namespace) -> None:
@@ -1020,28 +1041,74 @@ def cmd_record_closure(args: argparse.Namespace) -> None:
     print(f"[record-closure] OK: {closure_log}")
 
 
+def _record_commit_push_closure(
+    repo: Path,
+    args: argparse.Namespace,
+    *,
+    commit: str,
+    jenkins: str,
+    target_env: str,
+    verification: List[str],
+    result: str,
+    follow_up: str,
+) -> None:
+    cmd_record_closure(
+        argparse.Namespace(
+            repo=str(repo),
+            task_id=args.task_id,
+            title=args.title,
+            commit=commit,
+            jenkins=jenkins,
+            target_env=target_env,
+            verification=verification,
+            result=result,
+            follow_up=follow_up,
+            initial_commit=args.initial_commit,
+            jenkins_failure=args.jenkins_failure,
+            fix_commit=args.fix_commit,
+        )
+    )
+
+
 def cmd_commit_push(args: argparse.Namespace) -> None:
     repo = Path(args.repo).resolve()
     ensure_git_repo(repo)
     cmd_doctor(argparse.Namespace(repo=str(repo)))
+    cfg = _load_cfg(repo)
+    mode = _workflow_mode(cfg, args)
+    target_cfg = (cfg.get("target_env") or {})
 
     msg = args.msg
 
-    if args.record_closure and not args.result:
-        raise APError("When using --record-closure, --result is required.")
-
     if args.require_runtime_health:
         cmd_wait_health(argparse.Namespace(repo=str(repo), scope="runtime"))
 
-    if args.require_light_gate:
+    if mode in {"dev", "verify"} or args.require_light_gate:
         cmd_light_gate(argparse.Namespace(repo=str(repo)))
 
     if args.require_jenkins:
         cmd_verify_jenkins(argparse.Namespace(repo=str(repo)))
 
-    if args.require_matrix:
+    if args.require_matrix and mode != "verify":
         cmd_check_matrix(argparse.Namespace(repo=str(repo)))
 
+    if mode == "dev":
+        dev_verification = args.verification or [
+            "light-gate only",
+            "Jenkins triggered by push; build not verified in dev mode",
+            "target environment not verified in dev mode",
+        ]
+        _record_commit_push_closure(
+            repo,
+            args,
+            commit="generated by this commit-push run",
+            jenkins=args.jenkins_build or "triggered by push, not verified in dev mode",
+            target_env=args.target_env or "not verified in dev mode",
+            verification=dev_verification,
+            result=args.result or "DEV-CLOSED",
+            follow_up=args.follow_up or "Run verify mode when Jenkins and target-environment evidence is required.",
+        )
+
     run(["git", "add", "-A"], cwd=repo)
     diff = run(["git", "diff", "--cached", "--name-only"], cwd=repo).stdout.strip()
     if not diff:
@@ -1049,24 +1116,65 @@ def cmd_commit_push(args: argparse.Namespace) -> None:
 
     run(["git", "commit", "-m", msg], cwd=repo)
     run(["git", "push"], cwd=repo)
-    if args.record_closure:
-        cmd_record_closure(
+
+    if mode == "verify":
+        jenkins_build = cmd_verify_jenkins_build(
+            argparse.Namespace(
+                repo=str(repo),
+                git_ref="HEAD",
+                job_name=args.job_name,
+                job_url=args.job_url,
+                multibranch_root_job=args.multibranch_root_job,
+                branch_name=args.branch_name,
+                build_number=args.build_number,
+                max_builds=args.max_builds,
+                timeout_sec=args.timeout_sec,
+                poll_sec=args.poll_sec,
+                allow_no_deploy=args.allow_no_deploy,
+            )
+        )
+        target_summary = cmd_verify_target(
             argparse.Namespace(
                 repo=str(repo),
-                task_id=args.task_id,
-                title=args.title,
-                commit="HEAD",
-                jenkins=args.jenkins_build,
-                target_env=args.target_env,
-                verification=args.verification,
-                result=args.result,
-                follow_up=args.follow_up,
-                initial_commit=args.initial_commit,
-                jenkins_failure=args.jenkins_failure,
-                fix_commit=args.fix_commit,
+                backend_path=args.backend_path,
+                frontend_path=args.frontend_path,
+                backend_basic_auth=args.backend_basic_auth,
+                frontend_basic_auth=args.frontend_basic_auth,
             )
         )
-    print("[commit-push] OK - push completed, Jenkins should auto-trigger")
+        if args.require_matrix:
+            cmd_check_matrix(argparse.Namespace(repo=str(repo)))
+        verification = args.verification or [
+            f"Jenkins build verified: {jenkins_build or 'verified by git-ref HEAD'}",
+            f"Target verification: {target_summary}",
+        ]
+        _record_commit_push_closure(
+            repo,
+            args,
+            commit="HEAD",
+            jenkins=args.jenkins_build or jenkins_build or "verified by git-ref HEAD",
+            target_env=args.target_env or str(target_cfg.get("name") or "").strip(),
+            verification=verification,
+            result=args.result or "PASS",
+            follow_up=args.follow_up or "none",
+        )
+        run(["git", "add", "-A"], cwd=repo)
+        closure_diff = run(["git", "diff", "--cached", "--name-only"], cwd=repo).stdout.strip()
+        if closure_diff:
+            run(["git", "commit", "-m", f"{args.task_id}: record verification closure [skip ci]"], cwd=repo)
+            run(["git", "push"], cwd=repo)
+    elif args.record_closure and mode != "dev":
+        _record_commit_push_closure(
+            repo,
+            args,
+            commit="HEAD",
+            jenkins=args.jenkins_build or "TODO",
+            target_env=args.target_env or str(target_cfg.get("name") or "").strip(),
+            verification=args.verification or [],
+            result=args.result or "PARTIAL",
+            follow_up=args.follow_up or "none",
+        )
+    print(f"[commit-push] OK - mode={mode}")
 
 
 def main(argv: Optional[List[str]] = None) -> int:
@@ -1140,7 +1248,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     s.add_argument("--jenkins")
     s.add_argument("--target-env")
     s.add_argument("--verification", action="append")
-    s.add_argument("--result", choices=["PASS", "FAIL", "PARTIAL"], required=True)
+    s.add_argument("--result", choices=["DEV-CLOSED", "PASS", "FAIL", "PARTIAL"], required=True)
     s.add_argument("--follow-up")
     s.add_argument("--initial-commit")
     s.add_argument("--jenkins-failure")
@@ -1151,15 +1259,29 @@ def main(argv: Optional[List[str]] = None) -> int:
     s.add_argument("task_id")
     s.add_argument("--title")
     s.add_argument("--msg", required=True)
+    s.add_argument("--mode", choices=["dev", "verify"])
     s.add_argument("--require-light-gate", action="store_true")
     s.add_argument("--require-runtime-health", action="store_true")
     s.add_argument("--require-jenkins", action="store_true")
     s.add_argument("--require-matrix", action="store_true")
     s.add_argument("--record-closure", action="store_true")
+    s.add_argument("--job-name")
+    s.add_argument("--job-url")
+    s.add_argument("--multibranch-root-job")
+    s.add_argument("--branch-name")
+    s.add_argument("--build-number", type=int)
+    s.add_argument("--max-builds", type=int, default=20)
+    s.add_argument("--timeout-sec", type=int, default=300)
+    s.add_argument("--poll-sec", type=int, default=5)
+    s.add_argument("--allow-no-deploy", action="store_true")
+    s.add_argument("--backend-path", action="append")
+    s.add_argument("--frontend-path", action="append")
+    s.add_argument("--backend-basic-auth", action="store_true")
+    s.add_argument("--frontend-basic-auth", action="store_true")
     s.add_argument("--jenkins-build")
     s.add_argument("--target-env")
     s.add_argument("--verification", action="append")
-    s.add_argument("--result", choices=["PASS", "FAIL", "PARTIAL"])
+    s.add_argument("--result", choices=["DEV-CLOSED", "PASS", "FAIL", "PARTIAL"])
     s.add_argument("--follow-up")
     s.add_argument("--initial-commit")
     s.add_argument("--jenkins-failure")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvis1513/auto-coding-skill",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "CLI installer for auto-coding-skill (Claude Code + Codex CLI) with Go fullstack + Jenkins workflow support.",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node -c cli/src/index.js && python3 -m py_compile src/auto-coding-skill/scripts/ap.py src/auto-coding-skill/scripts/core.py src/auto-coding-skill/scripts/http_checks.py cli/assets/skill/scripts/ap.py cli/assets/skill/scripts/core.py cli/assets/skill/scripts/http_checks.py && find src cli -type d -name '__pycache__' -prune -exec rm -rf {} +",
+    "test": "node -c cli/src/index.js && python3 -c \"import ast, pathlib; files = ['src/auto-coding-skill/scripts/ap.py', 'src/auto-coding-skill/scripts/core.py', 'src/auto-coding-skill/scripts/http_checks.py', 'cli/assets/skill/scripts/ap.py', 'cli/assets/skill/scripts/core.py', 'cli/assets/skill/scripts/http_checks.py']; [ast.parse(pathlib.Path(rel).read_text(encoding='utf-8'), filename=rel, feature_version=(3, 11)) for rel in files]; print('python311-grammar-ok')\" && python3 -m py_compile src/auto-coding-skill/scripts/ap.py src/auto-coding-skill/scripts/core.py src/auto-coding-skill/scripts/http_checks.py cli/assets/skill/scripts/ap.py cli/assets/skill/scripts/core.py cli/assets/skill/scripts/http_checks.py && find src cli -type d -name '__pycache__' -prune -exec rm -rf {} +",
     "sync-assets": "node cli/src/sync-assets.js",
     "release:check": "npm run sync-assets && npm run test && npm pack --dry-run"
   },