@nforma.ai/nforma 0.2.1

package/commands/qgsd/mcp-status.md

@@ -0,0 +1,274 @@
+---
+name: qgsd:mcp-status
+description: Show status of all connected quorum agents — provider, model, health, and latency
+allowed-tools:
+  - Read
+  - Bash
+  - Task
+  - mcp__codex-1__identity
+  - mcp__gemini-1__identity
+  - mcp__opencode-1__identity
+  - mcp__copilot-1__identity
+  - mcp__claude-1__identity
+  - mcp__claude-2__identity
+  - mcp__claude-3__identity
+  - mcp__claude-4__identity
+  - mcp__claude-5__identity
+  - mcp__claude-6__identity
+  - mcp__claude-1__health_check
+  - mcp__claude-2__health_check
+  - mcp__claude-3__health_check
+  - mcp__claude-4__health_check
+  - mcp__claude-5__health_check
+  - mcp__claude-6__health_check
+  - mcp__codex-1__health_check
+  - mcp__gemini-1__health_check
+  - mcp__opencode-1__health_check
+  - mcp__copilot-1__health_check
+---
+
+<objective>
+Display a clean status table of all connected MCP quorum agents plus the Claude orchestrator. For CLI agents (codex-1, gemini-1, opencode-1, copilot-1): call their identity tool and health_check for real model names and latency. For HTTP agents (claude-1..6): call their identity tool then health_check for real-time endpoint health. Read provider URLs from ~/.claude.json. Show a claude orchestrator row at the top of the table.
+
+This command is read-only (observation only). It does NOT invoke quorum and is NOT in quorum_commands.
+</objective>
+
+<process>
+
+> **IMPORTANT: Run every Bash call in this workflow sequentially (one at a time). Never issue two Bash calls in parallel. A failure in one parallel sibling cancels all other parallel siblings — sequential execution isolates failures. For each numbered step below: run this Bash command alone, wait for its full output, store the result, then proceed to the next step.**
+
+## Step 1: Read scoreboard + provider URLs (run this Bash command first, wait for output before proceeding to Step 2)
+
+Run the following Bash command and store the output as INIT_INFO:
+
+```bash
+node << 'EOF'
+const fs=require('fs'), path=require('path'), os=require('os');
+
+// Scoreboard
+const sbPath=path.join(process.cwd(),'.planning','quorum-scoreboard.json');
+let totalRounds=0, lastUpdate=null;
+if(fs.existsSync(sbPath)){
+  const d=JSON.parse(fs.readFileSync(sbPath,'utf8'));
+  totalRounds=(d.rounds||[]).length;
+  lastUpdate=d.team?.captured_at||null;
+}
+
+// Provider URLs from ~/.claude.json
+const URL_MAP={
+  'https://api.akashml.com/v1':           'AkashML',
+  'https://api.together.xyz/v1':          'Together.xyz',
+  'https://api.fireworks.ai/inference/v1':'Fireworks',
+};
+const cfgPath=path.join(os.homedir(),'.claude.json');
+const providers={};
+if(fs.existsSync(cfgPath)){
+  const cfg=JSON.parse(fs.readFileSync(cfgPath,'utf8'));
+  for(const [key,val] of Object.entries(cfg.mcpServers||{})){
+    const url=(val.env||{}).ANTHROPIC_BASE_URL||null;
+    providers[key]=url?URL_MAP[url]||url:null;
+  }
+}
+
+// Claude orchestrator model from ~/.claude/settings.json
+const claudeSettingsPath=path.join(os.homedir(),'.claude','settings.json');
+let claudeModel='claude-sonnet-4-6'; // default
+if(fs.existsSync(claudeSettingsPath)){
+  try {
+    const cs=JSON.parse(fs.readFileSync(claudeSettingsPath,'utf8'));
+    const raw=(cs.model||'sonnet').toLowerCase();
+    if(raw.includes('opus')) claudeModel='claude-opus-4-6';
+    else if(raw.includes('haiku')) claudeModel='claude-haiku-4-5-20251001';
+    else claudeModel='claude-sonnet-4-6';
+  } catch(_){}
+}
+
+// Claude orchestrator auth type — oauthAccount present = subscription (sub), absent = API key (api)
+let claudeAuth='api'; // default: API key
+if(fs.existsSync(cfgPath)){
+  try {
+    const cfg=JSON.parse(fs.readFileSync(cfgPath,'utf8'));
+    if(cfg.oauthAccount && typeof cfg.oauthAccount==='object') claudeAuth='sub';
+  } catch(_){}
+}
+
+console.log(JSON.stringify({totalRounds,lastUpdate,providers,claudeModel,claudeAuth}));
+EOF
+```
+
+Parse `totalRounds`, `lastUpdate`, `providers` (map of slot → provider name or null), `claudeModel`, and `claudeAuth`.
+
+**Provider for CLI agents** — prefer `identity.display_provider` when present. If absent, infer from model name:
+- `gpt-*` or `o[0-9]*` → OpenAI
+- `gemini-*` → Google
+- `claude-*` → Anthropic
+- `opencode*` or `grok*` → OpenCode
+- default → —
+
+**Auth type** — read from identity response `auth_type` field if present. If absent, infer:
+- CLI agents (codex-1, gemini-1, opencode-1, copilot-1) → `sub` (subscription — flat fee, no per-token cost)
+- HTTP agents (claude-1..6) → `api` (API token — pay per request)
+
+Display as `sub` or `api` in the Auth column.
+
+## Step 2: Display banner (run this Bash command second, after Step 1 output is stored; wait for output before proceeding to Step 3)
+
+Print:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► MCP STATUS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Querying 4 CLI agents + 6 HTTP providers...
+```
+
+## Step 3: Collect identity + health_check results via sub-agent (run after Step 2 output is stored)
+
+Invoke a Task() sub-agent to call all MCP tools. This prevents raw tool-result blocks from appearing in the main conversation.
+
+```
+Task(
+  subagent_type: "general-purpose",
+  model: "claude-haiku-4-5",
+  prompt: """
+You are a data-collection sub-agent. Your only job is to call the MCP tools listed below and return their results as a single JSON object. Do not explain or summarize — return only the JSON object.
+
+Call each tool with {} as input. Wrap every call in try/catch — if a tool throws or is unavailable, record null for that field.
+
+Tools to call in this order (call them one at a time, sequentially — never parallel):
+
+1.  mcp__codex-1__identity          — store result as codex_id
+2.  mcp__gemini-1__identity         — store result as gemini_id
+3.  mcp__opencode-1__identity       — store result as opencode_id
+4.  mcp__copilot-1__identity        — store result as copilot_id
+5.  mcp__codex-1__health_check      — store result as codex_hc
+6.  mcp__gemini-1__health_check     — store result as gemini_hc
+7.  mcp__opencode-1__health_check   — store result as opencode_hc
+8.  mcp__copilot-1__health_check    — store result as copilot_hc
+9.  mcp__claude-1__identity         — store result as claude1_id
+10. mcp__claude-1__health_check     — store result as claude1_hc
+11. mcp__claude-2__identity         — store result as claude2_id
+12. mcp__claude-2__health_check     — store result as claude2_hc
+13. mcp__claude-3__identity         — store result as claude3_id
+14. mcp__claude-3__health_check     — store result as claude3_hc
+15. mcp__claude-4__identity         — store result as claude4_id
+16. mcp__claude-4__health_check     — store result as claude4_hc
+17. mcp__claude-5__identity         — store result as claude5_id
+18. mcp__claude-5__health_check     — store result as claude5_hc
+19. mcp__claude-6__identity         — store result as claude6_id
+20. mcp__claude-6__health_check     — store result as claude6_hc
+
+Return ONLY this JSON structure (no markdown, no explanation):
+{
+  "codex-1":    { "identity": <codex_id or null>,    "hc": <codex_hc or null> },
+  "gemini-1":   { "identity": <gemini_id or null>,   "hc": <gemini_hc or null> },
+  "opencode-1": { "identity": <opencode_id or null>, "hc": <opencode_hc or null> },
+  "copilot-1":  { "identity": <copilot_id or null>,  "hc": <copilot_hc or null> },
+  "claude-1":   { "identity": <claude1_id or null>,  "hc": <claude1_hc or null> },
+  "claude-2":   { "identity": <claude2_id or null>,  "hc": <claude2_hc or null> },
+  "claude-3":   { "identity": <claude3_id or null>,  "hc": <claude3_hc or null> },
+  "claude-4":   { "identity": <claude4_id or null>,  "hc": <claude4_hc or null> },
+  "claude-5":   { "identity": <claude5_id or null>,  "hc": <claude5_hc or null> },
+  "claude-6":   { "identity": <claude6_id or null>,  "hc": <claude6_hc or null> }
+}
+
+Where each identity value is the raw object returned by the tool (with at minimum `version` and `model` fields), and each hc value is the raw object returned by health_check (with `healthy`, `latencyMs`, and optionally `model`, `via` fields).
+"""
+)
+```
+
+Store the sub-agent's returned JSON object as AGENT_RESULTS (parse from the sub-agent's text output).
+
+For each slot in AGENT_RESULTS:
+- `identity` = the identity result (or null if the sub-agent recorded null)
+- `hc` = the health_check result (or null)
+
+Use these values in Step 4 exactly as before — the shape is identical to what the old direct tool calls returned.
+
+## Step 4: Derive health state per agent
+
+**For CLI agents — identity + health_check based:**
+- If identity call threw an exception → health = `error`, latency = `—`
+- Else if `hc` is null (health_check threw or timed out) → health = `available`, latency = `—`
+- Else if `!hc.healthy` → health = `unhealthy`, latency = `${hc.latencyMs}ms`
+- Else → health = `available`, latency = `${hc.latencyMs}ms`
+
+Model for CLI agents: use `identity.model` if present (real model name from model_detect or static), else `identity.display_provider ?? identity.provider`.
+
+**For HTTP agents (claude-1 through claude-6) — live health_check result:**
+- If identity call threw an exception → health = `error`, latency = `—`
+- Else if `hc` is null (health_check threw or timed out) → health = `unreachable`, latency = `—`
+- Else if `hc.healthy === false` → health = `unhealthy`, latency = `${hc.latencyMs}ms`
+- Else if `hc.via === 'fallback'` → health = `fallback`, latency = `${hc.latencyMs}ms`
+- Else → health = `available`, latency = `${hc.latencyMs}ms`
+
+When `hc.via === 'fallback'`, the displayed Model should be `hc.model` (the fallback model) rather than the primary model from identity, since that's what actually responded.
+
+## Step 5: Render formatted table
+
+Collect all results then render **one table** via a single Bash call (do not print rows one at a time). Pass the collected data as a JSON string into the script.
+
+Columns: **Agent | Auth | Provider | Model | Health | Latency**
+
+Auto-size each column to the widest value (including header). Use box-drawing characters for borders.
+
+Before rendering, prepend a claude orchestrator row at the TOP of the table. This row does NOT come from AGENT_RESULTS — it comes from INIT_INFO:
+- Agent: `claude`
+- Auth: `claudeAuth` (from INIT_INFO — derived from `oauthAccount.billingType` in `~/.claude.json`; `sub` for stripe_subscription/pro, `api` if `ANTHROPIC_API_KEY` is set or billingType indicates API billing)
+- Provider: `Anthropic`
+- Model: `claudeModel` (from INIT_INFO, e.g. `claude-sonnet-4-6`)
+- Health: `orchestrator`
+- Latency: `—`
+
+Example output format:
+
+```
+┌─────────────┬──────┬──────────────┬───────────────────────────────────────────────────┬──────────────┬─────────┐
+│ Agent       │ Auth │ Provider     │ Model                                             │ Health       │ Latency │
+├─────────────┼──────┼──────────────┼───────────────────────────────────────────────────┼──────────────┼─────────┤
+│ claude      │ sub  │ Anthropic    │ claude-sonnet-4-6                                 │ orchestrator │ —       │
+│ codex-1     │ sub  │ OpenAI       │ gpt-5.3-codex                                     │ available    │ 245ms   │
+│ gemini-1    │ sub  │ Google       │ gemini-2.5-pro                                    │ available    │ 312ms   │
+│ opencode-1  │ sub  │ OpenCode     │ xai/grok-3                                        │ available    │ 891ms   │
+│ copilot-1   │ sub  │ GitHub       │ gpt-4.1                                           │ available    │ 1204ms  │
+│ claude-1    │ api  │ AkashML      │ deepseek-ai/DeepSeek-V3.2                         │ available    │ 524ms   │
+│ claude-2    │ api  │ AkashML      │ MiniMaxAI/MiniMax-M2.5                            │ available    │ 735ms   │
+│ claude-3    │ api  │ Together.xyz │ Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8           │ available    │ 761ms   │
+│ claude-4    │ api  │ Fireworks    │ accounts/fireworks/models/kimi-k2p5               │ available    │ 1828ms  │
+│ claude-5    │ api  │ Together.xyz │ meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8 │ available    │ 20601ms │
+│ claude-6    │ api  │ Fireworks    │ accounts/fireworks/models/glm-5                   │ fallback     │ 312ms   │
+└─────────────┴──────┴──────────────┴───────────────────────────────────────────────────┴──────────────┴─────────┘
+
+Scoreboard: 156 rounds recorded | Last update: 2026-02-23T14:23:52.301Z
+```
+
+If scoreboard file was absent, show instead:
+```
+Scoreboard: no data yet (run /qgsd:quorum first to populate)
+```
+
+Health legend:
+- `available`   — agent responded (identity succeeded; for HTTP: health_check passed)
+- `fallback`    — primary endpoint failed; fallback provider (ANTHROPIC_FALLBACK_BASE_URL) responded successfully
+- `unhealthy`   — HTTP endpoint returned healthy=false
+- `unreachable` — HTTP health_check call failed (timeout, connection error)
+- `error`       — identity call failed (agent not running or crashed)
+
+</process>
+
+<success_criteria>
+- All 11 rows shown in one clean table (1 orchestrator + 4 CLI + 6 HTTP)
+- Columns: Agent | Auth | Provider | Model | Health | Latency (no UNAVAIL column)
+- `claude` orchestrator row shown at top of table with model read from `~/.claude/settings.json`
+- CLI agents show real model names (gpt-5.3-codex, gemini-2.5-pro, xai/grok-3, gpt-4.1) not binary names
+- CLI agents show real latency in ms from `health_check` --version call
+- CLI agent Provider column uses `identity.display_provider` (OpenAI, Google, OpenCode, GitHub)
+- Provider derived from ~/.claude.json ANTHROPIC_BASE_URL for HTTP agents; identity.display_provider for CLI agents
+- Health for CLI agents reflects identity + health_check result (available/unhealthy/error)
+- Health for claude-1..6 is live from health_check result; `fallback` shown when primary failed but fallback responded
+- Model column shows fallback model name (hc.model) when via=fallback, so it always reflects what actually served the check
+- Latency shows ms for all agents with health_check, — for claude orchestrator row
+- Command handles missing scoreboard gracefully (no crash)
+- Command handles individual agent failures gracefully (no crash)
+- Table rendered in a single Bash call at the end, not printed row-by-row
+</success_criteria>

package/commands/qgsd/mcp-update.md

@@ -0,0 +1,238 @@
+---
+name: qgsd:mcp-update
+description: Update a quorum agent to its latest version — detects install method from ~/.claude.json and runs the correct update command
+argument-hint: "<agent|all>"
+allowed-tools:
+  - Bash
+---
+
+<objective>
+Update a named quorum agent (or all agents) to their latest version. The install method is detected from `~/.claude.json` mcpServers config: `npx`-based agents update via `npm install -g <package>`; `node`-based local repo agents update via `git pull && npm run build` in their repo directory. The running process is NOT killed — run `/qgsd:mcp-restart <agent>` after updating to load the new binary.
+</objective>
+
+<process>
+
+## Step 1 — Parse arguments
+
+Parse `$ARGUMENTS` as one token: `$TARGET`.
+
+If `$TARGET` is missing, print usage and stop:
+```
+Usage: /qgsd:mcp-update <agent|all>
+
+Valid agents:
+  codex-cli-1, gemini-cli-1, opencode-1, copilot-1,
+  claude-1, claude-2, claude-3, claude-4, claude-5, claude-6
+
+Use "all" to update all configured agents sequentially.
+```
+
+## Step 2 — Validate agent name (single agent mode)
+
+If `$TARGET` is not `"all"`:
+
+Check `$TARGET` against the known agent list:
+```
+codex-cli-1, gemini-cli-1, opencode-1, copilot-1,
+claude-1, claude-2, claude-3, claude-4, claude-5, claude-6
+```
+
+If not in the list, print an error and stop:
+```
+Error: Unknown agent "$TARGET"
+
+Valid agents:
+  codex-cli-1   gemini-cli-1   opencode-1   copilot-1
+  claude-1      claude-2       claude-3     claude-4
+  claude-5      claude-6
+
+Use "all" to update all configured agents.
+```
+
+## Step 3 — Read install config from ~/.claude.json
+
+Run this inline node script via Bash to read the install configuration:
+
+**For single agent:**
+```bash
+node -e "
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+let claudeJson;
+try {
+  claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+} catch (e) {
+  console.error('Error: Cannot read ~/.claude.json: ' + e.message);
+  process.exit(1);
+}
+
+const servers = claudeJson.mcpServers || {};
+const agent = process.env.AGENT;
+const serverConfig = servers[agent];
+
+if (!serverConfig) {
+  console.error('Error: Agent \"' + agent + '\" is not configured in ~/.claude.json mcpServers');
+  process.exit(2);
+}
+
+const command = serverConfig.command;
+const args = serverConfig.args || [];
+
+let result;
+if (command === 'npx' || command === 'npm') {
+  // npm/npx-based: package name is last arg (skip flags like -y)
+  const packageName = args[args.length - 1];
+  result = { type: 'npm', package: packageName };
+} else if (command === 'node' && args.length > 0) {
+  // local node path: args[0] = /path/to/repo/dist/index.js
+  const distIndexPath = args[0];
+  const repoDir = path.dirname(path.dirname(distIndexPath));
+  result = { type: 'local', repoDir };
+} else {
+  result = { type: 'unknown', command, args };
+}
+
+process.stdout.write(JSON.stringify(result) + '\n');
+" AGENT="$TARGET"
+```
+
+Store output as `$INSTALL_INFO`.
+
+If exit code 1 or 2: print the error message and stop.
+If exit code 0: parse `$INSTALL_INFO` JSON.
+
+## Step 4 — Execute update (single agent)
+
+Based on the `type` field from `$INSTALL_INFO`:
+
+**type = "npm":**
+```bash
+npm install -g "$PACKAGE"
+```
+where `$PACKAGE` is `install_info.package`.
+
+Capture exit code and output. If exit code ≠ 0: print error output and stop.
+
+**type = "local":**
+```bash
+cd "$REPO_DIR" && git pull && npm run build
+```
+where `$REPO_DIR` is `install_info.repoDir`.
+
+Capture exit code and output. If exit code ≠ 0: print error output and stop.
+**Important:** Do NOT kill the running process if build fails.
+
+**type = "unknown":**
+Print:
+```
+Warning: Cannot determine update method for $TARGET (command: <command>).
+Manual update required. Check ~/.claude.json mcpServers.$TARGET for configuration.
+```
+Stop.
+
+## Step 5 — Print confirmation (single agent)
+
+Display:
+```
+Updated $TARGET
+
+  Install method: <npm: npm install -g <pkg>> OR <local repo: git pull + npm run build in <repo_dir>>
+  Result: <last line of npm/git output>
+
+Note: The running agent process is still using the old version.
+Run: /qgsd:mcp-restart $TARGET   to load the new binary.
+```
+
+## Step 6 — All-agent mode (if $TARGET = "all")
+
+If `$TARGET` is `"all"`, skip Steps 2–5 and run this instead:
+
+**6a. Build update task list via inline node script:**
+
+```bash
+node -e "
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const KNOWN_AGENTS = [
+  'codex-cli-1', 'gemini-cli-1', 'opencode-1', 'copilot-1',
+  'claude-1', 'claude-2', 'claude-3', 'claude-4', 'claude-5', 'claude-6'
+];
+
+const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+const servers = claudeJson.mcpServers || {};
+
+const tasks = [];
+const seenKeys = new Set();
+
+for (const agent of KNOWN_AGENTS) {
+  const cfg = servers[agent];
+  if (!cfg) {
+    tasks.push({ agent, type: 'not_configured' });
+    continue;
+  }
+  const cmd = cfg.command;
+  const args = cfg.args || [];
+
+  if (cmd === 'npx' || cmd === 'npm') {
+    const pkg = args[args.length - 1];
+    const key = 'npm:' + pkg;
+    if (seenKeys.has(key)) {
+      tasks.push({ agent, type: 'npm', package: pkg, deduplicated: true });
+    } else {
+      seenKeys.add(key);
+      tasks.push({ agent, type: 'npm', package: pkg, deduplicated: false });
+    }
+  } else if (cmd === 'node' && args.length > 0) {
+    const repoDir = path.dirname(path.dirname(args[0]));
+    const key = 'local:' + repoDir;
+    if (seenKeys.has(key)) {
+      tasks.push({ agent, type: 'local', repoDir, deduplicated: true });
+    } else {
+      seenKeys.add(key);
+      tasks.push({ agent, type: 'local', repoDir, deduplicated: false });
+    }
+  } else {
+    tasks.push({ agent, type: 'unknown', command: cmd });
+  }
+}
+
+process.stdout.write(JSON.stringify(tasks) + '\n');
+"
+```
+
+**6b. For each task in the list, sequentially:**
+- If `deduplicated: true`: mark as `SKIPPED (shared repo already updated)` — do not run again
+- If `type: "npm"` and `deduplicated: false`: run `npm install -g <package>`
+- If `type: "local"` and `deduplicated: false`: run `cd <repoDir> && git pull && npm run build`
+- If `type: "not_configured"`: mark as `NOT CONFIGURED`
+- If `type: "unknown"`: mark as `UNKNOWN (manual update required)`
+
+**6c. Print per-agent status table:**
+```
+Update results:
+
+  codex-cli-1   npm install -g codex-mcp-server      ✓ UPDATED
+  gemini-cli-1  npm install -g @tuannvm/gemini-...   ✓ UPDATED
+  opencode-1    git pull + build in /code/opencode   ✓ UPDATED
+  copilot-1     git pull + build in /code/copilot    ✓ UPDATED
+  claude-1      git pull + build in /code/claude-m   ✓ UPDATED
+  claude-2      (shared repo with claude-1)          ⚡ SKIPPED
+  claude-3      (shared repo)                        ⚡ SKIPPED
+  claude-4      (shared repo)                        ⚡ SKIPPED
+  claude-5      (shared repo)                        ⚡ SKIPPED
+  claude-6      (shared repo)                        ⚡ SKIPPED
+
+To load new binaries, restart updated agents:
+  /qgsd:mcp-restart codex-cli-1
+  /qgsd:mcp-restart gemini-cli-1
+  /qgsd:mcp-restart opencode-1
+  (etc. — list only agents that were UPDATED, not SKIPPED)
+```
+
+</process>

package/commands/qgsd/new-milestone.md

@@ -0,0 +1,44 @@
+---
+name: qgsd:new-milestone
+description: Start a new milestone cycle — update PROJECT.md and route to requirements
+argument-hint: "[milestone name, e.g., 'v1.1 Notifications']"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - AskUserQuestion
+---
+<objective>
+Start a new milestone: questioning → research (optional) → requirements → roadmap.
+
+Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
+
+**Creates/Updates:**
+- `.planning/PROJECT.md` — updated with new milestone goals
+- `.planning/research/` — domain research (optional, NEW features only)
+- `.planning/REQUIREMENTS.md` — scoped requirements for this milestone
+- `.planning/ROADMAP.md` — phase structure (continues numbering)
+- `.planning/STATE.md` — reset for new milestone
+
+**After:** `/qgsd:plan-phase [N]` to start execution.
+</objective>
+
+<execution_context>
+@~/.claude/qgsd/workflows/new-milestone.md
+@~/.claude/qgsd/references/questioning.md
+@~/.claude/qgsd/references/ui-brand.md
+@~/.claude/qgsd/templates/project.md
+@~/.claude/qgsd/templates/requirements.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+Project and milestone context files are resolved inside the workflow (`init new-milestone`) and delegated via `<files_to_read>` blocks where subagents are used.
+</context>
+
+<process>
+Execute the new-milestone workflow from @~/.claude/qgsd/workflows/new-milestone.md end-to-end.
+Preserve all workflow gates (validation, questioning, research, requirements, roadmap approval, commits).
+</process>

package/commands/qgsd/new-project.md

@@ -0,0 +1,42 @@
+---
+name: qgsd:new-project
+description: Initialize a new project with deep context gathering and PROJECT.md
+argument-hint: "[--auto]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Task
+  - AskUserQuestion
+---
+<context>
+**Flags:**
+- `--auto` — Automatic mode. After config questions, runs research → requirements → roadmap without further interaction. Expects idea document via @ reference.
+</context>
+
+<objective>
+Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.
+
+**Creates:**
+- `.planning/PROJECT.md` — project context
+- `.planning/config.json` — workflow preferences
+- `.planning/research/` — domain research (optional)
+- `.planning/REQUIREMENTS.md` — scoped requirements
+- `.planning/ROADMAP.md` — phase structure
+- `.planning/STATE.md` — project memory
+
+**After this command:** Run `/qgsd:plan-phase 1` to start execution.
+</objective>
+
+<execution_context>
+@~/.claude/qgsd/workflows/new-project.md
+@~/.claude/qgsd/references/questioning.md
+@~/.claude/qgsd/references/ui-brand.md
+@~/.claude/qgsd/templates/project.md
+@~/.claude/qgsd/templates/requirements.md
+</execution_context>
+
+<process>
+Execute the new-project workflow from @~/.claude/qgsd/workflows/new-project.md end-to-end.
+Preserve all workflow gates (validation, approvals, commits, routing).
+</process>