thachvd-kit 1.0.27 → 1.0.29

package/.agent/docs/getting-started.md

@@ -2,17 +2,30 @@
 
 Read this after `thachvd-kit init`. The kit gives every member one entry point, then selects only the process and expertise the task needs.
 
-## Start Every Task With /task
+## Forge Command Map
 
-Use `/task <request>` before editing whenever the route is not already obvious. It must produce:
+| Client | Task | Fast | Debug | Research | Review | Release |
+|---|---|---|---|---|---|---|
+| Codex | `$forge-task` | `$forge-fast` | `$forge-debug` | `$forge-research` | `$forge-review` | `$forge-release` |
+| Antigravity | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+| Claude Code | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+| Cursor | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+
+Forge commands accept free-form text after the command and continue the selected workflow in the same turn. Plain questions remain normal chat; edit requests without a command are implicitly routed as `forge-task`.
+
+Codex Forge skills live in `~/.codex/skills/forge-*/SKILL.md`. Antigravity Forge workflows live in `.agent/workflows/forge-*.md`. Claude Code Forge commands live in `.claude/commands/forge-*.md`. Cursor Forge commands live in `.cursor/commands/forge-*.md`.
+
+## Start Every Task With Forge
+
+Use the matching Forge command before editing whenever the request is not a simple question. `forge-task` must route internally and continue; it must not stop by asking the member to type a second command.
 
 ```text
-ROUTE: question | simple | feature | bug | review | release | multi-domain
+ROUTE: question | fast | feature | bug | research | review | release | multi-domain
 WORKFLOW: [exact .agent/workflows/<name>.md file]
 SKILLS: [matching skills, or none]
 AGENTS: [matching specialist agents, or none]
-GATE: fast-path | standard
-NEXT: [the next command or action]
+GATE: fast-path | standard | human-approval
+ACTION: [what the agent is doing next in this turn]
 ```
 
 A workflow is the process and its gates. A skill is the method or checklist. An agent is the specialist role. Chat alone is not a route: the member must select the route and invoke the matching workflow or explicitly choose the question path.
@@ -22,22 +35,23 @@ A workflow is the process and its gates. A skill is the method or checklist. An
 | Situation | Command | Gate | Required next step |
 |---|---|---|---|
 | Explain, inspect, or brainstorm only | direct answer or `/brainstorm` | none | no code until the request becomes actionable |
-| One obvious local fix | `/simple <request>` | fast-path | inspect -> edit -> focused verify |
-| New behavior, multi-file change, unclear scope, or >~30 min | `/task` -> `/brainstorm` -> `/spec` when needed -> `/plan` | standard | wait for approval before implementation |
-| Bug, regression, failing test, or unknown error | `/debug <symptom>` | bug | reproduce -> isolate -> regression test -> fix -> verify |
-| Pre-merge or independent review | `/review` | review | five-axis review; resolve blocking findings |
-| Version, tag, npm publish, or deployment | `/release` | release | release checklist; never fast-path |
+| One obvious local fix | `/forge-fast <request>` | fast-path | inspect -> edit -> focused verify |
+| New behavior, multi-file change, unclear scope, or >~30 min | `/forge-task <request>` | standard | route -> research/spec/plan -> approval when required -> continue |
+| Bug, regression, failing test, or unknown error | `/forge-debug <symptom>` | bug | reproduce -> isolate -> regression test -> fix -> verify |
+| Research request | `/forge-research <question>` | research | evidence report, no edits |
+| Pre-merge or independent review | `/forge-review` | review | five-axis review; resolve blocking findings |
+| Version, tag, npm publish, or deployment | `/forge-release` | release | release checklist; never fast-path |
 | Frontend + backend + data/security together | `/orchestrate` | standard | plan -> approval -> specialist work -> integration verify |
 
 ## Standard Feature Flow
 
-The gated sequence is Spec -> Plan -> Implement -> Review: `/task` -> `/brainstorm` -> `/spec` when scope is ambiguous or multi-file -> `/plan` -> user approves the plan -> implementation -> `/test` -> `/review` -> final verification -> commit/push.
+The gated sequence is Spec -> Plan -> Implement -> Review. `/forge-task` manages this sequence internally and pauses only at the explicit user approval gate before implementation.
 
 The plan is a gate, not a suggestion. Do not start product-code implementation before explicit approval. Load only the relevant specialist agent and skills, such as `$frontend-design`, `$api-design`, or `$webapp-testing`.
 
 ## Bug Fix Flow
 
-Use `/debug <symptom>`, not the feature flow, when something is failing or the root cause is unknown:
+Use `/forge-debug <symptom>`, not the feature flow, when something is failing or the root cause is unknown:
 
 1. Capture the exact symptom, environment, reproduction, and expected result.
 2. Inspect the relevant code path with MCP/codegraph when available.
@@ -51,7 +65,7 @@ Load `$systematic-debugging`, the `debugger` agent, and `testing-patterns` for t
 
 ## Simple Fast Path
 
-Use `/simple <request>` only when the change is one obvious file, the result is unambiguous, and it changes no behavior, API, schema, security, CI, dependency, workflow, or release contract. Before editing, state:
+Use `/forge-fast <request>` only when the change is one obvious file, the result is unambiguous, and it changes no behavior, API, schema, security, CI, dependency, workflow, or release contract. Before editing, state:
 
 ```text
 FAST_PATH: simple-fix
@@ -59,18 +73,18 @@ REASON: [why Spec/Plan/Review are not needed]
 SCOPE: [file or narrow area]
 ```
 
-This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection, focused verification, or reporting evidence. If the scope expands, stop and re-route with `/task`.
+This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection, focused verification, or reporting evidence. If the scope expands, stop and re-route internally through `forge-task`.
 
 ## Command And Skill Map
 
 - `/brainstorm`: clarify intent and tradeoffs; no code.
-- `/spec`: define requirements and acceptance criteria; no code.
+- `forge-research`: evidence-based codebase/technical/domain research; no product-code edits.
 - `/plan`: create an approved implementation plan; no code before approval.
 - `/enhance` or `/create`: implement an approved feature with the relevant specialist agent.
-- `/debug`: systematic root-cause investigation and regression protection.
+- `forge-debug`: systematic root-cause investigation and regression protection.
 - `/test`: add or run tests and assess coverage.
 - `/review`: five-axis review before completion or merge.
-- `/release`: verify, version, tag, publish, and verify npm output.
+- `forge-release`: verify, version, tag, publish, and verify npm output.
 - `$clean-code` and `$verification-before-completion`: default implementation hygiene.
 - `$webapp-testing`: browser/UI verification; use Playwright when available.
 

package/.agent/docs/workflow.md

@@ -4,7 +4,7 @@
 
 1. Read AGENTS.md.
 2. Read .agent/docs/project.md.
-3. Route the request with `/task <request>` when the path is not obvious.
+3. Use `/forge-task <request>` (or `$forge-task <request>` in Codex) when the request changes code and the path is not obvious.
 4. Read only the relevant docs under .agent/agents, .agent/skills, .claude/skills, and .agent/workflows.
 5. Check if MCP servers (like `codegraph`) are active/available and prioritize using them as the primary entry point to search and locate files, symbols, and code blocks.
 
@@ -13,11 +13,12 @@
 | Situation | Command | Workflow / gate |
 |---|---|---|
 | Question or analysis only | direct answer | no edits |
-| One obvious local fix | `/simple` | `.agent/workflows/simple.md`, fast-path |
-| Bug, regression, failing test, or unknown error | `/debug` | `.agent/workflows/debug.md`, evidence-first |
-| New behavior, multi-file change, or unclear scope | `/brainstorm` -> `/spec` when needed -> `/plan` | spec/plan approval -> implement -> review |
-| Pre-merge review | `/review` | `.agent/workflows/review.md`, five-axis |
-| npm version, tag, publish, or deployment | `/release` | `.agent/workflows/release.md`, release gate |
+| One obvious local fix | `/forge-fast` | `.agent/workflows/simple.md`, fast-path |
+| Bug, regression, failing test, or unknown error | `/forge-debug` | `.agent/workflows/debug.md`, evidence-first |
+| Research request | `/forge-research` | evidence report, no edits |
+| New behavior, multi-file change, or unclear scope | `/forge-task` | research/spec/plan approval -> implement -> review |
+| Pre-merge review | `/forge-review` | `.agent/workflows/review.md`, five-axis |
+| npm version, tag, publish, or deployment | `/forge-release` | `.agent/workflows/release.md`, release gate |
 | Several specialist domains | `/orchestrate` | plan -> approval -> parallel work -> integration verify |
 
 If a task is not clearly simple, use the standard flow. Never use the fast path for behavior, API, schema, security, CI, dependency, workflow, or release changes.
@@ -35,7 +36,7 @@ If a task is not clearly simple, use the standard flow. Never use the fast path
 
 ## Implementation Flow
 
-For `/simple` fixes, state the fast-path decision before editing:
+For `/forge-fast` fixes, state the fast-path decision before editing:
 
 ```text
 FAST_PATH: simple-fix
@@ -52,7 +53,7 @@ Then:
 5. Run verification (prioritize using Playwright MCP for web/UI changes to automate verification and capture screenshots).
 6. Summarize changed files and verification evidence.
 
-For bugs, use `/debug` with `$systematic-debugging`, the `debugger` agent, and `testing-patterns`: reproduce, isolate the root cause, add regression protection, make the smallest fix, and verify.
+For bugs, use `/forge-debug` with `$systematic-debugging`, the `debugger` agent, and `testing-patterns`: reproduce, isolate the root cause, add regression protection, make the smallest fix, and verify.
 
 For features or refactors, this flow runs *inside* the gated flow defined in AGENTS.md (spec -> plan -> implement -> review) — steps 3-5 above are the "Implement" phase, and step 6 is not a substitute for the mandatory `.agent/workflows/review.md` gate.
 
@@ -60,7 +61,7 @@ For features or refactors, this flow runs *inside* the gated flow defined in AGE
 
 A feature/refactor task is only complete when all of the following hold — not when code compiles or tests pass:
 
-The Spec checkbox may be skipped only when the documented `/simple` fast-path protocol is stated and its criteria are met.
+The Spec checkbox may be skipped only when the documented `/forge-fast` protocol is stated and its criteria are met.
 
 - [ ] `.agent/workflows/spec.md` exit criteria met (or explicitly skipped as a trivial/self-contained change)
 - [ ] `.agent/workflows/plan.md` produced a plan file, approved by the user

package/.agent/rules/GEMINI.md

@@ -29,19 +29,21 @@ Load only the agent, skill, or workflow files relevant to the current task.
 
 ## Execution
 
-- Route every task before editing. Use `/task <request>` when the correct path is not obvious.
+- Route every task before editing. Use `/forge-task <request>` when the correct path is not obvious.
+- Forge workflows are available as `/forge-task`, `/forge-fast`, `/forge-debug`, `/forge-research`, `/forge-review`, and `/forge-release`.
 - Questions and analysis: answer directly; do not edit code.
-- Simple fix: use `/simple <request>` only for one-file, unambiguous changes with no behavior or contract change.
-- Bug or failing behavior: use `/debug <symptom>` and follow the evidence-first root-cause flow.
-- Feature or refactor: use `/brainstorm` for discovery, `/spec` for ambiguous or multi-file scope, then `/plan`, wait for approval, implement, test, and `/review`.
-- Pre-merge review: use `/review`.
-- Release or npm publish: use `/release`; never use the simple fast path.
+- Simple fix: use `/forge-fast <request>` only for one-file, unambiguous changes with no behavior or contract change.
+- Bug or failing behavior: use `/forge-debug <symptom>` and follow the evidence-first root-cause flow.
+- Research: use `/forge-research <question>` for evidence-based research without product-code edits.
+- Feature or refactor: use `/forge-task <request>`; it handles research, spec, plan, approval, implementation, test, and review in sequence.
+- Pre-merge review: use `/forge-review`.
+- Release or npm publish: use `/forge-release`; never use the simple fast path.
 - UI work: use relevant frontend design skills before editing.
 - Security or deploy work: run the matching checklist before claiming done.
 
-### Fast Path (`/simple`)
+### Fast Path (`/forge-fast`)
 
-The fast path bypasses only Spec, Plan, and the feature/refactor Review gate for a trivial change. It never bypasses inspection or verification. State `FAST_PATH: simple-fix`, the reason, and the narrow scope before editing. Re-route with `/task` if the scope expands.
+The fast path bypasses only Spec, Plan, and the feature/refactor Review gate for a trivial change. It never bypasses inspection or verification. State `FAST_PATH: simple-fix`, the reason, and the narrow scope before editing. Re-route with `/forge-task` if the scope expands.
 
 ### Gated Flow (feature or refactor)
 

package/.agent/workflows/forge-debug.md

@@ -0,0 +1,12 @@
+---
+description: Investigate and fix a bug with evidence-first root-cause analysis.
+argument-hint: [SYMPTOM]
+---
+
+# Forge Debug
+
+Symptom:
+
+$ARGUMENTS
+
+Read `.agent/workflows/debug.md`, use `$systematic-debugging`, the `debugger` agent, and `testing-patterns` when available. Reproduce the symptom, inspect the relevant code path with codegraph/MCP, form and test hypotheses, identify the root cause, add regression protection when practical, make the smallest fix, and verify it. Do not patch by guesswork and do not stop by asking the member to invoke another command.

package/.agent/workflows/forge-fast.md

@@ -0,0 +1,22 @@
+---
+description: Execute a trivial, unambiguous change with focused verification.
+argument-hint: [REQUEST]
+---
+
+# Forge Fast Path
+
+Request:
+
+$ARGUMENTS
+
+Use this path only for one obvious file or tiny local change with no behavior, API, schema, security, CI, dependency, workflow, or release contract change.
+
+Before editing, state exactly:
+
+```text
+FAST_PATH: simple-fix
+REASON: [why Spec, Plan, and feature Review are not needed]
+SCOPE: [file or narrow area]
+```
+
+Inspect the target, make the smallest change, run focused verification, and report evidence. If the scope expands, stop and internally re-route through the appropriate Forge workflow. Never skip inspection or verification.

package/.agent/workflows/forge-release.md

@@ -0,0 +1,12 @@
+---
+description: Verify, version, publish, and verify the thachvd-kit npm release.
+argument-hint: [RELEASE_REQUEST]
+---
+
+# Forge Release
+
+Release request:
+
+$ARGUMENTS
+
+Read `.agent/workflows/release.md` and run the release gate. Confirm the working tree, review status, version, npm authentication, verification output, and package contents before publishing. Never use the fast path. Do not run `npm publish` until the release gate is satisfied and the human has confirmed the final version and publish action. After publishing, verify the registry version and the installed package output.

package/.agent/workflows/forge-research.md

@@ -0,0 +1,24 @@
+---
+description: Research the codebase, technical topic, or domain without editing product code.
+argument-hint: [QUESTION]
+---
+
+# Forge Research
+
+Research question:
+
+$ARGUMENTS
+
+Do not edit product code. First classify the research as codebase, external technical, or domain research. For codebase research, use codegraph/MCP first. For external research, use authoritative current sources only when needed and cite them. Return exactly:
+
+```text
+RESEARCH_STATUS: complete | blocked
+QUESTION: [what was investigated]
+ASSUMPTIONS: [explicit assumptions]
+FINDINGS: [evidence-based findings]
+SOURCES: [file paths, symbols, MCP evidence, or URLs]
+RISKS: [known risks and unknowns]
+OPTIONS: [possible approaches and tradeoffs]
+RECOMMENDATION: [recommended direction]
+OPEN_QUESTIONS: [unresolved questions]
+```

package/.agent/workflows/forge-review.md

@@ -0,0 +1,12 @@
+---
+description: Review a change across correctness, simplicity, architecture, security, and performance.
+argument-hint: [SCOPE]
+---
+
+# Forge Review
+
+Review scope:
+
+$ARGUMENTS
+
+Read `.agent/workflows/review.md` and inspect the relevant diff, task, and verification evidence. Review all five axes. Report findings first, ordered by severity, using `BLOCKING`, `SUGGESTION`, `NIT`, or `QUESTION`. Do not edit code during review unless the member explicitly asks for fixes after the findings.

package/.agent/workflows/forge-task.md

@@ -0,0 +1,37 @@
+---
+description: Route a request and continue the selected Forge workflow in this turn.
+argument-hint: [REQUEST]
+---
+
+# Forge Task Orchestrator
+
+The request supplied with this command is:
+
+$ARGUMENTS
+
+Read `AGENTS.md`, `.agent/docs/project.md`, and `.agent/docs/workflow.md` before editing.
+
+Classify the request internally as `question`, `fast`, `feature`, `bug`, `research`, `review`, `release`, or `multi-domain`. Then continue the selected workflow in this same turn. Do not stop after printing a `NEXT` command and do not ask the member to invoke another Forge command for ordinary routing.
+
+Use this compact status header when useful:
+
+```text
+REQUEST: [original request]
+ROUTE: [route]
+WORKFLOW: [exact workflow file]
+SKILLS: [matching skills]
+AGENTS: [matching agents]
+GATE: fast-path | standard | human-approval
+ACTION: [what you are doing now]
+```
+
+Rules:
+
+- Questions and analysis: answer directly with no edits.
+- Trivial one-file changes: apply the `forge-fast` protocol, including focused verification.
+- Bugs or unknown failures: reproduce, isolate root cause, add regression protection, fix, and verify.
+- Research: use codegraph/MCP first for repository questions, use authoritative external sources when needed, and do not edit code.
+- Features and refactors: follow spec -> plan -> approval -> implement -> test -> review. Stop only at the documented human approval gate.
+- Reviews: run the five-axis review and report findings first.
+- Releases: follow `.agent/workflows/release.md`; never use the fast path.
+- If the request is empty or unsafe to classify, ask one concise clarification question.

package/.agent/workflows/simple.md

@@ -6,6 +6,8 @@ description: Fast path for one-file, unambiguous fixes with no behavior or share
 
 $ARGUMENTS
 
+Codex UI command: `/prompts:simple`. The `/simple` name below describes the workflow; it is not a built-in Codex slash command.
+
 ## Use Only When
 
 - The change is limited to one obvious file or one tiny local edit.

package/.agent/workflows/task.md

@@ -6,6 +6,8 @@ description: Route every task to the smallest safe workflow, fast path, bug flow
 
 $ARGUMENTS
 
+Codex UI command: `/prompts:task`. The `/task` name below describes the workflow; it is not a built-in Codex slash command.
+
 ## Purpose
 
 Use `/task` at the start of a task when you are unsure which workflow, skill, or specialist agent applies. This command routes the request before implementation.

package/README.md

@@ -60,37 +60,49 @@ Skills work best through progressive disclosure: the agent should first see skil
 - Keep `.agent/skills` as the complete shared source from the kit.
 - Let `thachvd-kit` copy selected skills to `~/.codex/skills/` for Codex and `.claude/skills` for Claude Code.
 - Make every `SKILL.md` frontmatter `description` specific: include when to use it, trigger phrases, and boundaries.
-- Run `thachvd-kit --help` to see a compact workflow guide without adding that guidance to every agent context. It recommends when to use `/task`, `/simple`, `/brainstorm`, `/plan`, `/create`, `/enhance`, `/debug`, `/test`, `/preview`, `/deploy`, `/review`, `/release`, `/status`, and `/orchestrate`.
+- Run `thachvd-kit --help` to see a compact workflow guide. Forge commands appear after `init` and a client restart.
 - Use explicit prompts when implicit matching misses, for example `Use $webapp-testing to verify this UI` or `Use $clean-code before refactoring`.
 - Restart Codex or Claude Code if a newly copied or edited skill does not appear.
 
 ## Development Workflow
 
-After install, every AI client starts at `/task <request>` when the route is not already obvious. `/task` selects the smallest safe workflow and the relevant skills/agents; it does not force the full feature gate onto every request.
+After install, Forge is the member-facing command suite. It accepts free-form text after the command, routes the request, and continues the selected workflow in the same turn. Questions remain normal chat; edit requests without a command are implicitly routed as `forge-task`.
+
+### Client Commands
+
+| Client | Task | Fast path | Bug flow | Research | Review | Release |
+|---|---|---|---|---|---|
+| Codex | `$forge-task` | `$forge-fast` | `$forge-debug` | `$forge-research` | `$forge-review` | `$forge-release` |
+| Antigravity | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+| Claude Code | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+| Cursor | `/forge-task` | `/forge-fast` | `/forge-debug` | `/forge-research` | `/forge-review` | `/forge-release` |
+
+`init` installs these from `commands/`: Codex skills in `~/.codex/skills/forge-*`, Antigravity workflows in `.agent/workflows/forge-*`, Claude Code commands in `.claude/commands/forge-*`, and Cursor commands in `.cursor/commands/forge-*`. Restart or reload the client after installation.
 
 | Situation | Command | Required flow |
 |---|---|---|
 | Question or analysis | direct answer | no edits |
-| One obvious local fix | `/simple <request>` | inspect → edit → focused verify |
-| Bug or failing behavior | `/debug <symptom>` | reproduce → root cause → regression test → fix → verify |
-| New behavior or refactor | `/task` → `/brainstorm` → `/spec` when needed → `/plan` | approval → implement → test → `/review` |
-| Pre-merge review | `/review` | five-axis review; resolve blocking findings |
-| npm version/tag/publish | `/release` | release verification; never fast path |
+| One obvious local fix | `/forge-fast <request>` | inspect → edit → focused verify |
+| Bug or failing behavior | `/forge-debug <symptom>` | reproduce → root cause → regression test → fix → verify |
+| Research request | `/forge-research <question>` | evidence report; no product-code edits |
+| New behavior or refactor | `/forge-task <request>` | route → research/spec/plan → approval when required → implement → test → review |
+| Pre-merge review | `/forge-review` | five-axis review; resolve blocking findings |
+| npm version/tag/publish | `/forge-release` | release verification; never fast path |
 | Several specialist domains | `/orchestrate` | plan → approval → parallel work → integration verify |
 
 ### Standard Feature Flow
 
-`/task` → `/brainstorm` when needed → `/spec` for ambiguous or multi-file scope → `/plan` → explicit user approval → implementation → `/test` → `/review` → final verification → commit/push.
+`/forge-task` manages Spec → Plan → Implement → Review internally and pauses only at the explicit user approval gate before implementation. It does not stop by printing a command for the member to run next.
 
 Workflow files define process and gates. Skills define methods/checklists. Agents provide specialist ownership. Members should invoke the command, not only describe the work in chat.
 
 ### Bug Fix Flow
 
-Use `/debug` for regressions, failing tests, exceptions, incorrect output, or any symptom with an unknown root cause. Load `$systematic-debugging`, the `debugger` agent, and `testing-patterns`; reproduce the issue, inspect the code path, test hypotheses, add regression protection, make the smallest root-cause fix, and verify. Use `/review` when the change is cross-file or affects a shared contract.
+Use `/forge-debug` for regressions, failing tests, exceptions, incorrect output, or any symptom with an unknown root cause. Load `$systematic-debugging`, the `debugger` agent, and `testing-patterns`; reproduce the issue, inspect the code path, test hypotheses, add regression protection, make the smallest root-cause fix, and verify. Use `/forge-review` when the change is cross-file or affects a shared contract.
 
 ### Simple Fast Path
 
-Use `/simple` only for one obvious file, an unambiguous result, and no behavior, API, schema, security, CI, dependency, workflow, or release contract change. Before editing, state:
+Use `/forge-fast` only for one obvious file, an unambiguous result, and no behavior, API, schema, security, CI, dependency, workflow, or release contract change. Before editing, state:
 
 ```text
 FAST_PATH: simple-fix
@@ -98,7 +110,7 @@ REASON: [why Spec/Plan/Review are not needed]
 SCOPE: [file or narrow area]
 ```
 
-This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection or verification. If the scope expands, stop and run `/task` again.
+This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection or verification. If the scope expands, re-route internally through `forge-task`.
 
 Claude Code has a Stop hook that checks the standard feature/refactor gate. Codex, Antigravity, and Cursor use the same written routing rules through `AGENTS.md`, `.cursorrules`, and `.agent/rules/GEMINI.md`.
 

package/bin/cli.js

@@ -7,8 +7,9 @@ const prompts = require('prompts');
 const pc = require('picocolors');
 const packageJson = require('../package.json');
 
-const sourceDir = path.resolve(__dirname, '..');
-const targetDir = process.cwd();
+const sourceDir = path.resolve(__dirname, '..');
+const targetDir = process.cwd();
+const FORGE_COMMANDS = ['forge-task', 'forge-fast', 'forge-debug', 'forge-research', 'forge-review', 'forge-release'];
 
 // --- Skill Resolver ---
 
@@ -145,33 +146,34 @@ ${pc.bold('What gets generated:')}
   .claude/skills/   Selected Claude Code project skills copied from .agent/skills
 
 ${pc.bold('Workflow guide:')}
-  Every task               /task        Classify the request and select the workflow, skill, and agent
-  Small obvious fix        /simple      Fast path; skips spec/plan/review but still verifies
+  Every task               /forge-task     Route and continue the selected workflow in this turn
+  Small obvious fix        /forge-fast     Fast path; skips spec/plan/review but still verifies
   Idea is fuzzy            /brainstorm  Explore options, tradeoffs, and recommended direction
-  Scope needs a contract    /spec        Define requirements and acceptance criteria; no code yet
+  Research first           /forge-research Evidence-based research; no product-code edits
+  Scope needs a contract    /forge-task    Handles research, spec, plan approval, implementation, and review
   New app from scratch     /create      Turn an app idea into plan + implementation flow
   Feature is clear         /plan        Create docs/PLAN-*.md first, no code yet
   Existing app update      /enhance     Add or change a feature in an existing codebase
-  Bug or failing behavior  /debug       Investigate symptoms, hypotheses, root cause, fix
+  Bug or failing behavior  /forge-debug  Investigate symptoms, root cause, fix
   UI / UX work             ui-ux-pro-max, frontend-specialist, $frontend-design, $webapp-testing
   Run or add tests         /test        Generate tests, run tests, check coverage
   Preview locally          /preview     Start, stop, restart, or health-check dev server
   Deploy / infra           /deploy      Release, hosting, Docker, cloud, environment setup
-  Pre-merge review         /review      Run the five-axis review before calling work complete
-  Npm package release      /release     Verify, version, tag, publish, and verify the package
+  Pre-merge review         /forge-review Run the five-axis review before calling work complete
+  Npm package release      /forge-release Verify, version, tag, publish, and verify the package
   Project state            /status      Summarize stack, progress, preview, pending work
   Multi-domain work        /orchestrate Coordinate frontend, backend, data, security, QA
 
 ${pc.bold('Common explicit skill prompts:')}
-  Use /task to route this request before editing.
-  Use /simple for a one-file fix with no behavior or contract change.
+  Use /forge-task to route and continue a request in one turn.
+  Use /forge-fast for a one-file fix with no behavior or contract change.
   Use /brainstorm for this feature idea before planning.
-  Use /spec when requirements or scope need an explicit contract.
+  Use /forge-task when requirements or scope need an explicit contract.
   Use /plan for this feature; do not write code yet.
   Use /enhance to implement this planned feature.
-  Use /debug for this failing behavior and find the root cause before editing.
+  Use /forge-debug for this failing behavior and find the root cause before editing.
   Use /review before claiming this feature/refactor complete.
-  Use /release for npm versioning and publishing.
+  Use /forge-release for npm versioning and publishing.
   Use $clean-code before editing this module.
   Use $systematic-debugging to investigate this bug.
   Use $webapp-testing to verify the UI with Playwright.
@@ -919,18 +921,20 @@ If any \`.agent/docs/*.md\` file still contains \`TODO: refine\`, update the doc
 
 ## Task Flow
 
-Route every task before editing. Use \`/task <request>\` when the correct path is not obvious.
+Forge is the member-facing command suite. Use \`/forge-task <request>\` in Antigravity, Claude Code, or Cursor, and \`$forge-task <request>\` in Codex. The command classifies the request and continues the selected workflow in the same turn; it must not stop at a member-facing \`NEXT\` command.
 
-- Questions and analysis: answer directly, cite relevant files when useful, and do not edit code.
-- Simple fix: use \`/simple <request>\` only for one-file, unambiguous changes with no behavior or contract change.
-- Bug or failing behavior: use \`/debug <symptom>\` and follow the evidence-first root-cause flow.
-- Feature or refactor: use \`/brainstorm\` for discovery, \`/spec\` for ambiguous or multi-file scope, then \`/plan\`, wait for approval, implement, test, and \`/review\`.
-- Pre-merge review: use \`/review\` even when the implementation itself was done by another client or member.
-- Release or npm publish: use \`/release\`; release work never uses the simple fast path.
+- Questions and analysis without a command: answer directly and do not edit code.
+- Edit requests without a command: route internally as \`forge-task\` before editing.
+- Simple fix: use \`/forge-fast <request>\` only for one-file, unambiguous changes with no behavior or contract change.
+- Bug or failing behavior: use \`/forge-debug <symptom>\` and follow the evidence-first root-cause flow.
+- Research: use \`/forge-research <question>\`; research does not edit product code.
+- Feature or refactor: \`forge-task\` handles research/brainstorm, spec, plan approval, implementation, test, and review in sequence.
+- Pre-merge review: use \`/forge-review\` even when implementation was done by another client or member.
+- Release or npm publish: use \`/forge-release\`; release work never uses the fast path.
 - Multi-domain work: use \`.agent/workflows/orchestrate.md\` and route to the relevant specialist docs.
 - UI work: read \`.agent/agents/frontend-specialist.md\` and applicable design skills before editing.
 
-### Fast Path (\`/simple\`)
+### Fast Path (Forge \`forge-fast\`)
 
 The fast path intentionally bypasses only Spec, Plan, and the feature/refactor Review gate for a trivial change. It never bypasses inspection, focused verification, or reporting evidence. The agent must state this protocol before editing:
 
@@ -940,7 +944,7 @@ REASON: [why the change is one-file and unambiguous]
 SCOPE: [file or narrow area]
 \`\`\`
 
-If the scope expands, stop and re-route with \`/task\`. Do not silently skip gates for work that changes behavior, APIs, schemas, security, CI, dependencies, workflows, or release state.
+If the scope expands, stop and internally re-route through \`forge-task\`. Do not silently skip gates for work that changes behavior, APIs, schemas, security, CI, dependencies, workflows, or release state.
 
 ### Gated Flow (feature or refactor)
 
@@ -949,7 +953,7 @@ If the scope expands, stop and re-route with \`/task\`. Do not silently skip gat
 3. **Implement** — smallest coherent change per the approved plan, with focused tests for changed behavior.
 4. **Review** — run \`.agent/workflows/review.md\` (five-axis review) before the change is considered done. All 🔴 BLOCKING items must be resolved or explicitly accepted with rationale.
 
-A feature/refactor task is not "done" until step 4's exit criteria are met — passing tests alone does not satisfy the gate. Simple fixes use the explicit \`/simple\` fast path above. See \`.agent/docs/getting-started.md\` for the complete route guide.
+A feature/refactor task is not "done" until step 4's exit criteria are met — passing tests alone does not satisfy the gate. Simple fixes use the explicit \`forge-fast\` path above. See \`.agent/docs/getting-started.md\` for the complete route guide.
 
 ## Skill Loading
 
@@ -1183,9 +1187,9 @@ function generateWorkflowDoc() {
 
 ## Before Every Task
 
-1. Read AGENTS.md.
-2. Read .agent/docs/project.md.
-3. Route the request with \`/task <request>\` when the path is not obvious.
+1. Read AGENTS.md.
+2. Read .agent/docs/project.md.
+3. Use \`/forge-task <request>\` (or \`$forge-task <request>\` in Codex) when the request changes code and the path is not obvious.
 4. Read only the relevant docs under .agent/agents, .agent/skills, .claude/skills, and .agent/workflows.
 5. Check if MCP servers (like \`codegraph\`) are active/available and prioritize using them as the primary entry point to search and locate files, symbols, and code blocks.
 
@@ -1194,11 +1198,12 @@ function generateWorkflowDoc() {
 | Situation | Command | Workflow / gate |
 |---|---|---|
 | Question or analysis only | direct answer | no edits |
-| One obvious local fix | \`/simple\` | \`.agent/workflows/simple.md\`, fast-path |
-| Bug, regression, failing test, or unknown error | \`/debug\` | \`.agent/workflows/debug.md\`, evidence-first |
-| New behavior, multi-file change, or unclear scope | \`/brainstorm\` -> \`/spec\` when needed -> \`/plan\` | spec/plan approval -> implement -> review |
-| Pre-merge review | \`/review\` | \`.agent/workflows/review.md\`, five-axis |
-| npm version, tag, publish, or deployment | \`/release\` | \`.agent/workflows/release.md\`, release gate |
+| One obvious local fix | \`/forge-fast\` | \`.agent/workflows/simple.md\`, fast-path |
+| Bug, regression, failing test, or unknown error | \`/forge-debug\` | \`.agent/workflows/debug.md\`, evidence-first |
+| Research request | \`/forge-research\` | evidence report, no edits |
+| New behavior, multi-file change, or unclear scope | \`/forge-task\` | research/spec/plan approval -> implement -> review |
+| Pre-merge review | \`/forge-review\` | \`.agent/workflows/review.md\`, five-axis |
+| npm version, tag, publish, or deployment | \`/forge-release\` | \`.agent/workflows/release.md\`, release gate |
 | Several specialist domains | \`/orchestrate\` | plan -> approval -> parallel work -> integration verify |
 
 If a task is not clearly simple, use the standard flow. Never use the fast path for behavior, API, schema, security, CI, dependency, workflow, or release changes.
@@ -1216,7 +1221,7 @@ If a task is not clearly simple, use the standard flow. Never use the fast path
 
 ## Implementation Flow
 
-For \`/simple\` fixes, state the fast-path decision before editing:
+For \`/forge-fast\` fixes, state the fast-path decision before editing:
 
 \`\`\`text
 FAST_PATH: simple-fix
@@ -1233,7 +1238,7 @@ Then:
 5. Run verification (prioritize using Playwright MCP for web/UI changes to automate verification and capture screenshots).
 6. Summarize changed files and verification evidence.
 
-For bugs, use \`/debug\` with \`$systematic-debugging\`, the \`debugger\` agent, and \`testing-patterns\`: reproduce, isolate the root cause, add regression protection, make the smallest fix, and verify.
+For bugs, use \`/forge-debug\` with \`$systematic-debugging\`, the \`debugger\` agent, and \`testing-patterns\`: reproduce, isolate the root cause, add regression protection, make the smallest fix, and verify.
 
 For features or refactors, this flow runs *inside* the gated flow defined in AGENTS.md (spec -> plan -> implement -> review) — steps 3-5 above are the "Implement" phase, and step 6 is not a substitute for the mandatory \`.agent/workflows/review.md\` gate.
 
@@ -1241,7 +1246,7 @@ For features or refactors, this flow runs *inside* the gated flow defined in AGE
 
 A feature/refactor task is only complete when all of the following hold — not when code compiles or tests pass:
 
-The Spec checkbox may be skipped only when the documented \`/simple\` fast-path protocol is stated and its criteria are met.
+The Spec checkbox may be skipped only when the documented \`/forge-fast\` protocol is stated and its criteria are met.
 
 - [ ] \`.agent/workflows/spec.md\` exit criteria met (or explicitly skipped as a trivial/self-contained change)
 - [ ] \`.agent/workflows/plan.md\` produced a plan file, approved by the user
@@ -1265,17 +1270,30 @@ function generateGettingStartedDoc() {
 
 Read this after \`thachvd-kit init\`. The kit gives every member one entry point, then selects only the process and expertise the task needs.
 
-## Start Every Task With /task
+## Forge Command Map
 
-Use \`/task <request>\` before editing whenever the route is not already obvious. It must produce:
+| Client | Task | Fast | Debug | Research | Review | Release |
+|---|---|---|---|---|---|---|
+| Codex | \`$forge-task\` | \`$forge-fast\` | \`$forge-debug\` | \`$forge-research\` | \`$forge-review\` | \`$forge-release\` |
+| Antigravity | \`/forge-task\` | \`/forge-fast\` | \`/forge-debug\` | \`/forge-research\` | \`/forge-review\` | \`/forge-release\` |
+| Claude Code | \`/forge-task\` | \`/forge-fast\` | \`/forge-debug\` | \`/forge-research\` | \`/forge-review\` | \`/forge-release\` |
+| Cursor | \`/forge-task\` | \`/forge-fast\` | \`/forge-debug\` | \`/forge-research\` | \`/forge-review\` | \`/forge-release\` |
+
+Forge commands accept free-form text after the command and continue the selected workflow in the same turn. Plain questions remain normal chat; edit requests without a command are implicitly routed as \`forge-task\`.
+
+Codex Forge skills live in \`~/.codex/skills/forge-*/SKILL.md\`. Antigravity Forge workflows live in \`.agent/workflows/forge-*.md\`. Claude Code Forge commands live in \`.claude/commands/forge-*.md\`. Cursor Forge commands live in \`.cursor/commands/forge-*.md\`.
+
+## Start Every Task With Forge
+
+Use the matching Forge command before editing whenever the request is not a simple question. \`forge-task\` must route internally and continue; it must not stop by asking the member to type a second command.
 
 \`\`\`text
-ROUTE: question | simple | feature | bug | review | release | multi-domain
+ROUTE: question | fast | feature | bug | research | review | release | multi-domain
 WORKFLOW: [exact .agent/workflows/<name>.md file]
 SKILLS: [matching skills, or none]
 AGENTS: [matching specialist agents, or none]
-GATE: fast-path | standard
-NEXT: [the next command or action]
+GATE: fast-path | standard | human-approval
+ACTION: [what the agent is doing next in this turn]
 \`\`\`
 
 A workflow is the process and its gates. A skill is the method or checklist. An agent is the specialist role. Chat alone is not a route: the member must select the route and invoke the matching workflow or explicitly choose the question path.
@@ -1285,22 +1303,23 @@ A workflow is the process and its gates. A skill is the method or checklist. An
 | Situation | Command | Gate | Required next step |
 |---|---|---|---|
 | Explain, inspect, or brainstorm only | direct answer or \`/brainstorm\` | none | no code until the request becomes actionable |
-| One obvious local fix | \`/simple <request>\` | fast-path | inspect -> edit -> focused verify |
-| New behavior, multi-file change, unclear scope, or >~30 min | \`/task\` -> \`/brainstorm\` -> \`/spec\` when needed -> \`/plan\` | standard | wait for approval before implementation |
-| Bug, regression, failing test, or unknown error | \`/debug <symptom>\` | bug | reproduce -> isolate -> regression test -> fix -> verify |
-| Pre-merge or independent review | \`/review\` | review | five-axis review; resolve blocking findings |
-| Version, tag, npm publish, or deployment | \`/release\` | release | release checklist; never fast-path |
+| One obvious local fix | \`/forge-fast <request>\` | fast-path | inspect -> edit -> focused verify |
+| New behavior, multi-file change, unclear scope, or >~30 min | \`/forge-task <request>\` | standard | route -> research/spec/plan -> approval when required -> continue |
+| Bug, regression, failing test, or unknown error | \`/forge-debug <symptom>\` | bug | reproduce -> isolate -> regression test -> fix -> verify |
+| Research request | \`/forge-research <question>\` | research | evidence report, no edits |
+| Pre-merge or independent review | \`/forge-review\` | review | five-axis review; resolve blocking findings |
+| Version, tag, npm publish, or deployment | \`/forge-release\` | release | release checklist; never fast-path |
 | Frontend + backend + data/security together | \`/orchestrate\` | standard | plan -> approval -> specialist work -> integration verify |
 
 ## Standard Feature Flow
 
-The gated sequence is Spec -> Plan -> Implement -> Review: \`/task\` -> \`/brainstorm\` -> \`/spec\` when scope is ambiguous or multi-file -> \`/plan\` -> user approves the plan -> implementation -> \`/test\` -> \`/review\` -> final verification -> commit/push.
+The gated sequence is Spec -> Plan -> Implement -> Review. \`/forge-task\` manages this sequence internally and pauses only at the explicit user approval gate before implementation.
 
 The plan is a gate, not a suggestion. Do not start product-code implementation before explicit approval. Load only the relevant specialist agent and skills, such as \`$frontend-design\`, \`$api-design\`, or \`$webapp-testing\`.
 
 ## Bug Fix Flow
 
-Use \`/debug <symptom>\`, not the feature flow, when something is failing or the root cause is unknown:
+Use \`/forge-debug <symptom>\`, not the feature flow, when something is failing or the root cause is unknown:
 
 1. Capture the exact symptom, environment, reproduction, and expected result.
 2. Inspect the relevant code path with MCP/codegraph when available.
@@ -1314,7 +1333,7 @@ Load \`$systematic-debugging\`, the \`debugger\` agent, and \`testing-patterns\`
 
 ## Simple Fast Path
 
-Use \`/simple <request>\` only when the change is one obvious file, the result is unambiguous, and it changes no behavior, API, schema, security, CI, dependency, workflow, or release contract. Before editing, state:
+Use \`/forge-fast <request>\` only when the change is one obvious file, the result is unambiguous, and it changes no behavior, API, schema, security, CI, dependency, workflow, or release contract. Before editing, state:
 
 \`\`\`text
 FAST_PATH: simple-fix
@@ -1322,18 +1341,18 @@ REASON: [why Spec/Plan/Review are not needed]
 SCOPE: [file or narrow area]
 \`\`\`
 
-This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection, focused verification, or reporting evidence. If the scope expands, stop and re-route with \`/task\`.
+This bypasses only Spec, Plan, and the feature/refactor Review gate. It never bypasses inspection, focused verification, or reporting evidence. If the scope expands, stop and re-route internally through \`forge-task\`.
 
 ## Command And Skill Map
 
 - \`/brainstorm\`: clarify intent and tradeoffs; no code.
-- \`/spec\`: define requirements and acceptance criteria; no code.
+- \`forge-research\`: evidence-based codebase/technical/domain research; no product-code edits.
 - \`/plan\`: create an approved implementation plan; no code before approval.
 - \`/enhance\` or \`/create\`: implement an approved feature with the relevant specialist agent.
-- \`/debug\`: systematic root-cause investigation and regression protection.
+- \`forge-debug\`: systematic root-cause investigation and regression protection.
 - \`/test\`: add or run tests and assess coverage.
 - \`/review\`: five-axis review before completion or merge.
-- \`/release\`: verify, version, tag, publish, and verify npm output.
+- \`forge-release\`: verify, version, tag, publish, and verify npm output.
 - \`$clean-code\` and \`$verification-before-completion\`: default implementation hygiene.
 - \`$webapp-testing\`: browser/UI verification; use Playwright when available.
 
@@ -1536,7 +1555,7 @@ function copyAgentFolder() {
     return { copied, skipped: 0 };
 }
 
-function copySelectedSkillFolders(data, assumeYes) {
+function copySelectedSkillFolders(data, assumeYes) {
     const srcSkills = path.join(sourceDir, '.agent', 'skills');
     if (!fs.existsSync(srcSkills)) return { copied: 0, skipped: 0, missing: 0, skills: [] };
 
@@ -1579,8 +1598,114 @@ function copySelectedSkillFolders(data, assumeYes) {
         }
     }
 
-    return { copied, skipped: 0, missing, skills: selectedSkills };
-}
+    return { copied, skipped: 0, missing, skills: selectedSkills };
+}
+
+function copyCodexPrompts() {
+    const srcPrompts = path.join(sourceDir, 'prompts');
+    const codexPromptsDir = homePath('.codex', 'prompts');
+    if (!fs.existsSync(srcPrompts) || !codexPromptsDir) {
+        return { copied: 0, prompts: [] };
+    }
+
+    let copied = 0;
+    const prompts = [];
+    fs.mkdirSync(codexPromptsDir, { recursive: true });
+    for (const entry of fs.readdirSync(srcPrompts, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+        fs.copyFileSync(path.join(srcPrompts, entry.name), path.join(codexPromptsDir, entry.name));
+        copied++;
+        prompts.push(path.basename(entry.name, '.md'));
+    }
+    return { copied, prompts };
+}
+
+function copyClientWorkflowCommands() {
+    const srcPrompts = path.join(sourceDir, 'prompts');
+    const claudeSkillsDir = path.join(targetDir, '.claude', 'skills');
+    const cursorCommandsDir = path.join(targetDir, '.cursor', 'commands');
+    if (!fs.existsSync(srcPrompts)) {
+        return { claude: 0, cursor: 0, prompts: [] };
+    }
+
+    let claude = 0;
+    let cursor = 0;
+    const prompts = [];
+    for (const entry of fs.readdirSync(srcPrompts, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+        const name = path.basename(entry.name, '.md');
+        const sourcePath = path.join(srcPrompts, entry.name);
+        const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+        const cursorContent = sourceContent.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
+        fs.mkdirSync(path.join(claudeSkillsDir, name), { recursive: true });
+        fs.copyFileSync(sourcePath, path.join(claudeSkillsDir, name, 'SKILL.md'));
+        fs.mkdirSync(cursorCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(cursorCommandsDir, entry.name), cursorContent, 'utf8');
+        claude++;
+        cursor++;
+        prompts.push(name);
+    }
+    return { claude, cursor, prompts };
+}
+
+function stripFrontmatter(content) {
+    return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '').trimStart();
+}
+
+function copyForgeCommands() {
+    const srcCommands = path.join(sourceDir, 'commands');
+    const codexSkillsDir = homePath('.codex', 'skills');
+    if (!fs.existsSync(srcCommands)) {
+        return { antigravity: 0, claude: 0, cursor: 0, codex: 0, commands: [] };
+    }
+
+    const destinations = {
+        antigravity: path.join(targetDir, '.agent', 'workflows'),
+        claude: path.join(targetDir, '.claude', 'commands'),
+        cursor: path.join(targetDir, '.cursor', 'commands')
+    };
+    let antigravity = 0;
+    let claude = 0;
+    let cursor = 0;
+    let codex = 0;
+    const commands = [];
+
+    for (const commandName of FORGE_COMMANDS) {
+        const filename = `${commandName}.md`;
+        const sourcePath = path.join(srcCommands, filename);
+        if (!fs.existsSync(sourcePath)) continue;
+        const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+        const body = stripFrontmatter(sourceContent);
+
+        fs.mkdirSync(destinations.antigravity, { recursive: true });
+        fs.copyFileSync(sourcePath, path.join(destinations.antigravity, filename));
+        antigravity++;
+
+        fs.mkdirSync(destinations.claude, { recursive: true });
+        fs.copyFileSync(sourcePath, path.join(destinations.claude, filename));
+        claude++;
+
+        fs.mkdirSync(destinations.cursor, { recursive: true });
+        fs.writeFileSync(path.join(destinations.cursor, filename), body, 'utf8');
+        cursor++;
+
+        if (codexSkillsDir) {
+            const skillDir = path.join(codexSkillsDir, commandName);
+            fs.mkdirSync(skillDir, { recursive: true });
+            const skillBody = body.replace(/\$ARGUMENTS/g, 'the request supplied with this skill');
+            fs.writeFileSync(
+                path.join(skillDir, 'SKILL.md'),
+                `---\nname: ${commandName}\ndescription: ${sourceContent.match(/^description:\s*(.+)$/m)?.[1] || `Run ${commandName}`}\n---\n\nThis skill is invoked as $${commandName}. Treat the user's text supplied with the skill as the request.\n\n${skillBody}`,
+                'utf8'
+            );
+            codex++;
+        }
+
+        commands.push(commandName);
+    }
+
+    return { antigravity, claude, cursor, codex, commands };
+}
 
 async function writeGeneratedFile(relativePath, content, assumeYes) {
     const outputPath = path.join(targetDir, relativePath);
@@ -1913,12 +2038,27 @@ async function main() {
         console.log(`  ${pc.yellow('~')} ${pc.bold('.agent/')} already exists - ${skipped} file${skipped !== 1 ? 's' : ''} skipped (no overwrite)`);
     }
 
-    const nativeSkills = copySelectedSkillFolders(data, assumeYes);
+    const nativeSkills = copySelectedSkillFolders(data, assumeYes);
     if (nativeSkills.copied > 0) {
         console.log(`  ${pc.green('OK')} Copied native skills to ${pc.bold('~/.codex/skills/')} and ${pc.bold('.claude/skills/')} (${nativeSkills.skills.join(', ')})`);
     } else if (nativeSkills.skipped > 0) {
         console.log(`  ${pc.yellow('~')} Native skills already exist - ${nativeSkills.skipped} file${nativeSkills.skipped !== 1 ? 's' : ''} skipped`);
-    }
+    }
+
+    const codexPrompts = copyCodexPrompts();
+    if (codexPrompts.copied > 0) {
+        console.log(`  ${pc.green('OK')} Installed Codex custom prompts in ${pc.bold('~/.codex/prompts/')} (${codexPrompts.prompts.map(name => `/prompts:${name}`).join(', ')})`);
+    }
+
+    const legacyClientCommands = copyClientWorkflowCommands();
+    if (legacyClientCommands.claude > 0 || legacyClientCommands.cursor > 0) {
+        console.log(`  ${pc.dim('~')} Preserved legacy workflow aliases for Claude Code and Cursor (${legacyClientCommands.claude}/${legacyClientCommands.cursor})`);
+    }
+
+    const forgeCommands = copyForgeCommands();
+    if (forgeCommands.commands.length > 0) {
+        console.log(`  ${pc.green('OK')} Installed Forge commands (${forgeCommands.commands.join(', ')}) for Antigravity (${forgeCommands.antigravity}), Claude Code (${forgeCommands.claude}), Cursor (${forgeCommands.cursor}), and Codex skills (${forgeCommands.codex})`);
+    }
 
 
     const generatedFiles = [
@@ -1964,8 +2104,13 @@ async function main() {
     - ${pc.bold('.cursorrules')} Cursor entry
     - ${pc.bold('.agent/docs/')} scan-based project rules, including ${pc.bold('getting-started.md')} (standard flow vs fast path)
     - ${pc.bold('.agent/')} skills, workflows, agents, and rules
-    - ${pc.bold('~/.codex/skills/')} selected Codex skills installed globally (visible in $ menu)
-    - ${pc.bold('.claude/skills/')} selected Claude Code native skills
+    - ${pc.bold('~/.codex/skills/')} selected Codex skills installed globally (visible in $ menu)
+    - ${pc.bold('~/.codex/skills/forge-*/')} Forge Codex skills (visible as $forge-task, $forge-fast, and related skills)
+    - ${pc.bold('~/.codex/prompts/')} legacy Codex prompts retained for compatibility
+    - ${pc.bold('.claude/skills/')} selected Claude Code native skills
+    - ${pc.bold('.claude/commands/forge-*.md')} Forge Claude Code commands (visible as /forge-task and related commands)
+    - ${pc.bold('.cursor/commands/forge-*.md')} Forge Cursor commands (visible as /forge-task and related commands)
+    - ${pc.bold('.agent/workflows/forge-*.md')} Forge Antigravity workflows (visible as /forge-task and related commands)
     - ${pc.bold('.claude/settings.json')} Definition-of-Done Stop hook (Claude Code only — blocks reporting a feature/refactor "done" without a plan + review pass)
 
   ${pc.bold('MCP/tooling setup:')}

package/commands/forge-debug.md

@@ -0,0 +1,12 @@
+---
+description: Investigate and fix a bug with evidence-first root-cause analysis.
+argument-hint: [SYMPTOM]
+---
+
+# Forge Debug
+
+Symptom:
+
+$ARGUMENTS
+
+Read `.agent/workflows/debug.md`, use `$systematic-debugging`, the `debugger` agent, and `testing-patterns` when available. Reproduce the symptom, inspect the relevant code path with codegraph/MCP, form and test hypotheses, identify the root cause, add regression protection when practical, make the smallest fix, and verify it. Do not patch by guesswork and do not stop by asking the member to invoke another command.

package/commands/forge-fast.md

@@ -0,0 +1,22 @@
+---
+description: Execute a trivial, unambiguous change with focused verification.
+argument-hint: [REQUEST]
+---
+
+# Forge Fast Path
+
+Request:
+
+$ARGUMENTS
+
+Use this path only for one obvious file or tiny local change with no behavior, API, schema, security, CI, dependency, workflow, or release contract change.
+
+Before editing, state exactly:
+
+```text
+FAST_PATH: simple-fix
+REASON: [why Spec, Plan, and feature Review are not needed]
+SCOPE: [file or narrow area]
+```
+
+Inspect the target, make the smallest change, run focused verification, and report evidence. If the scope expands, stop and internally re-route through the appropriate Forge workflow. Never skip inspection or verification.

package/commands/forge-release.md

@@ -0,0 +1,12 @@
+---
+description: Verify, version, publish, and verify the thachvd-kit npm release.
+argument-hint: [RELEASE_REQUEST]
+---
+
+# Forge Release
+
+Release request:
+
+$ARGUMENTS
+
+Read `.agent/workflows/release.md` and run the release gate. Confirm the working tree, review status, version, npm authentication, verification output, and package contents before publishing. Never use the fast path. Do not run `npm publish` until the release gate is satisfied and the human has confirmed the final version and publish action. After publishing, verify the registry version and the installed package output.

package/commands/forge-research.md

@@ -0,0 +1,24 @@
+---
+description: Research the codebase, technical topic, or domain without editing product code.
+argument-hint: [QUESTION]
+---
+
+# Forge Research
+
+Research question:
+
+$ARGUMENTS
+
+Do not edit product code. First classify the research as codebase, external technical, or domain research. For codebase research, use codegraph/MCP first. For external research, use authoritative current sources only when needed and cite them. Return exactly:
+
+```text
+RESEARCH_STATUS: complete | blocked
+QUESTION: [what was investigated]
+ASSUMPTIONS: [explicit assumptions]
+FINDINGS: [evidence-based findings]
+SOURCES: [file paths, symbols, MCP evidence, or URLs]
+RISKS: [known risks and unknowns]
+OPTIONS: [possible approaches and tradeoffs]
+RECOMMENDATION: [recommended direction]
+OPEN_QUESTIONS: [unresolved questions]
+```

package/commands/forge-review.md

@@ -0,0 +1,12 @@
+---
+description: Review a change across correctness, simplicity, architecture, security, and performance.
+argument-hint: [SCOPE]
+---
+
+# Forge Review
+
+Review scope:
+
+$ARGUMENTS
+
+Read `.agent/workflows/review.md` and inspect the relevant diff, task, and verification evidence. Review all five axes. Report findings first, ordered by severity, using `BLOCKING`, `SUGGESTION`, `NIT`, or `QUESTION`. Do not edit code during review unless the member explicitly asks for fixes after the findings.

package/commands/forge-task.md

@@ -0,0 +1,37 @@
+---
+description: Route a request and continue the selected Forge workflow in this turn.
+argument-hint: [REQUEST]
+---
+
+# Forge Task Orchestrator
+
+The request supplied with this command is:
+
+$ARGUMENTS
+
+Read `AGENTS.md`, `.agent/docs/project.md`, and `.agent/docs/workflow.md` before editing.
+
+Classify the request internally as `question`, `fast`, `feature`, `bug`, `research`, `review`, `release`, or `multi-domain`. Then continue the selected workflow in this same turn. Do not stop after printing a `NEXT` command and do not ask the member to invoke another Forge command for ordinary routing.
+
+Use this compact status header when useful:
+
+```text
+REQUEST: [original request]
+ROUTE: [route]
+WORKFLOW: [exact workflow file]
+SKILLS: [matching skills]
+AGENTS: [matching agents]
+GATE: fast-path | standard | human-approval
+ACTION: [what you are doing now]
+```
+
+Rules:
+
+- Questions and analysis: answer directly with no edits.
+- Trivial one-file changes: apply the `forge-fast` protocol, including focused verification.
+- Bugs or unknown failures: reproduce, isolate root cause, add regression protection, fix, and verify.
+- Research: use codegraph/MCP first for repository questions, use authoritative external sources when needed, and do not edit code.
+- Features and refactors: follow spec -> plan -> approval -> implement -> test -> review. Stop only at the documented human approval gate.
+- Reviews: run the five-axis review and report findings first.
+- Releases: follow `.agent/workflows/release.md`; never use the fast path.
+- If the request is empty or unsafe to classify, ask one concise clarification question.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "thachvd-kit",
-    "version": "1.0.27",
+    "version": "1.0.29",
     "description": "Cross-agent project rules bootstrap kit for Codex, Antigravity, and Claude Code",
     "bin": {
         "thachvd-kit": "./bin/cli.js"
@@ -9,10 +9,12 @@
         ".agent",
         "agents",
         "bin",
+        "commands",
         "kit",
         "rules",
         "scripts",
         "skills",
+        "prompts",
         "workflows",
         "README.md",
         "LICENSE"

package/prompts/debug.md

@@ -0,0 +1,11 @@
+---
+description: Investigate a bug with evidence, root-cause analysis, regression protection, and verification.
+argument-hint: [SYMPTOM]
+---
+
+Read and follow `.agent/workflows/debug.md` in the current repository.
+
+Bug or symptom:
+$ARGUMENTS
+
+Use `$systematic-debugging`, the `debugger` agent, and `testing-patterns` when available. Reproduce and isolate the root cause before editing.

package/prompts/release.md

@@ -0,0 +1,11 @@
+---
+description: Run the npm release workflow with verification, versioning, tagging, publishing, and registry checks.
+argument-hint: [RELEASE_REQUEST]
+---
+
+Read and follow `.agent/workflows/release.md` in the current repository.
+
+Release request:
+$ARGUMENTS
+
+Do not publish until the release gate and `npm run release:verify` pass.

package/prompts/simple.md

@@ -0,0 +1,11 @@
+---
+description: Run the fast path for one-file, unambiguous fixes with verification.
+argument-hint: [TASK]
+---
+
+Read and follow `.agent/workflows/simple.md` in the current repository.
+
+Request:
+$ARGUMENTS
+
+Use the fast path only when its criteria are met. State `FAST_PATH: simple-fix`, `REASON`, and `SCOPE` before editing. Never skip verification.

package/prompts/spec.md

@@ -0,0 +1,11 @@
+---
+description: Define requirements and acceptance criteria before planning or implementation.
+argument-hint: [REQUEST]
+---
+
+Read and follow `.agent/workflows/spec.md` in the current repository.
+
+Request:
+$ARGUMENTS
+
+Do not write product code. Stop at the spec gate and wait for human confirmation.

package/prompts/task.md

@@ -0,0 +1,12 @@
+---
+description: Route the current request to the smallest safe workflow before editing.
+argument-hint: [TASK]
+---
+
+Read and follow `.agent/workflows/task.md` in the current repository.
+
+Route this request before editing:
+
+$ARGUMENTS
+
+Return the required ROUTE, WORKFLOW, SKILLS, AGENTS, GATE, and NEXT fields. Do not edit code while routing.

package/workflows/simple.md

@@ -6,6 +6,8 @@ description: Fast path for one-file, unambiguous fixes with no behavior or share
 
 $ARGUMENTS
 
+Codex UI command: `/prompts:simple`. The `/simple` name below describes the workflow; it is not a built-in Codex slash command.
+
 ## Use Only When
 
 - The change is limited to one obvious file or one tiny local edit.

package/workflows/task.md

@@ -6,6 +6,8 @@ description: Route every task to the smallest safe workflow, fast path, bug flow
 
 $ARGUMENTS
 
+Codex UI command: `/prompts:task`. The `/task` name below describes the workflow; it is not a built-in Codex slash command.
+
 ## Purpose
 
 Use `/task` at the start of a task when you are unsure which workflow, skill, or specialist agent applies. This command routes the request before implementation.