create-issflow 1.7.0 → 1.8.1

package/README.md

@@ -7,14 +7,14 @@ and tool-agnostic. Non-destructive: it never overwrites your files.
 
 ```bash
 cd my-project
-npx create-issflow                  # prompts for your AI tool
-npx create-issflow --tool=claude    # or pass it: claude | codex | cursor | gemini | aider | all
-# then open your tool — Claude Code fires the SessionStart hook automatically
+npx create-issflow                  # omit --tool = install EVERY adapter
+npx create-issflow --tool=cursor    # claude | codex | cursor | gemini | aider | all
+# then open your tool and run:
 /overview                           # bootstrap the project
 ```
 
 Flags:
-- `--tool=<name>` — pick the target tool (skips the prompt). `all` writes every adapter.
+- `--tool=<name>` — pick the target tool. **Omit = `all`** (every adapter).
 - `--ci` — also write `.github/workflows/issflow-feature.yml` (headless `/feature`
   via GitHub Actions: label an issue `feature:approved` → the lane runs).
 - `--docker` — also write `Dockerfile.issflow` + `scripts/feature-docker.js`
@@ -36,15 +36,15 @@ The portable kit (every tool) in `<project>/.claude/`:
 - `hooks/` — session-start · context-guard · plan-gate (rule-13 enforcement) · pre-compact · subagent-stop · feature-gate (Stop gate for `/feature`, artifact-verified)
 - `istartsoft-flow/METHODOLOGY.md` — the full methodology (single source of truth)
 
-Plus a root `AGENTS.md` (the open standard) and the per-tool adapter:
+Plus a root **`AGENTS.md`** (open standard — primary entry) and the per-tool adapter:
 
 | Tool | Adds |
 |------|------|
-| `claude` | merges hooks into `.claude/settings.json` |
 | `codex` | nothing extra — `AGENTS.md` is read natively |
 | `cursor` | `.cursor/rules/` + `.cursor/commands/` + `.cursor/hooks.json` |
 | `gemini` | `GEMINI.md` pointer |
 | `aider` | `.aider.conf.yml` that loads the methodology |
+| `claude` | thin `CLAUDE.md` (`@AGENTS.md`) + merges hooks into `.claude/settings.json` |
 | `all` | every adapter above |
 
 It also un-ignores the workflow dirs in `.gitignore` if `.claude/*` was ignored.

package/bin/cli.js

@@ -40,7 +40,7 @@ function printHelp() {
 
 Usage: npx create-issflow [--tool=<name>] [--dry-run] [--force]
 
-Tools (--tool=, interactive prompt if omitted):`);
+Tools (--tool=). Omit --tool to install EVERY adapter (same as --tool=all):`);
   for (const [k, v] of Object.entries(TOOLS)) log(`  ${k.padEnd(7)} ${v}`);
   log(`
 Flags:
@@ -51,27 +51,22 @@ Flags:
   -h, --help  this message
 
 Every tool installs the portable kit in .claude/ + a root AGENTS.md (the open
-standard). The full methodology lives in .claude/istartsoft-flow/METHODOLOGY.md.`);
+standard — primary entry for most hosts). The full methodology lives in
+.claude/istartsoft-flow/METHODOLOGY.md. Claude Code also gets a thin CLAUDE.md
+shim (@AGENTS.md) because that host only auto-loads CLAUDE.md.`);
 }
 
-// Resolve the target tool: flag -> interactive (TTY) -> default 'claude'.
+// Typo / alias map → canonical TOOLS key
+const TOOL_ALIASES = { cusor: 'cursor' };
+
+// Resolve the target tool: --tool= flag → default 'all' when omitted.
 function pickTool() {
   if (toolArg) {
-    if (!TOOLS[toolArg]) { console.error(`create-issflow: unknown --tool=${toolArg}. One of: ${Object.keys(TOOLS).join(', ')}`); process.exit(1); }
-    return toolArg;
-  }
-  if (process.stdin.isTTY && process.stdout.isTTY && !DRY) {
-    const keys = Object.keys(TOOLS);
-    process.stdout.write('\nWhich AI coding tool? (the kit is portable — pick your primary)\n');
-    keys.forEach((k, i) => process.stdout.write(`  ${i + 1}) ${k} — ${TOOLS[k]}\n`));
-    process.stdout.write('> ');
-    let line = '';
-    try { line = (fs.readFileSync(0, 'utf8').split('\n')[0] || '').trim().toLowerCase(); } catch (_) {}
-    const chosen = TOOLS[line] ? line : keys[parseInt(line, 10) - 1];
-    if (!chosen) { console.error('create-issflow: no valid choice; defaulting to claude.'); return 'claude'; }
-    return chosen;
+    const key = TOOL_ALIASES[toolArg] || toolArg;
+    if (!TOOLS[key]) { console.error(`create-issflow: unknown --tool=${toolArg}. One of: ${Object.keys(TOOLS).join(', ')}`); process.exit(1); }
+    return key;
   }
-  return 'claude'; // non-interactive default = back-compatible
+  return 'all'; // omit --tool = every adapter
 }
 
 // write a single file, non-destructive (honors DRY/FORCE).
@@ -206,22 +201,28 @@ const NEXT_STEPS = {
 function agentsMd() {
   return [
     '# AGENTS.md — iStartSoftFlow', '',
-    'This repo runs the **iStartSoftFlow** agentic dev workflow. The complete,',
-    'tool-agnostic methodology — the loop, roles, procedures, rituals, and hard',
-    'rules — lives in ONE file. Read it before acting:', '',
+    'This repo runs the **iStartSoftFlow** agentic dev workflow.', '',
+    '**Primary entry (this file).** The complete, tool-agnostic methodology — loop,',
+    'roles, procedures, rituals, hard rules — lives in ONE place. Read before acting:', '',
     '> **`.claude/istartsoft-flow/METHODOLOGY.md`** ← single source of truth.', '',
-    'Do not restate its rules elsewhere; this file only indexes it (anti-drift invariant).', '',
+    'The portable kit lives in **`.claude/`** (folder name = host convention for',
+    'commands/agents/hooks — content is tool-agnostic; see `.claude/README.md`).',
+    'Do not restate METHODOLOGY rules elsewhere (anti-drift).', '',
     '## The loop', '',
-    'design-research → grill ×2 → plan → implement → test → deploy — one VERTICAL',
-    'SLICE per phase. Phase 0 (infra) leads only when infra is self-managed.', '',
+    'design-research → grill ×2 → plan → (propose/design if quoted) → implement →',
+    'test → deploy — one VERTICAL SLICE per phase. Phase 0 (infra) only when',
+    'infra is self-managed.', '',
     '## Roles — `.claude/agents/`', '',
     'planner · researcher · implementer · test-author · debugger · e2e-runner · synthesizer', '',
     '## Procedures — `.claude/commands/` (run as `/name`)', '',
-    '/overview · /feature · /goal · /propose · /phase · /sprint · /ui-audit · /qa-audit ·',
-    '/security-audit · /release · /uat · /change-request · /replan · /quick · /synthesize ·',
-    '/runbook · /store-wisdom · /log-issue · /log-decision · /unstuck', '',
+    '**Default:** `/overview` · `/feature` · `/quick`', '',
+    '**Advanced:** `/propose` · `/design` · `/support` · `/phase` · `/sprint` · `/goal` ·',
+    '`/ui-audit` · `/qa-audit` · `/security-audit` · `/release` · `/uat` ·',
+    '`/change-request` · `/replan` · `/synthesize` · `/runbook` · `/store-wisdom` ·',
+    '`/log-issue` · `/log-decision` · `/unstuck`', '',
     '## Skills — `.claude/skills/` (loaded on demand)', '',
-    'caveman · grill-me · karpathy-guidelines · ux-design · security (Secure SDLC) · code-standards', '',
+    'caveman · grill-me · karpathy-guidelines · ux-design · security · code-standards ·',
+    'support-triage', '',
     '## Autonomy', '',
     'Planning (`/overview` grill + plan approval) always asks — that input is cheap.',
     '**AUTO (default)** governs the DEV loop: follow the plan, decide + log + continue,',
@@ -230,16 +231,8 @@ function agentsMd() {
     'mid-flow. **GUIDED** asks at each fork in dev too. Declare the mode in',
     '`docs/OVERVIEW.md`. See METHODOLOGY → Autonomy.', '',
     '## Hard-rule index (full text in METHODOLOGY.md)', '',
-    '1 grep ISSUES + research before debugging · 2 debug cap = 3 (AUTO: park + continue) ·',
-    '3 log every fix · 4 synthesize + context-reset per phase · 5 phase gate = real suite',
-    'green · 6 blind tests (RED-first) · 7 programmatic E2E auth · 8 log-decision on arch',
-    'change · 9 UI conforms to the `ux-design` cookbook + wireframe frame · 10 no-rationalization ·',
-    '11 Secure SDLC: threat-model → secure coding → SAST/SCA/secrets each phase → pentest',
-    'gate + security review before deploy (`security` skill) · 12 code-standards gate:',
-    'lint/format clean + naming per language idiom + declared architecture (`code-standards`) ·',
-    '13 PLAN-APPROVAL gate: no phase/sprint starts until `docs/PLAN.md` is human-approved ·',
-    '14 UNDERSTAND-FIRST gate: brief back any new free-text task and wait for confirm',
-    'before executing (an approved PLAN/FEATURE/CR/goal is the recorded confirmation).', '',
+    '1–12 as in METHODOLOGY · 13 PLAN-APPROVAL · 14 UNDERSTAND-FIRST ·',
+    '15 DESIGN + ARCHITECTURE gates (after proposal, before `/phase`; internal may n/a).', '',
     '## Your stack', '',
     'Declare your stack (language, framework, infra, auth, test + E2E runner,',
     'planning source) once in `docs/OVERVIEW.md`. Every rule references *your declared',
@@ -249,17 +242,14 @@ function agentsMd() {
 
 function claudeMd() {
   return [
-    '# CLAUDE.md — iStartSoftFlow (Claude Code entry)', '',
+    '# CLAUDE.md — host shim for Claude Code', '',
     '@AGENTS.md', '',
-    'The import above is the single source of truth — it points to',
-    '`.claude/istartsoft-flow/METHODOLOGY.md` (read on demand). Do NOT restate any',
-    'rule here; this file only wires Claude-native mechanisms (anti-drift invariant).', '',
-    '## Claude-native wiring (automatic — see `.claude/settings.json`)', '',
-    '- **SessionStart** hook injects git state + `docs/STATE.md` + open `docs/ISSUES.md`',
-    '  + the rule summary each session — read those first.',
-    '- **PreCompact** + **SubagentStop** hooks run their rituals automatically.',
-    '- Commands in `.claude/commands/` run as `/name`; agents in `.claude/agents/` are',
-    '  native subagents.', '',
+    'Claude Code auto-loads **this filename only**. The import above is the real',
+    'entry (`AGENTS.md` → METHODOLOGY). Do NOT restate rules here.', '',
+    '## Host wiring (automatic — see `.claude/settings.json`)', '',
+    '- **SessionStart** injects git state + `docs/STATE.md` + open `docs/ISSUES.md`.',
+    '- **PreCompact** + **SubagentStop** rituals run automatically.',
+    '- Commands in `.claude/commands/` → `/name`; agents in `.claude/agents/` → native subagents.', '',
   ].join('\n');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-issflow",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Scaffold the iStartSoftFlow AI-coding workflow into a project. Stack-agnostic, tool-agnostic (Claude Code, Codex, Cursor, Gemini, Aider), non-destructive.",
   "bin": {
     "create-issflow": "bin/cli.js"

package/template/.claude/README.md

@@ -0,0 +1,33 @@
+# `.claude/` — portable iStartSoftFlow kit
+
+This directory is the **portable workflow kit** installed into every project.
+Content is **tool-agnostic**. The folder name `.claude/` is a **host convention**
+(Claude Code and several other agents load commands/agents/hooks from this path).
+It is **not** “Claude-only product branding.”
+
+**Human entry points (repo root):**
+
+| File | Role |
+|------|------|
+| `AGENTS.md` | Open-standard primary entry — indexes this kit |
+| `CLAUDE.md` | Thin shim (`@AGENTS.md`) — only because Claude Code auto-loads that filename |
+
+**Single source of truth for rules:** [`istartsoft-flow/METHODOLOGY.md`](./istartsoft-flow/METHODOLOGY.md)
+
+## Layout
+
+| Path | What |
+|------|------|
+| `agents/` | Fresh-context workers (planner, researcher, implementer, …) |
+| `commands/` | Procedures — Default: `/overview` `/feature` `/quick`; Advanced: `/propose` `/design` `/support` … |
+| `skills/` | On-demand cookbooks (ux-design, security, support-triage, …) |
+| `hooks/` | Lifecycle enforcement (context, plan gate, feature gate, …) |
+| `istartsoft-flow/` | METHODOLOGY.md — every hard rule lives here once |
+| `templates/` | Proposal / UX pack / architecture / CR / FEATURE / automation |
+| `settings.json` | Host hook wiring (when using Claude Code adapter) |
+| `flow-config.json` | Context watchdog + sprint knobs (optional overrides) |
+
+Do **not** duplicate METHODOLOGY rules into other files (anti-drift).
+Do **not** put personal rate cards or salary numbers in this kit.
+
+Installer: `npx create-issflow` (omit `--tool` = all adapters).

package/template/.claude/commands/change-request.md

@@ -33,36 +33,57 @@ Is this an in-scope **clarification** (no cost change) or a real **scope change*
 (add / remove / alter)? Clarification -> log it, proceed, no re-price. Scope change
 -> continue.
 
+Also classify commercial lane:
+- **Warranty / defect** (bug vs approved scope, inside support window) → prefer
+  `/support` or `/quick` — not a billable CR unless the client expands scope.
+- **Billable CR** → continue below.
+
 ## STEP 2 — IMPACT ANALYSIS
 Determine:
 - phases affected — **done phases are frozen** (their cost is already spent and
   counts); new / changed phases; cut phases (credit back the un-started effort).
-- knock-on effects — architecture, **security (re-threat-model?)**, tests, timeline.
+- knock-on effects — architecture, **UX pack**, **security (re-threat-model?)**,
+  tests, timeline. If UX or arch artifacts change, those gates re-open (rule 15).
 - dispatch `researcher` (DESIGN or IMPL) if the change needs grounding in facts.
 
-## STEP 3 — RE-ESTIMATE (the DELTA only; reasonable + transparent)
-- Use the SAME estimation config as PROPOSAL.md (unit, rate card, currency,
-  contingency) — consistency is what makes the re-price defensible.
+## STEP 3 — RE-ESTIMATE (the DELTA only)
+- Reuse the SAME estimation config used for the approved proposal’s **internal**
+  math (unit, rate card, currency, contingency) if still available in a private
+  estimate memo or chat-recorded answers.
+- If rate / contingency is missing → **ASK once** (same rule as `/propose`). Never
+  invent a kit default rate; never commit personal rates into public kit files.
 - added effort × rate = added cost; cut effort = credit.
-- **net cost Δ** + **new total** vs the approved baseline — as a range + assumptions.
+- **net cost Δ** + **new total** vs the approved baseline — as a range.
+- Show rate math **in chat to the human only**.
 - **timeline Δ**. State what stays the SAME so the client sees the price is fair.
 
-## STEP 4 — LOG the change order to docs/CHANGES.md (append-only)
+### CLIENT-DOC RULE
+Anything the client sees (CR summary, updated PROPOSAL.md / proposal.html) shows
+**Δ cost + new total** (and effort/timeline) only — **never** rate, rate card, or
+contingency %.
+
+## STEP 4 — LOG the change order
+1. Append a one-line summary to `docs/CHANGES.md` (append-only):
 ```
 CR-<n> | <date> | <change> | impact: <phases> | effort Δ: <±days> |
 cost Δ: <±amount> | new total: <amount> | status: proposed
 ```
+2. Fill `.claude/templates/CR-template.md` → `docs/changes/CR-<n>.md` (detail:
+   classification, impact, Δ cost, warranty vs billable, status). Keep the detail
+   file client-safe on money fields (totals only).
 
 ## STEP 5 — APPROVAL GATE
-Show me CR-<n> (impact + price delta + new total). **STOP for approval** (commercial
-gate — always interactive).
+Show me CR-<n> (impact + price delta + new total — no rate). **STOP for approval**
+(commercial gate — always interactive).
 - **Approved** -> set CR status `approved`; bump PROPOSAL.md to a new version (vN+1)
-  with the delta folded in; re-render `docs/proposal.html` from it (same template +
-  language); then dispatch `/replan` to apply the phase changes to PLAN.md (done
-  phases stay frozen). Update STATE.md. NOTE: `/replan` reverts PLAN.md to
-  `> Approval: PENDING` and re-runs the PLAN-APPROVAL gate (hard rule 13) — the
-  commercial CR sign-off is SEPARATE from the plan sign-off, so `/phase` and
-  `/sprint` stay blocked until you also re-approve the revised plan.
+  with the delta folded in (**totals only**); re-render `docs/proposal.html` from it
+  (same template + language; no contingency note / rate); then dispatch `/replan` to
+  apply the phase changes to PLAN.md (done phases stay frozen). Update STATE.md.
+  NOTE: `/replan` reverts PLAN.md to `> Approval: PENDING` and re-runs the
+  PLAN-APPROVAL gate (hard rule 13) — the commercial CR sign-off is SEPARATE from
+  the plan sign-off, so `/phase` and `/sprint` stay blocked until you also
+  re-approve the revised plan. If UX/arch scope changed, reset `design:` /
+  `architecture:` in STATE to PENDING (rule 15) before build resumes.
 - **Rejected** -> set CR status `rejected`; PLAN + PROPOSAL unchanged.
 
 ## STEP 6 — RECORD

package/template/.claude/commands/design.md

@@ -0,0 +1,51 @@
+---
+description: Post-proposal DESIGN + ARCHITECTURE gates — produce UX pack and architecture note, stop for human approve before /phase (hard rule 15).
+argument-hint: [optional: "ux" | "arch" | "both" · "dry-run"]
+---
+
+Caveman ULTRA mode. You are the ORCHESTRATOR.
+
+Purpose: after a **client proposal is signed** (or when the project opts into these
+gates), produce build-ready design + architecture artifacts and get human approve
+**before** `/phase` runs. Vertical slices still build UX+code together — these gates
+lock the *frame* first (model B).
+
+DRY-RUN: if `$ARGUMENTS` contains `dry-run`/`--dry-run`, outline what you'd write
+and STOP. Write nothing.
+
+## PRE-FLIGHT
+- Read `docs/OVERVIEW.md`, `docs/PLAN.md`, `docs/PROPOSAL.md` (if any), `docs/STATE.md`.
+- PLAN must be approved (rule 13). If a proposal exists for quoted work, it should
+  be signed off first (`/propose`) — otherwise warn and confirm they want design
+  gates without a commercial proposal (internal projects may skip `/propose` and
+  still run `/design`, or skip rule 15 entirely when STATE has `design: n/a` and
+  `architecture: n/a` set deliberately for non-quoted work).
+
+Target: `$ARGUMENTS` → `ux` | `arch` | `both` (default **both**).
+
+## STEP 1 — UX PACK (if ux|both)
+1. Apply `ux-design` skill (authoring mode): wireframe baseline + cookbook direction.
+2. Scaffold or update `docs/UX-PACK.md` from `.claude/templates/UX-PACK-template.md`.
+3. Fill flows, screen inventory, tokens/frame, a11y notes from OVERVIEW + PLAN.
+4. SHOW me UX-PACK.md. **STOP for approval.**
+5. On approve: stamp `> Approval: approved <date> v<n>`; set `design: approved <date>`
+   in STATE.md; HISTORY line `design v<n> approved`.
+6. On change request: revise and re-show; header stays PENDING.
+
+## STEP 2 — ARCHITECTURE (if arch|both)
+1. Dispatch `researcher` (DESIGN) only if open unknowns remain; else use OVERVIEW.
+2. Scaffold or update `docs/ARCHITECTURE.md` from
+   `.claude/templates/ARCHITECTURE-template.md`.
+3. Apply `code-standards` architecture guidance; security trust boundaries via
+   `security` skill when relevant.
+4. SHOW me ARCHITECTURE.md. **STOP for approval.**
+5. On approve: stamp header; set `architecture: approved <date>` in STATE.md;
+   HISTORY line `architecture v<n> approved`. Optionally `/log-decision` for
+   material pattern choices.
+6. On change request: revise and re-show.
+
+## STEP 3 — HANDOFF
+When both required gates are approved (or N/A for internal skip):
+- Tell me `/phase` is unblocked for rule 15.
+- Reminder: frontend phases still run the `ux-design` CLOSE check (rule 9);
+  architecture drift still needs `/log-decision` (rule 8).

package/template/.claude/commands/log-issue.md

@@ -13,6 +13,8 @@ Canonical format:
 ### <short error title — searchable, literal error keywords>
 
 - [ ] open      (or “- [x] resolved” once fixed)
+- severity: P1 | P2 | P3   (optional; required when filed via /support)
+- commercial: warranty | billable | n/a
 - symptom: <what was observed>
 - root cause: <the REAL underlying cause>
 - solution: <exact fix, or “pending”>
@@ -26,5 +28,6 @@ Rules:
 - open issues use the empty box `- [ ]`; resolved are checked `- [x] resolved`
   (the SessionStart hook surfaces every `- [ ]` as open — keep the box empty until fixed).
 - open issues go at the TOP; resolved below; archived oldest at bottom.
+- For after-go-live tickets prefer `/support` first (triage), then this log.
 
 Confirm the entry back in 2 lines.

package/template/.claude/commands/overview.md

@@ -104,10 +104,14 @@ proceeds to the planner. (This is the planning confirmation gate.)
 
 phase: 0 (pending)
 plan: PENDING
+design: PENDING
+architecture: PENDING
 completed: project bootstrapped — design research done, double grill done
 blocker: none
 
 ```
+(For internal non-quoted work you may set `design: n/a` and `architecture: n/a`
+instead of PENDING so rule 15 does not block `/phase`.)
 8. Create docs/ISSUES.md with header `# Issues` and `## Archived` section.
 
 9. Create empty docs/HISTORY.md.
@@ -138,6 +142,9 @@ blocker: none
 
     AUTO governs the development loop that runs AFTER this gate, never the gate itself.
 
-Optional next step (client / quoted work only): run `/propose` to turn this
-OVERVIEW + PLAN into a proposal + estimate for sign-off before building. Internal or
-personal projects skip it and go straight to `/phase`.
+Optional next steps (client / quoted work):
+1. `/propose` — proposal + estimate (asks rate in chat; client docs stay totals-only).
+2. `/design` — UX pack + architecture approve gates (hard rule 15) before `/phase`.
+
+Internal or personal projects may skip `/propose` and set `design: n/a` /
+`architecture: n/a` in STATE, then go to `/phase`.

package/template/.claude/commands/phase.md

@@ -29,6 +29,16 @@ a. PLAN-APPROVAL CHECK (hard rule 13): Read the docs/PLAN.md `> Approval:` heade
    start. Route me to the `/overview` PLAN-APPROVAL gate (or `/replan` then re-approve).
    Approved -> continue.
 
+a2. DESIGN + ARCHITECTURE GATES (hard rule 15): Read `docs/STATE.md` for `design:`
+    and `architecture:`.
+    - Quoted / client work (approved `docs/PROPOSAL.md` exists): both must read
+      `approved <date>` (or explicit `n/a` only if the human waived the gate in
+      writing). Still PENDING / missing -> STOP. Route me to `/design`.
+    - Internal / no proposal: if STATE has `design: n/a` and `architecture: n/a`,
+      continue; if fields are missing, treat as n/a once (set them) unless OVERVIEW
+      opted into the gates.
+    Approved / n/a -> continue.
+
 b. INFRA CHECK (phases > 0): Read the declared infra in docs/OVERVIEW.md.
    - Managed infra -> confirm it is reachable; no provisioning step is needed.
    - Self-managed infra -> confirm Phase 0 (infra) ran and is healthy.

package/template/.claude/commands/propose.md

@@ -34,18 +34,37 @@ Derive the vertical-slice phases (or read `docs/PLAN.md` if it exists). Size eac
 - effort: an ideal-days RANGE (e.g. 2–3d), + story points if your team uses them
 - risk / unknowns: what could move the estimate
 
-## STEP 3 — ESTIMATE (flexible, transparent — no false precision)
-Read the **estimation config** from OVERVIEW (or ask once — a commercial/planning
-input, allowed). Everything is configurable; use sensible defaults if unset:
-- **unit:** ideal-days (default) | story-points | both.
-- **rate card:** a single blended rate, OR per-role rates (e.g. senior / mid /
-  junior). Cost = Σ(effort per role × that role's rate).
-- **currency:** as declared (THB default for a Thai project).
-- **contingency:** a % buffer for unknowns (default 10–15%).
-- **payment milestones:** by-phase, or a split (e.g. 30/40/30), or none.
-- **language:** the rendered doc's language (default = the project language).
-Compute cost per phase, then a **Total as a RANGE (low–high)** incl. contingency —
-show the math. **Timeline:** phases in dependency order → calendar estimate (note parallelism).
+## STEP 3 — ESTIMATE (ask rate · never invent a kit default)
+Estimation config is **project-private**. The public kit ships **no** default rate
+card and **no** sample salary/rate numbers — rates are confidential.
+
+1. Read estimation fields from OVERVIEW **only if the human already put them there
+   for this project** (unit, rate card, currency, contingency, milestones, language).
+2. If **rate card** or **contingency** is missing → **ASK once** in chat (commercial
+   input, allowed). Do not guess. Do not copy rates from other repos or prior chats
+   into kit files.
+3. Optional: store the answered rate/contingency in a **project-local** file the
+   team keeps private (e.g. `docs/ESTIMATE.local.md` gitignored, or OVERVIEW fields
+   that never get published). Never commit personal rate/salary into a public kit
+   or template.
+4. Configurable fields (ask or read — no invented kit defaults for money):
+   - **unit:** ideal-days | hours | story-points | both
+   - **rate card:** blended OR per-role (senior / mid / junior…)
+   - **currency:** as declared (ask if unset; THB is common for Thai clients)
+   - **contingency:** % buffer for unknowns (ask if unset)
+   - **payment milestones:** by-phase, split (e.g. 30/40/30), or none
+   - **language:** rendered doc language (default = project language)
+
+Compute cost per phase, then a **Total as a RANGE (low–high)** that already folds
+in contingency. Show the math **in chat to the human** (rate × effort + contingency).
+**Timeline:** phases in dependency order → calendar estimate (note parallelism).
+
+### CLIENT-DOC RULE (hard — commercial privacy)
+Client-facing artifacts (`docs/PROPOSAL.md` client sections, `docs/proposal.html`,
+and any PDF/print) MUST show **totals and phase costs only**.
+**Never** print: hourly/day rates, rate cards, contingency %, “incl. X% buffer”,
+salary, or the estimate math. Contingency is already inside the numbers — do not
+label it on the client page.
 
 ## STEP 4 — ASSUMPTIONS & EXCLUSIONS
 List every assumption the estimate rests on (infra provided, third-party/licence
@@ -54,29 +73,41 @@ change-orders re-price against.
 
 ## STEP 5 — WRITE + RENDER
 1. Write `docs/PROPOSAL.md` — the SOURCE OF TRUTH (versioned v1 + date). This is
-   what `CHANGES.md` re-prices against. Template:
+   what `CHANGES.md` re-prices against. **Client-safe** body (no rate / no
+   contingency %):
 ```
 # Proposal — <project>   (v1, <date>)
 ## Scope        — in-scope: … | out-of-scope: …
 ## Phases       — table: phase | complexity | effort (range) | cost
-## Total        — <low>–<high> (incl. <buffer>% contingency)
+## Total        — <low>–<high>   ← totals only; no “incl. X% contingency”
 ## Timeline     — <estimate>, dependency order
 ## Assumptions  — …
 ## Exclusions   — …
 ## Payment      — milestones (if any)
 ## Sign-off     — approved by: ___  date: ___  version: v1
 ```
+   If you keep an internal rate memo, put it in a **separate private** file (not
+   the client PROPOSAL.md / HTML). PROPOSAL.md itself stays client-safe so it can
+   be shared.
+
 2. RENDER a client-facing `docs/proposal.html` from `.claude/templates/proposal.html`:
    copy it, replace every `{{PLACEHOLDER}}`, and fill the CONTENT in the declared
    language (the section labels are already bilingual TH / EN). It must fit ONE A4
    page — be terse (≈ 3–6 phase rows, ≈ 4 assumptions, short scope items); trim before
    it spills to a second page. Fill `{{COMPANY}}` / `{{COMPANY_TAGLINE}}` / `{{LOGO}}`
    from the ISSUING company's brand declared in OVERVIEW (or ask once) — white-label,
-   never hardcode the kit's name. Print-ready (Ctrl/Cmd-P → A4 → Save as PDF). Keep
-   PROPOSAL.md (source) and proposal.html (deliverable) in sync.
+   never hardcode the kit's name. Leave `{{TOTAL_NOTE}}` empty or a non-rate line
+   (e.g. currency / “ราคารวมทั้งโครงการ”) — **never** a contingency % or rate.
+   Print-ready (Ctrl/Cmd-P → A4 → Save as PDF). Keep PROPOSAL.md and proposal.html
+   in sync.
 
 ## STEP 6 — SIGN-OFF GATE
 Show me the proposal. **STOP for approval** (commercial gate — always interactive).
 On approval: record the approved version + date in PROPOSAL.md and STATE.md, and
-append a HISTORY line `proposal v<n> approved (<total>)`. Building starts only after
-sign-off. On rejection: revise per feedback and re-show.
+append a HISTORY line `proposal v<n> approved (<total>)`.
+
+**Next (quoted / client work):** before `/phase`, run the **DESIGN + ARCHITECTURE
+gates** (METHODOLOGY lifecycle · hard rule 15) — produce `docs/UX-PACK.md` +
+`docs/ARCHITECTURE.md`, get human approve, stamp STATE. Building starts only after
+proposal sign-off **and** those gates (or explicit skip for internal non-quoted
+work). On rejection: revise per feedback and re-show.

package/template/.claude/commands/release.md

@@ -49,7 +49,16 @@ sign-off** — a release gate, always interactive in both modes.
 On a SIGNED sign-off only: deploy to production, smoke-test prod (health 200), update
 `docs/ENDPOINTS.md` base URL, tag the release. HISTORY line: `released v<n> (<date>)`.
 
-## STAGE 8 — GO-LIVE & SUPPORT
-Enter after-go-live support (hypercare): watch for incidents, keep the issue log live.
-New scope → `/change-request` (impact + re-price + sign-off). The project is live; the
-loop continues through change requests.
+## STAGE 8 — GO-LIVE & SUPPORT (hypercare)
+Enter after-go-live support:
+
+1. **Watch** — incidents, error budgets, critical paths; keep `docs/ISSUES.md` live.
+2. **Front door** — route client/prod reports through `/support` (severity P1–P3,
+   warranty vs billable). Warranty defects → `/quick` (or larger lane); do not
+   silently expand scope for free.
+3. **New scope** → `/change-request` (impact + re-price + sign-off).
+4. **Ops memory** — update `/runbook` when a fix changes operational steps.
+5. Default warranty window if unset: **30 days** from this promote (STATE/HISTORY);
+   override from PROPOSAL assumptions when present.
+
+The project is live; the loop continues through `/support` and change requests.

package/template/.claude/commands/support.md

@@ -0,0 +1,43 @@
+---
+description: After-go-live support triage — severity, warranty vs billable CR, hotfix via /quick or route to /change-request. Use for bugs and issues in hypercare / warranty.
+argument-hint: [symptom or ticket summary · "dry-run"]
+---
+
+Caveman ULTRA mode. You are the ORCHESTRATOR.
+
+Purpose: handle production / post-release issues like a small software house —
+triage first, then fix under warranty or open a billable CR. Issue: $ARGUMENTS
+
+DRY-RUN: if `$ARGUMENTS` contains `dry-run`/`--dry-run`, print the triage plan and
+STOP. Log and fix nothing.
+
+Apply the `support-triage` skill.
+
+## PRE-FLIGHT
+Read `docs/PROPOSAL.md` (warranty / support assumptions if any), `docs/STATE.md`,
+`docs/ISSUES.md`, `docs/RUNBOOK.md` (if present), and recent HISTORY release lines.
+No live release yet → say so; may still log the issue for pre-prod.
+
+## STEP 1 — TRIAGE
+Brief-back (rule 14) then classify:
+
+| Field | Values |
+|-------|--------|
+| Severity | **P1** (down / data loss / security) · **P2** (major feature broken, workaround) · **P3** (minor / cosmetic) |
+| Type | defect vs approved scope · clarification · **new scope** |
+| Commercial | **warranty** (in support window, defect) · **billable** (out of window or new scope) · **unclear** (ask) |
+
+Default warranty window if unset in PROPOSAL/OVERVIEW: **30 days** after production
+promote (`released` HISTORY line). Ask once if the human wants a different window.
+
+## STEP 2 — ROUTE
+- **Warranty defect** → `/log-issue` (severity in title/symptom) → fix with `/quick`
+  (or `/phase` / `/feature` if phase-worthy — do not dodge TDD via quick for large
+  work, rule 10). P1: prioritize; note runbook updates via `/runbook` if ops-related.
+- **Billable / new scope** → `/change-request` (do not silently build free work).
+- **Unclear** → STOP and ask warranty vs billable before coding.
+
+## STEP 3 — CLOSE THE LOOP
+- Confirm ISSUES entry + HISTORY note `support P<n>: <title> → <route>`.
+- If fixed under warranty: mark issue resolved; no PROPOSAL bump.
+- Reminder: release STAGE 8 hypercare keeps ISSUES live; `/support` is the front door.

package/template/.claude/istartsoft-flow/METHODOLOGY.md

@@ -1,16 +1,20 @@
 # iStartSoftFlow — portable agent methodology (single source of truth)
 
-> **The iStartSoft execution loop.** Namespaced under `.claude/istartsoft-flow/`
-> so it coexists with a repo's own agent-instruction files (`CLAUDE.md`,
-> `AGENTS.md`, `GEMINI.md`, …) — it does NOT replace them. The kit is
-> **stack-agnostic and tool-agnostic**: it pins a *process*, not a *stack*.
-> Declare your stack (language, framework, infra, auth, test + E2E runner,
-> planning source) once in `docs/OVERVIEW.md`; every rule below references *your
-> declared stack* and hardcodes none. If infra is **managed** (a PaaS + a managed
-> datastore), Phase 0 (infra) is N/A and phases begin at the first vertical slice;
-> otherwise Phase 0 provisions infra first. Planning source of truth stays in your
-> PRD / architecture / stories (e.g. BMAD / iSSM); iStartSoftFlow is the execution
-> loop layered on top.
+> **The iStartSoft execution loop.** Lives under `.claude/istartsoft-flow/` as
+> part of the **portable kit**. The directory name `.claude/` is a **host
+> convention** (several agents load commands/hooks from that path) — not
+> Claude-only branding. Primary human entry is root **`AGENTS.md`** (open
+> standard). `CLAUDE.md` / `GEMINI.md` / … are thin host adapters that point
+> here; they do NOT replace this file.
+>
+> The kit is **stack-agnostic and tool-agnostic**: it pins a *process*, not a
+> *stack*. Declare your stack (language, framework, infra, auth, test + E2E
+> runner, planning source) once in `docs/OVERVIEW.md`; every rule below
+> references *your declared stack* and hardcodes none. If infra is **managed**
+> (a PaaS + a managed datastore), Phase 0 (infra) is N/A and phases begin at the
+> first vertical slice; otherwise Phase 0 provisions infra first. Planning source
+> of truth stays in your PRD / architecture / stories (e.g. BMAD / iSSM);
+> iStartSoftFlow is the execution loop layered on top.
 
 <!-- ISTARTSOFTFLOW-AGENTS-SENTINEL-v2.0 -->
 > **SENTINEL.** The HTML comment above (`ISTARTSOFTFLOW-AGENTS-SENTINEL-v2.0`) is a
@@ -23,10 +27,11 @@
 > open `AGENTS.md` standard, get the full methodology from here.
 
 > **Anti-drift invariant (load-bearing).** Every rule lives in exactly ONE place:
-> this file. `CLAUDE.md` restates NO rule — it only maps roles to Claude-native
-> files and says "native mechanism X performs ritual Y automatically." A rule and
-> its automation may never contradict. Duplication between files is an
-> architectural defect, not a convenience.
+> this file. Host entry files (`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, …) restate
+> NO rule — they only index this file and wire host-native mechanisms
+> ("mechanism X performs ritual Y automatically"). A rule and its automation may
+> never contradict. Duplication between files is an architectural defect, not a
+> convenience.
 
 Caveman ULTRA mode always on. Apply the `karpathy-guidelines` skill (engineering
 discipline) on every coding and debugging task. Apply the `ux-design` skill (the UX
@@ -106,34 +111,55 @@ from idea to closeout:
 5. **Proposal & estimate (OPTIONAL — depends on the job)** — for client / quoted
    work, `/propose` reads OVERVIEW + PLAN → `docs/PROPOSAL.md` + a rendered
    `docs/proposal.html`: scope, phase breakdown, effort + cost estimate, timeline,
-   assumptions, with a **client sign-off gate** before build. Internal / personal
-   projects skip straight from plan to build.
-6. **Build** — the loop, one phase at a time (`/phase`, AUTO dev loop). Each phase's
+   assumptions, with a **client sign-off gate** before build. **Ask rate +
+   contingency in chat** when missing — the kit stores **no** default rate (rates
+   are confidential). Client docs show **totals only** (never rate or contingency %).
+   Internal / personal projects skip straight from plan to build (and may set
+   design/architecture gates to `n/a`).
+6. **Design + architecture gates (rule 15 — after proposal, before build)** —
+   `/design` produces `docs/UX-PACK.md` + `docs/ARCHITECTURE.md` and stops for
+   human approve. Vertical slices still implement UI+code together; these gates
+   lock the *frame* first (software-house shape without abandoning slices).
+7. **Build** — the loop, one phase at a time (`/phase`, AUTO dev loop). Each phase's
    tests (unit + integration + e2e) are automated and MUST pass before the next phase.
    Optionally wrap the phases in the **sprint layer** (`/sprint`): group them into
    capacity-bounded sprints, each shipping one demoable increment with planning →
    standups → review → retro. `/sprint run` drives this end-to-end (see Sprint layer).
-7. **Change mid-flight** — `/change-request`: impact analysis + re-estimate + a logged
-   change order (`docs/CHANGES.md`) + sign-off, then `/replan`. Scope and cost never
-   change silently.
-8. **Release** — `/release`: full regression (functional/integration/e2e) → auto
+8. **Change mid-flight** — `/change-request`: impact analysis + re-estimate + a logged
+   change order (`docs/CHANGES.md` + `docs/changes/CR-<n>.md`) + sign-off, then
+   `/replan`. Scope and cost never change silently. Client-facing CR = Δ cost + new
+   total only.
+9. **Release** — `/release`: full regression (functional/integration/e2e) → auto
    audits (UI / QA / security / code) → smoke → **manual UAT** (`/uat`, scenario sheet
    + captured results) → defect loop → **sign-off** (`docs/SIGNOFF-…`) → promote to
    production (a human-signed hard-stop).
-9. **Go-live & support** — after-go-live hypercare; new scope routes through
-   `/change-request`. The project is live; the loop continues.
-10. **Closeout** — `/synthesize` → a project summary: what was built, key decisions,
+10. **Go-live & support** — hypercare + `/support` triage (severity, warranty vs
+    billable CR, hotfix via `/quick`). New scope → `/change-request`.
+11. **Closeout** — `/synthesize` → a project summary: what was built, key decisions,
     every change order, and the final cost vs the original estimate.
 
 **Logging is continuous and total.** Every stage writes to a durable artifact:
-requirements (PRD / OVERVIEW), commercial (PROPOSAL / CHANGES), execution
-(PLAN / HISTORY), decisions (DESIGN_LOG), errors (ISSUES), research (research/).
-Nothing important lives only in chat — it is on disk, so the project can always be
-reconstructed and summarised.
+requirements (PRD / OVERVIEW), commercial (PROPOSAL / CHANGES), design
+(UX-PACK / ARCHITECTURE), execution (PLAN / HISTORY), decisions (DESIGN_LOG),
+errors (ISSUES), research (research/). Nothing important lives only in chat — it
+is on disk, so the project can always be reconstructed and summarised.
 
 **Approval gates are always interactive** (both modes): the **PLAN-APPROVAL** gate
-(rule 13), the proposal sign-off, and every change-order approval pause for the human.
-AUTO governs the *dev loop between* those gates, never the plan or the money decisions.
+(rule 13), the proposal sign-off, **DESIGN + ARCHITECTURE** (rule 15), and every
+change-order approval pause for the human. AUTO governs the *dev loop between*
+those gates, never the plan, the money, or the design/arch frame.
+
+### Software-house roles → kit map
+
+| House role | Kit surface |
+|------------|-------------|
+| BA / PM | `/overview` grill · `grill-me` · PLAN / PROPOSAL / CR gates |
+| UX / UI | `/design` (UX pack) · `ux-design` skill · `/ui-audit` · rule 9 CLOSE |
+| Architect | `/design` (ARCHITECTURE) · `researcher` DESIGN · `code-standards` · `/log-decision` |
+| Developer | `implementer` · `/phase` · `/feature` · `/quick` |
+| QA | `test-author` · `e2e-runner` · `/qa-audit` · `/uat` |
+| DevOps | final-phase deploy · `/release` promote |
+| Support | `/support` · `/log-issue` · `/runbook` · release hypercare |
 
 -----
 
@@ -280,12 +306,22 @@ Named procedures, each with a canonical body in `.claude/commands/<name>.md`.
 
 **Lane routing — which entry point for which job:**
 
+**Default paths** (most days — elevate these in HOW-TO / landing):
+
 | The job | Lane |
 |---------|------|
-| Brand-new project (no OVERVIEW yet) | `/overview` → `/phase` (optionally `/sprint`) |
+| Brand-new project (no OVERVIEW yet) | `/overview` → (`/propose` if quoted) → `/design` → `/phase` (optionally `/sprint`) |
 | New FEATURE on an existing product | `/feature` (scaffold the doc with `/feature new`) |
 | Small, obvious, non-phase change (a fix, a rename, a copy tweak) | `/quick` |
+
+**Advanced** (same kit — do not cut; use when the job needs them):
+
+| The job | Lane |
+|---------|------|
+| Client quote after plan approval | `/propose` (asks rate; client totals only) |
+| UX pack + architecture sign-off | `/design` (rule 15) |
 | Scope change to already-approved work | `/change-request` |
+| After-go-live bug / triage | `/support` |
 | An OUTCOME spanning several units ("clear the feature queue") | `/goal` (drives the lanes above) |
 | Whole-product quality sweep / pre-release | `/ui-audit` · `/qa-audit` · `/security-audit` · `/release` |
 
@@ -310,8 +346,14 @@ surface or need its own acceptance criteria? -> `/feature`. Otherwise `/quick`.
   holds state; its `Approved:` line arms headless passes.
 - **propose** — turn approved requirements + stack into `PROPOSAL.md` (scope, phase
   breakdown, effort + cost estimate, assumptions) with a client sign-off gate.
+  Asks rate/contingency in chat when missing; client artifacts are totals-only.
+- **design** — post-proposal UX pack + architecture note (`UX-PACK.md` /
+  `ARCHITECTURE.md`) with human approve (rule 15) before `/phase`.
 - **change-request** — a mid-project scope change: impact analysis + re-estimate +
-  a logged change order (`CHANGES.md`) + sign-off, then `replan`.
+  a logged change order (`CHANGES.md` + `docs/changes/CR-<n>.md`) + sign-off, then
+  `replan`. Client sees Δ cost + new total only.
+- **support** — after-go-live triage: severity P1–P3, warranty vs billable CR,
+  hotfix via `/quick` or route to `/change-request`.
 - **phase [n]** — run one phase end-to-end with the circuit breaker. Chooses the
   TDD or non-TDD order at RESEARCH. CLOSE runs the regression guard + ENDPOINTS
   coverage gate. When a sprint is active, CLOSE also fires a `/sprint standup` tick.
@@ -462,7 +504,7 @@ Mirrors the installer's `--dry-run`. (In a dry-run, even AUTO never acts — it
 
 -----
 
-## Hard rules (1–14)
+## Hard rules (1–15)
 
 1. Before debugging ANY error: grep `docs/ISSUES.md` AND `docs/research/INDEX.md`.
    The SESSION-OPEN ritual surfaces ISSUES.md — there is no excuse to miss it.
@@ -536,6 +578,14 @@ Mirrors the installer's `--dry-run`. (In a dry-run, even AUTO never acts — it
     change · `Approved:` goal → goal runs) — that is exactly what arms headless.
     Rationale: a wrong understanding burns tokens and context at 100× the cost
     of one confirm turn. AUTO governs execution AFTER intake, never instead of it.
+15. **DESIGN + ARCHITECTURE gates.** After a client proposal is signed (quoted
+    work), no `/phase` / `/sprint` build starts until `docs/UX-PACK.md` and
+    `docs/ARCHITECTURE.md` carry human approval, recorded as `design:` /
+    `architecture:` in `docs/STATE.md` plus HISTORY lines. Run `/design` to
+    author and stop for sign-off. Internal / non-quoted projects may set both to
+    `n/a`. A CR that reshapes UX or architecture reverts the affected gate to
+    `PENDING`. Client-facing commercial docs never include rate cards or
+    contingency percentages (ask rates in chat; totals only on the page).
 
 -----
 
@@ -571,14 +621,17 @@ the KB. The kit works normally without a KB.
 ## File contract
 
 - `docs/PRD.md` — crystallised product requirements (or your BMAD/iSSM stories).
-- `docs/PROPOSAL.md` — scope + phase breakdown + effort/cost estimate + assumptions
-  + sign-off. Versioned; the commercial baseline (source of truth).
+- `docs/PROPOSAL.md` — scope + phase breakdown + effort/cost totals + assumptions
+  + sign-off. Versioned; client-safe commercial baseline (no rate / contingency %).
 - `docs/proposal.html` — the client-facing proposal, rendered from PROPOSAL.md via
   `.claude/templates/proposal.html`, in the project language; print-ready (PDF).
-- `.claude/templates/` — client-facing document templates (proposal.html, …) the
-  commands render into `docs/`.
+- `docs/UX-PACK.md` · `docs/ARCHITECTURE.md` — pre-build design/arch frames
+  (rule 15); templates under `.claude/templates/`.
+- `.claude/templates/` — document templates (proposal.html, UX-PACK, ARCHITECTURE,
+  CR, FEATURE, …) the commands render into `docs/`.
 - `docs/CHANGES.md` — change-order log (append-only): each scope change with its
   impact, effort/cost delta, new total, and approval status. The commercial audit trail.
+- `docs/changes/CR-<n>.md` — detailed CR from `CR-template.md` (client-safe totals).
 - `docs/UAT-<date>.md` — UAT scenario sheet (all cases) + captured tester results
   (PASS/FAIL + notes). Drives the release defect loop.
 - `docs/SIGNOFF-<date>.md` — release sign-off: scope delivered, test/audit/UAT
@@ -601,7 +654,8 @@ the KB. The kit works normally without a KB.
   (Done-when · Budget · `Approved:` line · progress ticks). Maintained by `/goal`.
 - `.claude/templates/FEATURE-template.md` — the Feature-doc form `/feature new`
   scaffolds (Approval/Automation headers + spec sections).
-- `docs/STATE.md` — current position. Small. Rewritten, not appended.
+- `docs/STATE.md` — current position. Small. Rewritten, not appended. Includes
+  `plan:`, `design:`, `architecture:` gate pointers (approved · PENDING · n/a).
 - `docs/ISSUES.md` — error log. Deduped by synthesizer.
 - `docs/PLAN.md` — the phase plan (the product backlog). Carries an `> Approval:`
   header — `PENDING` until the rule-13 PLAN-APPROVAL gate stamps `approved <date> v<n>`;
@@ -645,19 +699,19 @@ the KB. The kit works normally without a KB.
 
 ## Capability matrix (which host gets what)
 
-The kit is single-source (`.claude/` + this file). `create-issflow --tool=<host>`
-writes the right adapter; unsupported features degrade to model-run rituals, never
-silently vanish. The portable assets (agents, commands, skills, methodology) are
-the same everywhere — only the *wiring* differs.
+Single-source kit: **`.claude/` tree** (portable) + **this file** (rules) + root
+**`AGENTS.md`** (open-standard entry). `create-issflow --tool=<host>` (omit =
+all) writes adapters; unsupported features degrade to model-run rituals, never
+silently vanish. Assets are the same everywhere — only the *wiring* differs.
 
 | Host | Entry file | Commands | Subagents | Lifecycle hooks | Shared KB |
 |------|-----------|----------|-----------|-----------------|-----------|
-| **Claude Code** (reference) | `CLAUDE.md` (`@AGENTS.md`) + `.claude/` | `.claude/commands/` | native | SessionStart · PreToolUse (context watchdog + rule-13 plan gate) · PreCompact · SubagentStop · Stop (feature gate) | yes |
+| **Any AGENTS.md host** | `AGENTS.md` | read as reference | model-run | model-run | yes |
 | **Codex CLI** | `AGENTS.md` (native) | `.claude/commands/` (read as prompts) | read as reference | model-run | yes |
 | **Cursor** | `.cursor/rules/` + `AGENTS.md` | `.cursor/commands/` | reads `.claude/agents/` | `.cursor/hooks.json` (sessionStart · subagentStop) | yes |
 | **Gemini CLI** | `GEMINI.md` + `AGENTS.md` | `.claude/commands/` (read as prompts) | read as reference | model-run | yes |
 | **Aider** | `.aider.conf.yml` → `AGENTS.md` | read as reference | model-run | model-run | yes |
-| **Any AGENTS.md host** | `AGENTS.md` | read as reference | model-run | model-run | yes |
+| **Claude Code** | `CLAUDE.md` (`@AGENTS.md`) + `.claude/` | `.claude/commands/` | native | SessionStart · PreToolUse (context watchdog + plan gate) · PreCompact · SubagentStop · Stop | yes |
 
 "model-run" = the host can't automate the ritual, so the model performs it by hand
 (SESSION-OPEN at the top of each session; the COMPRESS snapshot before a reset).

package/template/.claude/skills/support-triage/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: support-triage
+description: >
+  After-go-live issue triage for software-house support — severity P1–P3,
+  warranty vs billable CR, hotfix vs change-request routing. Use with /support,
+  production incidents, hypercare, client bug reports, or when classifying
+  whether a fix is free warranty work. Keywords: support, hypercare, warranty,
+  P1, severity, ticket, hotfix, aftercare, ซัพพอร์ต, รับประกัน.
+---
+
+# support-triage — post-release front door
+
+Caveman ULTRA mode. Triage before you code. Wrong commercial lane (free vs
+billable) is a process defect.
+
+## Severity
+
+| Level | Meaning | Response shape |
+|-------|---------|----------------|
+| **P1** | Service down, data loss, active security incident | Drop-everything; runbook; fix or mitigate now |
+| **P2** | Major feature broken; workaround exists | Same-day / next business day aim |
+| **P3** | Minor, cosmetic, nice-to-have | Queue; batch with other P3s |
+
+## Warranty vs billable
+
+- **Warranty:** defect against **approved** scope inside the support window
+  (default 30 days after prod `released` unless PROPOSAL/OVERVIEW says otherwise)
+  → log + `/quick` (or larger lane if needed) — **no** proposal bump.
+- **Billable:** new scope, enhancement, or outside window → `/change-request`.
+- **Unclear:** ask once; do not assume free work.
+
+## Routing checklist
+
+1. Reproduce / capture symptom (prefer client steps).
+2. Grep `docs/ISSUES.md` + runbook — known issue?
+3. Assign P1–P3 + warranty/billable.
+4. Route: support fix · CR · or escalate (infra / vendor).
+5. HISTORY line for the triage decision.
+
+Never put personal rate cards into public tickets or client emails from this skill.

package/template/.claude/skills/ux-design/SKILL.md

@@ -27,18 +27,23 @@ against the cookbook + wireframe and produces a UX CHECK verdict; nothing UI shi
 without it. New visual direction (a layout or look the wireframe doesn't cover) is
 confirmed with the user before building — design is where human taste matters.
 
+- **Authoring the UX pack** (`/design` → `docs/UX-PACK.md`) after proposal sign-off
+  and before `/phase` (hard rule 15) — produce the frame the build must stay inside.
 - Building a screen / page / component.
 - Reviewing a UI diff (the "ตรวจ" pass).
 - CLOSE gate of any frontend phase — the cookbook check MUST pass.
 
-This skill is the STANDARD + the inline GATE (one screen, at phase close). For a
-WHOLE-PRODUCT sweep against this same cookbook — periodic or before a release — run
-`/ui-audit` (same rubric, broader scope, a scored report).
+This skill is the STANDARD + the inline GATE (one screen, at phase close) **and**
+the authoring guide for the pre-build UX pack. For a WHOLE-PRODUCT sweep against
+this same cookbook — periodic or before a release — run `/ui-audit` (same rubric,
+broader scope, a scored report).
 
 Order: **wireframe first** (does the layout match the baseline frame?) ->
 **cookbook** (do the details obey the system?). Never invent layout the
 wireframe does not have. If the design truly needs a frame the wireframe lacks,
 STOP and update the wireframe baseline first (a design decision -> `log-decision`).
+When an approved `docs/UX-PACK.md` exists, treat it as the project frame — drift
+from the pack is a defect unless the pack is re-approved.
 
 -----
 

package/template/.claude/templates/ARCHITECTURE-template.md

@@ -0,0 +1,53 @@
+# Architecture — <project>
+
+> Approval: PENDING
+> (Stamp on sign-off: `approved <YYYY-MM-DD> v<n>` — hard rule 15)
+
+## Purpose
+Build-ready architecture note after commercial sign-off. Refines OVERVIEW stack
+into concrete boundaries the implementer follows per phase.
+
+## Context
+- OVERVIEW stack summary:
+- Constraints / non-goals:
+
+## Pattern
+- Declared architecture: Feature-Based (default) | layered | hexagonal | other:
+- Why this fits:
+
+## System diagram (text)
+```
+(clients) → (API / BFF) → (domain) → (data / external)
+```
+
+## Boundaries & modules
+| Module | Owns | Talks to |
+|--------|------|----------|
+| | | |
+
+## Data
+- Stores / schemas (high level):
+- Migrations approach:
+
+## Auth & trust boundaries
+- Authn / authz:
+- Secrets:
+- Threat notes (STRIDE if security-touching):
+
+## Integrations
+| Service | Use | Failure mode |
+|---------|-----|--------------|
+| | | |
+
+## Quality & ops
+- Test + E2E runners (from OVERVIEW):
+- Deploy target:
+- Observability / runbook hooks:
+
+## Decisions open
+-
+
+## Sign-off
+- Approved by: ___
+- Date: ___
+- Version: v1

package/template/.claude/templates/CR-template.md

@@ -0,0 +1,34 @@
+# CR-<n> — <short title>
+
+> Status: proposed | approved | rejected
+> Date: <YYYY-MM-DD>
+> Baseline: PROPOSAL v<n> | FEATURE `<slug>`
+
+## Classification
+- [ ] Clarification (no cost change)
+- [ ] Billable scope change (add / remove / alter)
+- [ ] Warranty defect (prefer `/support` / `/quick` — not billable unless scope expands)
+
+## Request
+<what the client / stakeholder asked>
+
+## Impact
+- Phases affected (done phases frozen):
+- UX pack impact: none | amend → re-approve (rule 15)
+- Architecture impact: none | amend → re-approve (rule 15)
+- Security re-threat-model?: no | yes
+- Timeline Δ:
+
+## Commercial (client-safe)
+| | |
+|--|--|
+| Effort Δ | <± range> |
+| Cost Δ | <± amount · currency> |
+| New total | <amount> |
+
+**Do not** put rate, rate card, or contingency % in this file if it is shared with
+the client. Show math with rates only in private chat / private estimate memo.
+
+## Decision
+- Approved by: ___ · Date: ___
+- Or rejected because:

package/template/.claude/templates/UX-PACK-template.md

@@ -0,0 +1,37 @@
+# UX pack — <project>
+
+> Approval: PENDING
+> (Stamp on sign-off: `approved <YYYY-MM-DD> v<n>` — hard rule 15)
+
+## Purpose
+Hi-fi-enough UI direction for build: screens, flows, and frame the implementer
+must stay inside. Wireframe baseline first; visual direction confirmed here.
+
+## Users & jobs
+-
+
+## Key flows
+1.
+2.
+
+## Screen inventory
+| Screen | Job | Priority |
+|--------|-----|----------|
+| | | |
+
+## Frame & tokens
+- Wireframe baseline: (link or summary)
+- Brand / tokens: (or “follow OVERVIEW UX direction”)
+- Breakpoints: XS · SM · MD · LG · XL
+
+## States & a11y notes
+- Empty / loading / error covered for each primary view
+- WCAG 2.1 AA targets
+
+## Out of scope (design)
+-
+
+## Sign-off
+- Approved by: ___
+- Date: ___
+- Version: v1

package/template/.claude/templates/proposal.html

@@ -91,7 +91,8 @@
 
   <div class="total">
     <span><span class="lbl" style="margin:0">ราคารวม <em>Total</em></span><br><span class="muted" style="font-size:9px">{{TIMELINE}}</span></span>
-    <span class="amt">{{TOTAL_COST}} <small>{{CONTINGENCY_NOTE}}</small></span>
+    <!-- CLIENT-SAFE: totals only. Never put rate, rate card, or contingency % in {{TOTAL_NOTE}}. Leave empty or a non-rate label (e.g. currency). -->
+    <span class="amt">{{TOTAL_COST}} <small>{{TOTAL_NOTE}}</small></span>
   </div>
 
   <div class="cols">