@jakkrichm/create-nexus-devflow 2.16.3 → 2.17.0

package/template/.claude/skills/complete/reference/completion-recovery.md

@@ -0,0 +1,248 @@
+# Completion recovery
+
+Use this contract before Complete requires a live spec, and before Status or
+Continuous selects new work. Archive and Git evidence determine the phase.
+`run.json`, modification times, archive titles, and commit subjects prove none of
+these transitions. Recovery grants no commit, merge, push, or cleanup approval.
+
+## Prepare one recoverable archive
+
+After Complete's final gates pass, but before any logging edits, record the full
+work branch ref, `HEAD`, local default branch ref and its current commit. Require
+that default commit to be an ancestor of the work branch. Resolve refs locally;
+do not fetch. Capture the verified working tree in a temporary Git index:
+
+```bash
+node --input-type=module -e '
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), "devflow-completion-"));
+const env = { ...process.env, GIT_INDEX_FILE: path.join(dir, "index") };
+try {
+  execFileSync("git", ["read-tree", "HEAD"], { env });
+  execFileSync("git", ["add", "-A", "--", "."], { env });
+  process.stdout.write(execFileSync("git", ["write-tree"], { env }));
+} finally {
+  fs.rmSync(dir, { recursive: true, force: true });
+}'
+```
+
+Run from the project root only after excluding unrelated work and Git conflicts.
+This writes local Git objects, not a commit or ref, and leaves the normal index
+untouched. Never force-add ignored files. Dirty submodules or required ignored
+inputs without separately recoverable exact bytes cannot support this proof.
+The source tree is evidence, not approval or a substitute for any quality gate.
+
+Before logging, record `absentOptional` as an array containing only
+`devflow/context/{xxx-slug}/findings.md` and/or `devflow/context/{xxx-slug}/review.md` when each
+exact path returns `ENOENT` from `lstat`, its parents are ordinary directories,
+and neither HEAD nor sourceTree contains it. Otherwise omit that path. This
+records original filesystem absence, never permission to discard evidence.
+Ignored existing files and symlinks are not absent. Reject other paths, duplicates,
+or contradictions; a missing field in an older annotation proves no absence.
+
+Start the archive with the original verified spec bytes, unchanged. Measure
+UTF-8 **bytes**, not characters or lines. Append two LF bytes and this single-line
+JSON comment before any Findings, Independent review, or Manual try guide section:
+
+```text
+<!-- devflow:completion {"schemaVersion":1,"specBytes":123,"specSha256":"<64 hex>","branch":"refs/heads/feature/name","head":"<full SHA>","baseRef":"refs/heads/main","baseCommit":"<full SHA>","sourceTree":"<full tree SHA>","absentOptional":[]} -->
+```
+
+Use `Buffer.length` and SHA-256 over the exact file bytes. To recover, locate the
+unique annotation boundary and remove only the two inserted line breaks before
+it (LF or CRLF). Test that prefix as raw bytes and uniform LF/CRLF candidates
+against both `specBytes` and `specSha256`; deduplicate identical candidates and
+accept only one exact match. This reconstructs hash-proven original bytes across
+ordinary Git EOL conversion. Mixed endings or custom filters without an exact
+match stop recovery. Never trim content, split on a Markdown heading, or accept a
+normalized digest instead of the original. Reject malformed/duplicate annotations.
+
+Build the complete archive in a temporary file first, including all resolved
+findings, the exact passing receipt when present, and any generated try guide.
+Validate it against its inputs, then place it at the intended absent archive path
+in `devflow/history/features/`, `fixes/`, or `rollbacks/`.
+Never overwrite an existing archive: a matching one enters recovery; a conflicting
+one stops for an exact path decision. Finish plan/overview bookkeeping, update
+`devflow/history/HISTORY.md`, then clean up the run workspace `devflow/context/{xxx-slug}/`.
+Do not append sections incrementally to an existing archive during recovery.
+
+## Screen candidates read-only
+
+Before matching a reused feature branch, apply the historical-build exclusion
+below. Do not treat a proved prior reversed build as pending completion of its
+replacement. If that exclusion cannot be proved, retain the candidate and stop
+for full proof rather than guessing from a different spec or archive name.
+
+Inspect current branch, `git status --porcelain=v1`, live spec/review and plan
+consistency, and relevant annotated archives. Check recorded local work refs with
+`git show-ref --verify --quiet <branch>`. A matching work branch/archive, a retained
+matching work ref after merge, or uncommitted completion changes/live evidence tied
+to that item is a recovery candidate. An explicit request to resume completion
+also requires full proof. Status reports candidates and routes them to Complete;
+it does not create a temporary index or claim the phase has passed full proof.
+
+For ordinary Status or a new Continuous invocation, a clean local default branch
+with consistent live state, no matching local work ref, and no pending completion
+evidence is settled history. An archive at its tip alone does not trigger recovery.
+Do not require historical `head`/`sourceTree` objects for that orientation; clean
+clones and Git pruning legitimately lose them. This is not a new claim about past
+verification. A reset stub alone proves nothing: check the refs, cleanliness, and
+live state too. Missing objects still block actual recovery and explicit resume.
+
+## Prove an actual recovery candidate
+
+For feature archives on a reused branch, exclude a prior build only when all of
+these read-only Git checks pass:
+
+- `../../feature/reference/build-history.md` proves its unique unchanged archive
+  addition on the local default, and the introducing commit's sole parent equals
+  that archive annotation's `baseCommit` on the same `baseRef`.
+- An exact completed, unchanged, reachable rollback record names that archive and
+  introducing commit; its commit is after the feature addition.
+- The current work branch descends from a post-rollback local default: that
+  rollback commit is an ancestor of the merge base of the current work branch
+  and local default. Its old archive remains byte/mode-identical in both trees
+  and the working tree, with no pending archive edits or retained review explicitly
+  targeting that old build.
+
+Different spec bytes, title, attempt, filename, or ancestry alone never exclude
+an archive. Missing, changed, or contradictory proof stops; this exception does
+not recover old missing inputs or waive current gates. It permits legacy branch
+reuse only after the old lifecycle is demonstrably finished and reversed.
+
+Require one annotated archive matching the recorded work branch, or the exact
+archive/commit proof in the merged phase below. A real live spec must match its
+recovered bytes; a cleaned-up workspace is also expected after merge. A different spec conflicts.
+For features, use the recovered spec's frozen `**Build attempt:**` and that exact
+archive path; never allocate a new attempt on resume. For a legacy feature spec
+without the field, the path plus existing annotation fixes the destination only
+after the prior-build proof in `../../feature/reference/build-history.md` at its
+recorded `baseCommit` uniquely establishes its attempt. Exclude the current archive from those prior
+builds. Do not edit the recovered bytes to insert metadata.
+
+Require all recorded commits and `sourceTree` to exist (`git cat-file -e`).
+Unreferenced source trees can be pruned by Git: missing objects stop recovery;
+request the original objects or an identified backup, never recreate a guessed
+baseline. An old archive without this annotation may be read as history, but
+cannot automatically recover a missing live spec through this contract.
+
+Use the temporary-index command above to inspect the present work tree without
+altering the real index. Compare trees with `git diff --raw -z <source> <current>`
+and inspect source blobs with `git show <sourceTree>:<path>`. Git trees use clean-
+filtered bytes; compare evidence through `git hash-object --path=<path> --stdin`
+when ordinary EOL conversion applies, while recovering the exact spec only by
+its archive digest above. Unsupported custom filters stop recovery. Inspect staged
+changes too; conflicting staged/working versions must be reconciled explicitly.
+Do not infer identity from ancestry alone, a matching filename, or a latest date.
+
+## Validate only the expected completion changes
+
+Reconstruct the original spec and evidence from the source tree and archive.
+Every changed path, file mode, addition, and deletion must be accounted for.
+Only these exact transformations can follow the captured source tree:
+
+- Add this one archive, with the exact spec prefix and annotation, resolved
+  findings copied with only the documented ID prefix, the original passing
+  receipt bytes, and a try guide for this spec when required or already generated.
+- Apply this work item's exact build-plan checkbox/parent changes, or its exact
+  rollback note. Update `devflow/history/HISTORY.md` with the release digest.
+  Change only the overview's existing source-hash value, using the documented hash contract.
+  A fix has no build-plan change.
+- Remove only resolved ledger entries present in that archive. Preserve every
+  `open`, `fixed`, and `unverified` entry byte-for-byte, including its ID.
+- Clean up the completed task run directory `devflow/context/{xxx-slug}/`.
+- Delete only the exact consumed prototype files already authorized for this
+  work item and identified by its design reference. No general cleanup is allowed.
+
+No other history, context, configuration, product, test, or ignore-rule changes
+are completion bookkeeping. Read the full diffs, not just a filename allowlist.
+Partial plan bookkeeping is recoverable only when each changed byte is one of
+these transformations and all unfinished operations can be identified exactly.
+Conflicting or partial archive/evidence content stops before any live reset.
+
+For independent review, validate the archived receipt against its original
+`Target commit`, original base/merge-base, exact recovered spec digest, reviewer
+identity, execution/context pairing, required Check result, and receipt sections.
+The annotation's `head` must equal that target, and its source tree may differ
+from the target only in the original review/findings evidence permitted by Audit.
+Never relabel the receipt as current at the later work commit or merge commit.
+When the original receipt has `Spec snapshot`, preserve that field unchanged.
+After live reset, the hash-proven original archive prefix may establish the same
+spec identity: require its exact digest to equal the receipt's `Spec hash` and the
+annotation's `specSha256`, and require the snapshot field's canonical path to
+contain that original target and hash. This is archived-receipt validation, not
+a current live receipt. Do not create a new snapshot or relabel the target.
+Conflicting retained snapshot bytes or unsafe paths still stop recovery; an
+absent local snapshot may use this exact archive proof after reset. This does
+not replace source-tree/product proof or recover other ignored evidence.
+The narrow completion changes above preserve the reviewed product; any other
+change requires restored exact active inputs and renewed gates/checkpoint/review.
+Never overwrite conflicting live evidence to obtain that restoration.
+
+Ignored local-only files are absent from this tree proof. Validate them using
+separately provable exact original bytes plus the archive and retained inputs,
+or stop and name the missing evidence. A local archive can match a still-existing
+work branch; its presence alone cannot bind an already-deleted branch to a squash
+commit. Do not force-add ignored workflow files to make recovery pass.
+
+## Interrupted archival, before the work commit
+
+Require the recorded work branch at the recorded `head`, the local default still
+at `baseCommit`, a complete matching archive, and only the validated partial or
+finished bookkeeping changes above. Reconcile archived and retained findings and
+review before changing anything. Do not duplicate sections or erase unresolved
+entries. If the archive is absent and live inputs are intact, use normal Complete;
+if both the archive and needed live input are missing, stop for recovery evidence.
+
+Read the recovered spec from a temporary file, preserving its exact bytes; do
+not overwrite the live stub merely to orient a fresh session. Repeat current-
+session Verify and required gates against that spec and the current product.
+Reuse a passing archived review only through the original-target checks above.
+If a gate needs active files restored, restore only proven matching originals
+with no conflicting live data, run the gate, and re-enter normal Complete. If
+verification or review changes evidence, stop and reconcile a new reviewed archive
+candidate explicitly; never silently append to the existing archive.
+
+Finish only the missing bookkeeping, with live workspace cleanup last. Show the concrete
+remaining diff and proposed conventional work commit, obtain normal commit
+approval, and continue at Complete Step 2. This archive does not authorize Git.
+
+## Work committed, awaiting merge
+
+Require a clean recorded work branch at one unambiguous final work commit whose
+sole parent is recorded `head`, with the default still at `baseCommit`. Compare the complete work
+commit tree to `sourceTree` and require exactly the finished transformations above.
+The tracked archive and final bookkeeping must be in that commit, not added later.
+For ignored evidence require the separate proof described above. Extra commits or
+post-commit drift stop for review, not another completion commit.
+
+Rerun current-session Verify and validate all required gates using the recovered
+spec and original receipt. Resume at Complete Step 3's merge approval. Never make
+a second work commit, reset evidence again, or treat earlier approval as covering
+new changes. Preserve the exact work commit SHA for merge verification.
+
+## Merge already completed
+
+Require a clean local default branch tip whose sole parent is the recorded
+`baseCommit`, and the complete finished tree and archive. If the work branch still
+exists, require its exact final work commit and tree equality with that default
+tip (`git diff --exit-code <workCommit>^{tree} <defaultTip>^{tree}`), including the
+archive blob. A squash merge normally does not contain the work commit as an
+ancestor. Tree equality alone without the matching base, archive, and completed
+bookkeeping is insufficient.
+
+If the work branch was deleted, require the tracked archive at the default tip,
+its exact source-tree/spec/branch annotation, and exactly the finished changes
+from sourceTree to that tip. An ignored archive without a provable commit binding
+must stop for user identification and supporting evidence. If the default has
+advanced or several commits/archives fit, stop and name the ambiguity instead of
+weakening this proof or searching by title.
+
+Do only pending cleanup already authorized for this work item; ask if cleanup
+approval is missing. Never repeat archival, the work commit, or the squash merge,
+and never create a cleanup commit on the default branch. If nothing remains,
+report the verified local merge once and leave Git unchanged. Push still needs
+its separate approval. A repeated resume follows this same no-op path.

package/template/.claude/skills/continuous/SKILL.md

@@ -6,6 +6,8 @@ argument-hint: "[{resume, max-features, or start-feature}]"
 
 # continuous - Complete the Build Plan One Local Feature at a Time
 
+**Context reuse:** Reuse any required file already loaded in project instructions or the current session. Read it again only if absent, changed, or exact current bytes or line references are needed.
+
 **First action:** Before project inspection, preflight, or any other tool call,
 publish `running` to `devflow/.state/run.json` using the dashboard activity
 contract in `AGENTS.md`.
@@ -19,120 +21,192 @@ Where this sits in the workflow:
                Gates ➔ Merge)
 ```
 
-`/continuous` (หรือ `$continuous`) คือโหมดการทำงานแบบ Autonomous Multi-Feature Delivery Loop สำหรับจัดส่งฟีเจอร์ที่อยู่ใน `devflow/build-plan.md` ต่อเนื่องทีละฟีเจอร์ในเครื่อง Local โดยไม่ต้องหยุดรอ Manual Review Prompts ในแต่ละขั้นตอนย่อย แต่ยังคงรักษาความเข้มงวดของ **The 3-Pillars Model & Task-Isolated Living Spec (`devflow/context/{xxx-slug}/spec.md`)**, การทำ TDD, การตรวจ Quality Gates, การบันทึก Findings Ledger, และการ Squash-merge ลง Local Main Commit ทีละฟีเจอร์อย่างปลอดภัย 100%
-
-### ขอบเขตสิทธิ์ที่ได้รับอนุญาตเฉพาะในเครื่อง Local:
-- สร้างและสลับ Feature Branch ในเครื่อง Local
-- บันทึก Checkpoint Commits ย่อยบน Branch
-- สร้าง required immutable independent-review checkpoints
-- บันทึก Feature Commit สุดท้าย
-- Squash-merge ฟีเจอร์ที่เสร็จสมบูรณ์ลง Default Branch ของ Local
-- ลบ Feature Branch เฉพาะใน Local หลังรวมโค้ดสำเร็จ
-- วนลูปเริ่มทำฟีเจอร์ที่ยังไม่ได้เช็ค (`- [ ]`) รายการถัดไปใน `build-plan.md`
-
-### ข้อจำกัดความปลอดภัยเด็ดขาด (Strict Safety Boundaries):
-- **ห้าม** Push ขึ้น Remote Repository
-- **ห้าม** Deploy หรือเผยแพร่ (Publish) สู่ภายนอก
-- **ห้าม** ลบข้อมูลจริง, ทำลาย Database, หรือรัน Destructive Migration
-- **ห้าม** กด Accept Finding หรือเพิกเฉยต่อ Failing Quality Gate แทนมนุษย์
+Continuous Mode (`/continuous` or `$continuous`) is an explicit opt-in loop for
+completing planned features serially from `devflow/build-plan.md` in local isolation
+without pausing at normal human review prompts. It preserves the same strict
+**The 3-Pillars Model & Task-Isolated Living Spec (`devflow/context/{xxx-slug}/spec.md`)**,
+disciplined TDD verification, quality gates, findings ledger, branch isolation, and
+one clean local main commit per feature that a careful human workflow would produce.
+
+### Authorized Local Actions for this Run:
+- Create and switch local feature branches (`feature/{xxx-slug}`)
+- Create configured checkpoint commits on those branches
+- Create required immutable independent-review checkpoints
+- Create the final local feature commit
+- Squash-merge a completed feature into the local default branch (`main`)
+- Delete the merged local feature branch
+- Repeat with the next unchecked build-plan item
+
+### Strict Safety Boundaries:
+- **NEVER** push to remote repositories
+- **NEVER** deploy or publish externally
+- **NEVER** delete production data, destroy databases, or run irreversible migrations
+- **NEVER** accept findings or waive failing quality gates on behalf of the user
+- Always stop before those actions and hand off to the user
 
 ---
 
 ## Input & Target Selection
 
-- **ไม่ระบุ Argument (`/continuous`)**:
-  1. หากมีฟีเจอร์ค้างอยู่ใน `devflow/context/{xxx-slug}/` ให้ทำต่อจากขั้นตอนย่อยแรกที่ยังไม่ได้เช็ค (`- [ ]`)
-  2. หากไม่มี ให้เลือกฟีเจอร์แรกที่ยังไม่ได้เช็ค (`- [ ]`) ใน `devflow/build-plan.md`
-  3. วนลูปทำต่อเนื่องตามลำดับใน `build-plan.md` จนกว่าจะหมด หรือครบตามจำนวน `continuous.maxFeatures` ใน `devflow/config.json`
-- **ระบุ `resume` (`/continuous resume`)**: ทำงานต่อจากฟีเจอร์และขั้นตอนย่อยที่ค้างอยู่ทันที
-- **ระบุชื่อหรือหมายเลขฟีเจอร์ (`/continuous 13`)**: เริ่มต้นจากฟีเจอร์ที่ระบุ แล้ววนลูปต่อไปยังฟีเจอร์ถัดไป
+Before selecting a new feature or requiring an active live spec, always inspect
+pending completion using the installed Complete skill and
+`../complete/reference/completion-recovery.md`. Use its read-only candidate screen
+first: settled clean default-branch history needs no historical transient objects
+for a new run. An actual completion candidate or an explicit request to resume
+interrupted completion requires full recovery proof, using this run's scoped Git
+authority and `qualityGates.continuous`. Do not repeat archival or a work commit/merge.
+Missing, conflicting, or unprovable recovery evidence stops before next-feature work.
+An active feature with no completion candidate resumes implementation normally; its
+ordinary `resume` does not require an archive or completion proof.
+
+With no argument after pending completion has been reconciled:
+
+1. Resume an active feature in `devflow/context/{xxx-slug}/spec.md`.
+2. Otherwise select the next unchecked leaf item (`- [ ]`) in `devflow/build-plan.md`.
+3. Continue in build-plan order until no unchecked leaf remains or
+   `continuous.maxFeatures` completed features have been counted.
+
+`resume` explicitly resumes the active feature or its pending completion.
+A feature number or name may set the starting item only when no different work item
+is active. After that item, continue with the next unchecked leaf items in normal
+build-plan order.
+
+Continuous Mode handles planned features only. If the active work is a fix or rollback,
+stop and point to its normal reviewed workflow. Never overwrite active work to make
+the requested target fit.
 
 ---
 
-## Step 1: Preflight Safety Check (ตรวจสอบความพร้อมก่อนเริ่ม)
+## Step 1: Preflight Safety Check
 
-อ่านบริบทตั้งต้น:
+Read initial context:
 - `AGENTS.md`
-- `devflow/config.json` (หากไม่มี ให้ใช้ค่า Defaults อย่างปลอดภัย; หาก Invalid ให้หยุดและชี้ไปที่ `/doctor`)
-- `devflow/project-plan.md` และ `devflow/build-plan.md`
+- `devflow/config.json` (if missing, use safe defaults; if invalid, stop and point to `/doctor`)
+- `devflow/project-plan.md` and `devflow/build-plan.md`
 - `devflow/context/project-overview.md`
-- `devflow/context/{xxx-slug}/` (ถ้ามีงานค้างอยู่)
-- `devflow/context/coding-standards.md` และ `devflow/context/ai-interaction.md`
-- สถานะ Git (`git status`, `git branch`, recent log)
-
-### กฎการเริ่มงาน (Start Conditions):
-1. สถานะ Git Working Tree สะอาด (Clean) บน Default Branch หรือมีเฉพาะ Diff ของฟีเจอร์ปัจจุบัน
-2. `devflow/build-plan.md` มีฟีเจอร์ที่ยังไม่ได้ทำเหลืออยู่
-3. ไม่มี Finding ระดับ P0 หรือ P1 ค้างในสถานะ `open` หรือ `fixed`
-4. บันทึก Commit SHA ตั้งต้นของ Default Branch ไว้สำหรับสรุปผลในรายงานสุดท้าย
+- `devflow/context/{xxx-slug}/` (if work is already active)
+- `devflow/context/coding-standards.md` and `devflow/context/ai-interaction.md`
+- Git status (`git status`, `git branch`, default branch, and recent log)
+
+### Start Conditions:
+1. The project is a Git repository.
+2. The working tree is clean on the default branch, or all dirty work belongs to the
+   active feature on its matching configured feature branch, including proven pending
+   completion handled through the recovery contract.
+3. `devflow/build-plan.md` is a valid ordered checkbox plan with at least one remaining leaf.
+4. Overview is fresh. If stale but both plans are clear and consistent, refresh it
+   using `/overview` behavior and include that change with the first feature.
+5. Existing P0 or P1 findings are not `open` or `fixed`.
+6. Project commands and the exact `Verify` command, when declared, are usable.
+7. Record the starting default-branch commit SHA for the final integration summary.
+
+The initial `devflow/.state/run.json` record required by `AGENTS.md` must already show
+command `continuous` and status `running` before preflight begins. After preflight passes,
+enrich it with boundary `local-only`, the current feature, and completed-feature progress
+against the smaller of the remaining queue or configured limit. Update it when a feature
+starts, after every passing build step, after each quality gate, and after each local main
+commit. On a stop, set status `blocked` with `/continuous resume` when resuming is safe.
+At the end of the queue or limit, set status `completed`.
 
 ---
 
-## Step 2: Serial Feature Lifecycle (วงจรการส่งมอบทีละฟีเจอร์)
+## Step 2: Serial Feature Lifecycle
 
-ดำเนินงานวนลูปทีละ 1 ฟีเจอร์ตามลำดับ:
+Execute the loop one feature at a time in strict order:
 
-### 2.1 Select & Spec (เลือกและร่างสเปก)
-- หาก Resuming: ใช้ Spec เดิมใน `devflow/context/{xxx-slug}/spec.md`
-- หากเป็นฟีเจอร์ใหม่: ถอดความต้องการจาก `build-plan.md` และสร้าง Task Workspace ที่ `devflow/context/{xxx-slug}/` พร้อมเขียน `spec.md`, `stage.md`, `findings.md` และวิเคราะห์ Red-team ก่อนเริ่มโค้ด
+### 2.1 Select & Spec
+- If resuming: Reuse the existing spec in `devflow/context/{xxx-slug}/spec.md`.
+- If new feature: Extract requirements from `devflow/build-plan.md` and initialize the
+  task workspace at `devflow/context/{xxx-slug}/` with `spec.md`, `stage.md`, and `findings.md`.
+  Check `../feature/reference/build-history.md` for `--build-N` naming conventions if
+  rebuilding a previously rolled-back feature, ensuring existing archives in
+  `devflow/history/features/` are never overwritten. Self-review the spec before coding.
 
 ### 2.2 Create / Resume Feature Branch
-- สร้าง Branch ตาม Prefix ใน Config (เช่น `feature/061-slug`) จาก Default Branch
+- Use the configured branch prefix (e.g., `feature/{xxx-slug}`) from the current local default branch.
+- When resuming, require the existing branch and active spec to agree.
+- If switching would strand unrelated work or the default branch changed unsafely, stop.
+  Never stash, reset, or discard work automatically.
 
 ### 2.3 Implement Small Steps with Strict TDD
-- ดำเนินการสร้างฟังก์ชันทีละ Task ตาม Checklist ใน Spec:
-  1. `[TDD-Red]`: เขียน Unit Test ก่อน
-  2. `[TDD-Green]`: เขียนโค้ดขั้นต่ำให้ Test ผ่าน
-  3. `[TDD-Refactor]`: ปรับแต่งโค้ดให้สะอาดและรัน Verification ผ่าน
-  4. ทำเครื่องหมาย `- [x]` ใน Spec และบันทึก Checkpoint Commit บน Branch (หาก `workflow.checkpointCommits: "enabled"`)
+Execute the spec in order, one small diff at a time:
+1. `[TDD-Red]`: Write the failing unit test first.
+2. `[TDD-Green]`: Implement the minimal code to pass the test.
+3. `[TDD-Refactor]`: Clean up and ensure all verifications pass cleanly.
+4. Check off the step (`- [x]`) in `spec.md`.
+5. When `workflow.checkpointCommits` is `enabled`, create a conventional local
+   checkpoint commit containing that passing step and its checked spec state.
+   When `disabled`, keep the work uncommitted until feature completion.
 
 ### 2.4 Apply Continuous Quality Gates
-ตรวจสอบตามการตั้งค่า `qualityGates.continuous` ใน `devflow/config.json`:
-- **Audit**: `manual` (ข้ามอัตโนมัติ), `when-sensitive` (รันเมื่อแตะ Auth/Security/Database/Secrets), `always` (รันทุกฟีเจอร์)
-- **Independent Review**: อ่าน `qualityGates.continuous.independentReview`; `manual` คือ opt-in, `always` บังคับทุกฟีเจอร์, และ `when-sensitive` บังคับเมื่อฟีเจอร์แตะ authentication, authorization, secrets, payments, personal data, destructive operations, dependencies, deployment หรือ security boundary อื่น บันทึกคำตัดสินและหลักฐานต่อฟีเจอร์ใน spec
-- **Check**: `manual` (ข้ามอัตโนมัติ), `when-behavioral` (รันเมื่อมี Runtime Behavior เช่น UI/CLI/API), `always` (รันทุกฟีเจอร์)
-- **Try Guide**: `manual` (ข้ามอัตโนมัติ), `when-user-facing` (สร้าง Try Guide เมื่อเป็น UI/CLI), `always` (สร้างทุกฟีเจอร์)
-
-ทุก product/spec edit ทำให้ receipt เดิมหมดอายุ เมื่อ Independent Review gate
-ทำงาน ให้รัน Verify และสร้าง immutable checkpoint (ได้รับอนุญาตภายใต้ Continuous Mode authority แม้ checkpointCommits จะ disabled) จากนั้นปฏิบัติตาม `/audit independent current`
-หาก `review.independentExecution` เป็น `automatic` ให้ spawn และรอ isolated reviewer child พร้อมตรวจสอบ receipt ให้ผ่านก่อนดำเนินการต่อ
-หากเป็น `manual` หรือ runtime ไม่สามารถพิสูจน์ isolation, identity, model ได้ ให้ตั้งสถานะเป็น `ready` และหยุดด้วย manual handoff
-Continuous Mode จะไม่ทำการ audit งานของตัวเองโดยเด็ดขาด
-
-คำขอจะบันทึก `Requested execution` และ receipt จะบันทึก `Actual execution`
-การจับคู่ของ execution และ reviewer context จะต้องถูกต้องตามสัญญา review
-หากเป็น legacy request ที่ไม่มี `Requested execution` ให้ถือว่าเป็น legacy manual-only ห้ามเติมฟิลด์หรือรัน subagent กับมัน
-
-สำหรับฟีเจอร์ browser-facing ให้รัน `npm run test:browser` เมื่อมี
-`test:browser` script และเก็บ interactive evidence ผ่าน `browseros-neo` เมื่อ
-พร้อมใช้งาน หาก script หรือ MCP ไม่มี ให้บันทึก limitation และหยุดเมื่อ evidence
-นั้นเป็น gate ที่จำเป็น ห้ามติดตั้งหรืออ้างผลโดยปริยาย
+Evaluate `qualityGates.continuous` in `devflow/config.json`:
+- **Audit**: `manual` skips automatic audit; `when-sensitive` runs `/audit current`
+  for authentication, authorization, payments, secrets, personal or user data, migrations,
+  destructive operations, external side effects, security boundaries, or unusually broad changes;
+  `always` audits every feature.
+- **Independent Review**: Read `qualityGates.continuous.independentReview`; `manual` skips
+  automatic review; `when-sensitive` requires an isolated reviewer for the same sensitive
+  categories as Audit; `always` requires an isolated reviewer for every feature. A passing
+  independent receipt satisfies the Audit gate for that feature.
+- **Check**: `manual` skips automatic `/check`; `when-behavioral` runs it when a done-when
+  needs observed runtime behavior (UI, CLI, API, background job); `always` checks every feature.
+- **Try Guide**: `manual` skips automatic generation; `when-user-facing` generates a guide
+  for UI, CLI, or user-facing workflows; `always` generates one for every feature.
+
+Run required gates in order: check, review, then try guide. When independent review is
+selected, ensure application code is in a clean immutable checkpoint. First rerun final
+verification and selected Check gate and set spec status to `verified`. This review
+checkpoint is covered by Continuous Mode authority even when step checkpoint commits are
+disabled. Follow `/audit independent current`.
+
+With `review.independentExecution: "automatic"`, spawn and wait for the isolated reviewer
+subagent and validate its receipt before continuing. With `manual`, or when runtime cannot
+prove isolation, identity, model, or completion, set activity to `ready` and stop with the
+manual handoff. Continuous Mode never audits its own work.
+
+The request records `Requested execution`; the receipt records `Actual execution`. Require
+the execution and reviewer-context pairing defined by the review contract. A pending request
+without `Requested execution` is legacy manual-only.
+
+For browser-facing features, run `npm run test:browser` when `test:browser` script exists
+and collect interactive evidence via `browseros-neo` when available.
 
 ### 2.5 Repair Findings
-- ซ่อมแซม Finding ระดับ P0/P1 ที่เกิดขึ้นจากฟีเจอร์นี้โดยอัตโนมัติ (ไม่เกิน `continuous.maxRepairAttempts` ครั้ง)
-- หากไม่สามารถซ่อมแซมได้ หรือมี P0/P1 ค้างอยู่ ให้หยุดการทำงานทันที
+- Automatically repair confirmed P0 and P1 findings directly caused by the feature, up to
+  `continuous.maxRepairAttempts` times.
+- After repair, rerun affected verification and re-audit the repaired area.
+- Any unresolved P0 or P1 finding left `open` or `fixed` stops the loop before completion.
 
 ### 2.6 Complete Locally Like a Human
-- รัน Verification ขั้นสุดท้าย
-- ย้ายและ Archive เอกสารไปที่ `devflow/history/features/{xxx-slug}.md`
-- อัปเดตเช็คบ็อกซ์ใน `devflow/build-plan.md`
-- ลบโฟลเดอร์รัน `devflow/context/{xxx-slug}/`
-- Squash-merge Feature Branch เข้าสู่ Local Main และลบ Feature Branch ใน Local
-- นับจำนวนฟีเจอร์ที่สำเร็จเพิ่มขึ้น 1
+Apply the `/complete` safety, logging, and archive behavior without asking commit and merge prompts:
+1. Run final documented verification.
+2. Confirm the current spec status is `verified`.
+3. Capture source tree / annotation proof per `../complete/reference/completion-recovery.md`
+   and embed `<!-- devflow:completion {...} -->` in the archive.
+4. Place the archive at `devflow/history/features/{xxx-slug}.md`.
+5. Update checkboxes in `devflow/build-plan.md` and append entry to `devflow/history/HISTORY.md`.
+6. Remove the active run directory `devflow/context/{xxx-slug}/`.
+7. Switch to the local default branch, squash-merge the feature branch, and create one
+   conventional commit containing product work, tests, and DevFlow history.
+8. Delete the merged local feature branch.
+9. Confirm the default branch is clean before selecting the next feature.
 
 ---
 
 ## Step 3: Optional Final Integration Audit
 
-เมื่อครบกำหนดจำนวนฟีเจอร์หรือหมด `build-plan.md` หาก `continuous.finalIntegrationAudit: true` ให้รันการตรวจสอบความเข้ากันได้แบบบูรณาการ (Cross-Feature Contracts & Seams) จากจุดเริ่มต้นถึง HEAD ปัจจุบัน
+When the feature queue completes or `continuous.maxFeatures` is reached, if
+`continuous.finalIntegrationAudit: true`, execute an integration compatibility check
+(Cross-Feature Contracts & Seams) covering the span from the starting commit to current HEAD.
 
 ---
 
-## Step 4: Stop & Report (สรุปรายงานผลลัพธ์)
+## Step 4: Stop & Report
 
-เมื่อการทำงานสิ้นสุด (ไม่ว่าจะสำเร็จครบถ้วน หรือหยุดเนื่องจากติดเงื่อนไขความปลอดภัย) ให้รายงานสรุปเป็นภาษาไทย:
-- Commit เริ่มต้น และ Commit สุดท้ายของ Default Branch
-- รายชื่อฟีเจอร์ที่จัดส่งสำเร็จในรอบนี้ พร้อม Commit Hash
-- ผลการรัน Quality Gates และการซ่อมแซม Findings (ถ้ามี)
-- ความคืบหน้าภาพรวมของ `build-plan.md` และฟีเจอร์ถัดไป
-- ย้ำเตือนชัดเจนว่า **ไม่มีการ Push ใดๆ ขึ้น Remote Repository**
+When Continuous Mode finishes (either fully completed or stopped at a safety boundary),
+present a concise summary report in Thai (per user communication rules):
+- Starting and ending commit SHAs of the local default branch.
+- List of features delivered in this run with their commit hashes.
+- Summary of quality gates executed and findings resolved.
+- Overall progress of `devflow/build-plan.md` and next upcoming feature.
+- Clear reminder that **no remote push or deployment has occurred**.

package/template/.claude/skills/feature/SKILL.md

@@ -126,6 +126,10 @@ build plan starts high-level.
 
 ## Step 3 - write the spec
 
+Before review, allocate the selected feature ID's build attempt using
+`reference/build-history.md`: first build 1, otherwise one greater than
+the maximum proven prior attempt after all prior builds were reversed. For attempt N > 1, append `--build-N` to the slug and archive path (e.g. `086-export--build-2.md`).
+
 For the one (sub-)feature being built now, allocate sequential ID (`xxx-slug`) and create a dedicated workspace at `devflow/context/{xxx-slug}/`. Write the full living spec to
 `devflow/context/{xxx-slug}/spec.md`, following `reference/feature-spec-template.md`. Also initialize `stage.md` and `findings.md` in that folder. The first heading and build-plan identity must use this canonical form:
 
@@ -133,8 +137,10 @@ For the one (sub-)feature being built now, allocate sequential ID (`xxx-slug`) a
 # Feature: <title>
 
 **From build-plan:** feature <id>
+**Build attempt:** <positive integer>
 ```
 
+
 Fill every section:
 - Goal, Problem Statement, and In/Out of scope
 - Acceptance Criteria (AC-1, AC-2, ...)