@bhargavvc/sdd-cc 1.30.1 → 1.42.3

package/sdd/workflows/settings-integrations.md

@@ -0,0 +1,281 @@
+<purpose>
+Interactive configuration of third-party integrations for SDD — search API keys
+(Brave / Firecrawl / Exa), code-review CLI routing (`review.models.<cli>`), and
+agent-skill injection (`agent_skills.<agent-type>`). Writes to
+`.planning/config.json` via `sdd-sdk`/`sdd-tools` so unrelated keys are
+preserved, never clobbered.
+
+This command is deliberately separate from `/sdd:settings` (workflow toggles)
+and any `/sdd-settings-advanced` tuning surface. It exists because API keys and
+cross-tool routing are *connectivity* concerns, not workflow or tuning knobs.
+</purpose>
+
+<security>
+**API keys are secrets.** They are written as plaintext to
+`.planning/config.json` — that is where secrets live on disk, and file
+permissions are the security boundary. The UI must never display, echo, or
+log the plaintext value. The workflow follows these rules:
+
+- **Masking convention: `****<last-4>`** (e.g. `sk-abc123def456` → `****f456`).
+  Strings shorter than 8 characters render as `****` with no tail so a short
+  secret does not leak a meaningful fraction of its bytes. Unset values render
+  as `(unset)`.
+- **Plaintext is never echoed by AskUserQuestion descriptions, confirmation
+  tables, or any log line.** It is not written to any file under `.planning/`
+  other than `config.json` itself.
+- **`config-set` output is masked** for keys in the secret set
+  (`brave_search`, `firecrawl`, `exa_search`) — see
+  `sdd/bin/lib/secrets.cjs`.
+- **Agent-type and CLI slug validation.** `agent_skills.<agent-type>` and
+  `review.models.<cli>` keys are matched against `^[a-zA-Z0-9_-]+$`. Inputs
+  containing path separators (`/`, `\`, `..`), whitespace, or shell
+  metacharacters are rejected. This closes off skill-injection attacks.
+</security>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="ensure_and_load_config">
+Ensure config exists and resolve the active config path (flat vs workstream, #2282):
+
+```bash
+sdd-sdk query config-ensure-section
+if [[ -z "${SDD_CONFIG_PATH:-}" ]]; then
+  if [[ -f .planning/active-workstream ]]; then
+    WS=$(tr -d '\n\r' < .planning/active-workstream)
+    SDD_CONFIG_PATH=".planning/workstreams/${WS}/config.json"
+  else
+    SDD_CONFIG_PATH=".planning/config.json"
+  fi
+fi
+```
+
+Store `$SDD_CONFIG_PATH`. Every subsequent read/write uses it.
+</step>
+
+<step name="read_current">
+Read the current config and compute a masked view for display. For each
+integration field, compute one of:
+
+- `(unset)` — field is null / missing
+- `****<last-4>` — secret field that is populated (plaintext never shown)
+- `<value>` — non-secret routing/skill string, shown as-is
+
+```bash
+BRAVE=$(sdd-sdk query config-get brave_search --default null)
+FIRECRAWL=$(sdd-sdk query config-get firecrawl --default null)
+EXA=$(sdd-sdk query config-get exa_search --default null)
+SEARCH_GITIGNORED=$(sdd-sdk query config-get search_gitignored --default false)
+```
+
+For each secret key (`brave_search`, `firecrawl`, `exa_search`) the displayed
+value is `****<last-4>` when set, never the raw string. Never echo the
+plaintext to stdout, stderr, or any log.
+</step>
+
+<step name="section_1_search_integrations">
+
+**Text mode (`workflow.text_mode: true` or `--text` flag):** Set
+`TEXT_MODE=true` and replace every `AskUserQuestion` call with a plain-text
+numbered list. Required for non-Claude runtimes.
+
+Ask the user what they want to do for each search API key. For keys that are
+already set, show `**** already set` and offer Leave / Replace / Clear. For
+unset keys, offer Skip / Set.
+
+```text
+AskUserQuestion([
+  {
+    question: "Brave Search API key — used for web research during plan/discuss phases",
+    header: "Brave",
+    multiSelect: false,
+    options: [
+      // When already set:
+      { label: "Leave (**** already set)", description: "Keep current value" },
+      { label: "Replace", description: "Enter a new API key" },
+      { label: "Clear", description: "Remove the stored key" }
+      // When unset:
+      // { label: "Skip", description: "Leave unset" },
+      // { label: "Set", description: "Enter an API key" }
+    ]
+  },
+  {
+    question: "Firecrawl API key — used for deep-crawl scraping",
+    header: "Firecrawl",
+    multiSelect: false,
+    options: [ /* same Leave/Replace/Clear or Skip/Set */ ]
+  },
+  {
+    question: "Exa Search API key — used for semantic search",
+    header: "Exa",
+    multiSelect: false,
+    options: [ /* same Leave/Replace/Clear or Skip/Set */ ]
+  },
+  {
+    question: "Include gitignored files in local code searches?",
+    header: "Gitignored",
+    multiSelect: false,
+    options: [
+      { label: "No (Recommended)", description: "Respect .gitignore. Safer — excludes secrets, node_modules, build artifacts." },
+      { label: "Yes", description: "Include gitignored files. Useful when secrets/artifacts genuinely contain searchable intent." }
+    ]
+  }
+])
+```
+
+For each "Set" or "Replace", follow with a text-input prompt that asks for the
+key value. **The answer must not be echoed back** in subsequent question
+descriptions or confirmation text. Write the value via:
+
+```bash
+sdd-sdk query config-set brave_search "<value>"     # masked in output
+sdd-sdk query config-set firecrawl "<value>"        # masked in output
+sdd-sdk query config-set exa_search "<value>"       # masked in output
+sdd-sdk query config-set search_gitignored true|false
+```
+
+For "Clear", write `null`:
+
+```bash
+sdd-sdk query config-set brave_search null
+```
+</step>
+
+<step name="section_2_review_models">
+
+`review.models.<cli>` is a map that tells the code-review workflow which
+shell command to invoke for a given reviewer flavor. Supported flavors:
+`claude`, `codex`, `gemini`, `opencode`.
+
+```text
+AskUserQuestion([
+  {
+    question: "Which reviewer CLI do you want to configure?",
+    header: "CLI",
+    multiSelect: false,
+    options: [
+      { label: "Claude", description: "review.models.claude — defaults to session model when unset" },
+      { label: "Codex", description: "review.models.codex — e.g. 'codex exec --model gpt-5'" },
+      { label: "Gemini", description: "review.models.gemini — e.g. 'gemini -m gemini-2.5-pro'" },
+      { label: "OpenCode", description: "review.models.opencode — e.g. 'opencode run --model claude-sonnet-4'" },
+      { label: "Done", description: "Skip — finish this section" }
+    ]
+  }
+])
+```
+
+For the selected CLI, show the current value (or `(unset)`) and offer
+Leave / Replace / Clear, followed by a text-input prompt for the new command
+string. Write via:
+
+```bash
+sdd-sdk query config-set review.models.<cli> "<command string>"
+```
+
+Loop until the user selects "Done".
+
+The `review.models.<cli>` key is validated by the dynamic pattern
+`^review\.models\.[a-zA-Z0-9_-]+$`. Empty CLI slugs and path-containing slugs
+are rejected by `config-set` before any write.
+</step>
+
+<step name="section_3_agent_skills">
+
+`agent_skills.<agent-type>` injects extra skill names into an agent's spawn
+frontmatter. The slug is user-extensible, so input is free-text validated
+against `^[a-zA-Z0-9_-]+$`. Inputs with path separators, spaces, or shell
+metacharacters are rejected.
+
+```text
+AskUserQuestion([
+  {
+    question: "Configure agent_skills for which agent type?",
+    header: "Agent Type",
+    multiSelect: false,
+    options: [
+      { label: "sdd-executor", description: "Skills injected when spawning executor agents" },
+      { label: "sdd-planner", description: "Skills injected when spawning planner agents" },
+      { label: "sdd-verifier", description: "Skills injected when spawning verifier agents" },
+      { label: "Custom…", description: "Enter a custom agent-type slug" },
+      { label: "Done", description: "Skip — finish this section" }
+    ]
+  }
+])
+```
+
+For "Custom…", prompt for a slug and validate it matches
+`^[a-zA-Z0-9_-]+$`. If it fails validation, print:
+
+```text
+Rejected: agent-type '<slug>' must match [a-zA-Z0-9_-]+ (no path separators,
+spaces, or shell metacharacters).
+```
+
+and re-prompt.
+
+For a selected slug, prompt for the comma-separated skill list (text input).
+Show the current value if any, offer Leave / Replace / Clear. Write via:
+
+```bash
+sdd-sdk query config-set agent_skills.<slug> "<skill-a,skill-b,skill-c>"
+```
+
+Loop until "Done".
+</step>
+
+<step name="confirm">
+Display the masked confirmation table. **No plaintext API keys appear in this
+output under any circumstance.**
+
+```text
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ SDD ► INTEGRATIONS UPDATED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Search Integrations
+| Field              | Value             |
+|--------------------|-------------------|
+| brave_search       | ****<last-4>      |  (or "(unset)")
+| firecrawl          | ****<last-4>      |
+| exa_search         | ****<last-4>      |
+| search_gitignored  | true | false      |
+
+Code Review CLI Routing
+| CLI         | Command                              |
+|-------------|--------------------------------------|
+| claude      | <value or (session model default)>   |
+| codex       | <value or (unset)>                   |
+| gemini      | <value or (unset)>                   |
+| opencode    | <value or (unset)>                   |
+
+Agent Skills Injection
+| Agent Type       | Skills                    |
+|------------------|---------------------------|
+| <slug>           | <skill-a, skill-b>        |
+| ...              | ...                       |
+
+Notes:
+- API keys are stored plaintext in .planning/config.json. The confirmation
+  table above never displays plaintext — keys appear as ****<last-4>.
+- Plaintext is not echoed back by this workflow, not written to any log,
+  and not displayed in error messages.
+
+Quick commands:
+- /sdd:settings — workflow toggles and model profile
+- /sdd-set-profile <profile> — switch model profile
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Current config read from `$SDD_CONFIG_PATH`
+- [ ] User presented with three sections: Search Integrations, Review CLI Routing, Agent Skills Injection
+- [ ] API keys written plaintext only to `config.json`; never echoed, never logged, never displayed
+- [ ] Masked confirmation table uses `****<last-4>` for set keys and `(unset)` for null
+- [ ] `review.models.<cli>` and `agent_skills.<agent-type>` keys validated against `[a-zA-Z0-9_-]+` before write
+- [ ] Config merge preserves all keys outside the three sections this workflow owns
+</success_criteria>

package/sdd/workflows/settings.md

@@ -12,17 +12,27 @@ Read all files referenced by the invoking prompt's execution_context before star
 Ensure config exists and load current state:
 
 ```bash
-node "$HOME/.claude/sdd/bin/sdd-tools.cjs" config-ensure-section
-INIT=$(node "$HOME/.claude/sdd/bin/sdd-tools.cjs" state load)
+sdd-sdk query config-ensure-section
+INIT=$(sdd-sdk query state.load)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+# `state.load` returns STATE frontmatter JSON from the SDK — it does not include `config_path`. Orchestrators may set `SDD_CONFIG_PATH` from init phase-op JSON; otherwise resolve the same path sdd-tools uses for flat vs active workstream (#2282).
+if [[ -z "${SDD_CONFIG_PATH:-}" ]]; then
+  if [[ -f .planning/active-workstream ]]; then
+    WS=$(tr -d '\n\r' < .planning/active-workstream)
+    SDD_CONFIG_PATH=".planning/workstreams/${WS}/config.json"
+  else
+    SDD_CONFIG_PATH=".planning/config.json"
+  fi
+fi
 ```
 
-Creates `.planning/config.json` with defaults if missing and loads current config values.
+Creates `config.json` (at the resolved path) with defaults if missing. `INIT` still holds `state.load` output for any step that needs STATE fields.
+Store `$SDD_CONFIG_PATH` — all subsequent reads and writes use this path, not a hardcoded `.planning/config.json`, so active-workstream installs target the correct file (#2282).
 </step>
 
 <step name="read_current">
 ```bash
-cat .planning/config.json
+cat "$SDD_CONFIG_PATH"
 ```
 
 Parse current values (default to `true` if not present):
@@ -30,14 +40,65 @@ Parse current values (default to `true` if not present):
 - `workflow.plan_check` — spawn plan checker during plan-phase
 - `workflow.verifier` — spawn verifier during execute-phase
 - `workflow.nyquist_validation` — validation architecture research during plan-phase (default: true if absent)
+- `workflow.pattern_mapper` — run sdd-pattern-mapper between research and planning (default: true if absent)
 - `workflow.ui_phase` — generate UI-SPEC.md design contracts for frontend phases (default: true if absent)
 - `workflow.ui_safety_gate` — prompt to run /sdd:ui-phase before planning frontend phases (default: true if absent)
+- `workflow.ai_integration_phase` — framework selection + eval strategy for AI phases (default: true if absent)
+- `workflow.tdd_mode` — enforce RED/GREEN/REFACTOR gate sequence during execute-phase (default: false if absent)
+- `workflow.code_review` — enable /sdd:code-review and /sdd:code-review --fix commands (default: true if absent)
+- `workflow.code_review_depth` — default depth for /sdd:code-review: `quick`, `standard`, or `deep` (default: `"standard"` if absent; only relevant when `code_review` is on)
+- `workflow.ui_review` — run visual quality audit (/sdd:ui-review) in autonomous mode (default: true if absent)
+- `commit_docs` — whether `.planning/` files are committed to git (default: true if absent)
+- `intel.enabled` — enable queryable codebase intelligence (/sdd:map-codebase --query) (default: false if absent)
+- `graphify.enabled` — enable project knowledge graph (/sdd:graphify) (default: false if absent)
 - `model_profile` — which model each agent uses (default: `balanced`)
 - `git.branching_strategy` — branching approach (default: `"none"`)
+- `workflow.use_worktrees` — whether parallel executor agents run in worktree isolation (default: `true`)
 </step>
 
 <step name="present_settings">
-Use AskUserQuestion with current values pre-selected:
+
+**Text mode (`workflow.text_mode: true` in config or `--text` flag):** Set `TEXT_MODE=true` if `--text` is present in `$ARGUMENTS` OR `text_mode` from init JSON is `true`. When TEXT_MODE is active, replace every `AskUserQuestion` call with a plain-text numbered list and ask the user to type their choice number. This is required for non-Claude runtimes (OpenAI Codex, Gemini CLI, etc.) where `AskUserQuestion` is not available.
+
+**Non-Claude runtime note:** If `TEXT_MODE` is active (i.e. the runtime is non-Claude), prepend the following notice before the model profile question:
+
+```
+Note: Quality, Balanced, Budget, and Adaptive profiles assign semantic tiers
+(Opus/Sonnet/Haiku) to each agent. When `runtime` is set in .planning/config.json,
+tiers resolve to runtime-native model IDs — on Codex that's gpt-5.4 / gpt-5.3-codex /
+gpt-5.4-mini with appropriate reasoning effort. See "Runtime-Aware Profiles" in
+docs/CONFIGURATION.md.
+
+If `runtime` is unset on a non-Claude runtime, the profile tiers have no effect on
+actual model selection — agents use the runtime's default model. Choose "Inherit" to
+force session-model behavior, set `runtime` + a profile to get tiered models, or
+configure `model_overrides` manually in .planning/config.json to target specific
+models per agent.
+```
+
+Use AskUserQuestion with current values pre-selected. Questions are grouped into six visual sections; the first question in each section carries the section-denoting `header` field (AskUserQuestion renders abbreviated section tags for grouping, max 12 chars).
+
+Section layout:
+
+### Planning
+Research, Plan Checker, Pattern Mapper, Nyquist, UI Phase, UI Gate, AI Phase
+
+### Execution
+Verifier, TDD Mode, Code Review, Code Review Depth _(conditional — only when code_review=on)_, UI Review
+
+### Docs & Output
+Commit Docs, Skip Discuss, Worktrees
+
+### Features
+Intel, Graphify
+
+### Model & Pipeline
+Model Profile, Auto-Advance, Branching
+
+### Misc
+Context Warnings, Research Qs
+
+**Conditional visibility — code_review_depth:** This question is shown only when the user's chosen `code_review` value (after they answer that question, or the pre-selected value if unchanged) is on. If `code_review` is off, omit the `code_review_depth` question from the AskUserQuestion block and preserve the existing `workflow.code_review_depth` value in config (do not overwrite). Implementation: ask the Model + Planning + Execution-up-to-Code-Review questions first; if `code_review=on`, include `code_review_depth` in the same batch; otherwise skip it. Conceptually this is a one-branch split on the `code_review` answer.
 
 ```
 AskUserQuestion([
@@ -46,10 +107,10 @@ AskUserQuestion([
     header: "Model",
     multiSelect: false,
     options: [
-      { label: "Quality", description: "Opus everywhere except verification (highest cost)" },
-      { label: "Balanced (Recommended)", description: "Opus for planning, Sonnet for research/execution/verification" },
-      { label: "Budget", description: "Sonnet for writing, Haiku for research/verification (lowest cost)" },
-      { label: "Inherit", description: "Use current session model for all agents (best for OpenRouter, local models, or runtime model switching)" }
+      { label: "Quality", description: "Opus everywhere except verification (highest cost) — Claude only" },
+      { label: "Balanced (Recommended)", description: "Opus for planning, Sonnet for research/execution/verification — Claude only" },
+      { label: "Budget", description: "Sonnet for writing, Haiku for research/verification (lowest cost) — Claude only" },
+      { label: "Inherit", description: "Use current session model for all agents (required for non-Claude runtimes: Codex, Gemini CLI, OpenRouter, local models)" }
     ]
   },
   {
@@ -79,13 +140,62 @@ AskUserQuestion([
       { label: "No", description: "Skip post-execution verification" }
     ]
   },
+  {
+    question: "Enable TDD Mode? (RED/GREEN/REFACTOR gates for eligible tasks)",
+    header: "TDD",
+    multiSelect: false,
+    options: [
+      { label: "No (Recommended)", description: "Execute tasks normally. Tests written alongside implementation." },
+      { label: "Yes", description: "Planner applies type:tdd to business logic/APIs/validations; executor enforces gate sequence. End-of-phase review checks compliance." }
+    ]
+  },
+  {
+    question: "Enable Code Review? (/sdd:code-review and /sdd:code-review --fix commands)",
+    header: "Code Review",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Enable /sdd:code-review commands for reviewing source files changed during a phase." },
+      { label: "No", description: "Commands exit with a configuration gate message. Use when code review is handled externally." }
+    ]
+  },
+  // Conditional: include the following code_review_depth question ONLY when the user's
+  // chosen code_review value is "Yes". If code_review is "No", omit this question from
+  // the AskUserQuestion call and do not touch the existing workflow.code_review_depth value.
+  {
+    question: "Code Review Depth? (default depth for /sdd:code-review — override per-run with --depth=)",
+    header: "Review Depth",
+    multiSelect: false,
+    options: [
+      { label: "Standard (Recommended)", description: "Per-file analysis. Balanced cost and signal." },
+      { label: "Quick", description: "Pattern-matching only. Fastest, lowest cost." },
+      { label: "Deep", description: "Cross-file analysis with import graphs. Highest cost, highest signal." }
+    ]
+  },
+  {
+    question: "Enable UI Review? (visual quality audit via /sdd:ui-review in autonomous mode)",
+    header: "UI Review",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Run visual quality audit after phase execution in autonomous mode." },
+      { label: "No", description: "Skip the UI audit step. Good for backend-only projects." }
+    ]
+  },
   {
     question: "Auto-advance pipeline? (discuss → plan → execute automatically)",
     header: "Auto",
     multiSelect: false,
     options: [
       { label: "No (Recommended)", description: "Manual /clear + paste between stages" },
-      { label: "Yes", description: "Chain stages via Task() subagents (same isolation)" }
+      { label: "Yes", description: "Chain stages via Agent() subagents (same isolation)" }
+    ]
+  },
+  {
+    question: "Run Pattern Mapper? (maps new files to existing codebase analogs between research and planning)",
+    header: "Pattern Mapper",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "sdd-pattern-mapper runs between research and plan steps. Surfaces conventions so new code follows house style." },
+      { label: "No", description: "Skip pattern mapping. Faster; lose consistency hinting for new files." }
     ]
   },
   {
@@ -117,6 +227,15 @@ AskUserQuestion([
       { label: "No", description: "No prompt — plan-phase proceeds without UI-SPEC check." }
     ]
   },
+  {
+    question: "Enable AI Phase? (framework selection + eval strategy for AI phases)",
+    header: "AI Phase",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Run /sdd:ai-integration-phase before planning AI system phases. Surfaces the right framework, researches its docs, and designs the evaluation strategy." },
+      { label: "No", description: "Skip AI design contract. Good for non-AI phases or when framework is already decided." }
+    ]
+  },
   {
     question: "Git branching strategy?",
     header: "Branching",
@@ -127,6 +246,15 @@ AskUserQuestion([
       { label: "Per Milestone", description: "Create branch for entire milestone (sdd/{version}-{name})" }
     ]
   },
+  {
+    question: "Create git tags on milestone completion?",
+    header: "Git Tagging",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Tag releases with version (e.g., v1.0) on milestone completion" },
+      { label: "No", description: "Skip git tagging — use if your project doesn't use tags or uses a different release convention" }
+    ]
+  },
   {
     question: "Enable context window warnings? (injects advisory messages when context is getting full)",
     header: "Ctx Warnings",
@@ -145,6 +273,15 @@ AskUserQuestion([
       { label: "Yes", description: "Search web for best practices before each question group. More informed questions but uses more tokens." }
     ]
   },
+  {
+    question: "Commit .planning/ files to git? (controls whether plans/artifacts are tracked in your repo)",
+    header: "Commit Docs",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Commit .planning/ to git. Plans, research, and phase artifacts travel with the repo." },
+      { label: "No", description: "Do not commit .planning/. Keep planning local only. Automatic when .planning/ is in .gitignore." }
+    ]
+  },
   {
     question: "Skip discuss-phase in autonomous mode? (use ROADMAP phase goals as spec)",
     header: "Skip Discuss",
@@ -153,6 +290,33 @@ AskUserQuestion([
       { label: "No (Recommended)", description: "Run smart discuss before each phase — surfaces gray areas and captures decisions." },
       { label: "Yes", description: "Skip discuss in /sdd:autonomous — chain directly to plan. Best for backend/pipeline work where phase descriptions are the spec." }
     ]
+  },
+  {
+    question: "Use git worktrees for parallel agent isolation?",
+    header: "Worktrees",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Each parallel executor runs in its own worktree branch — no conflicts between agents." },
+      { label: "No", description: "Disable worktree isolation. Agents run sequentially on the main working tree. Use if EnterWorktree creates branches from wrong base (known cross-platform issue)." }
+    ]
+  },
+  {
+    question: "Enable Intel? (queryable codebase intelligence via /sdd:map-codebase --query — builds a JSON index in .planning/intel/)",
+    header: "Intel",
+    multiSelect: false,
+    options: [
+      { label: "No (Recommended)", description: "Skip intel indexing. Use when codebase is small or intel queries are not needed." },
+      { label: "Yes", description: "Enable /sdd:map-codebase --query commands. Builds and queries a JSON index of the codebase." }
+    ]
+  },
+  {
+    question: "Enable Graphify? (project knowledge graph via /sdd:graphify — builds a graph in .planning/graphs/)",
+    header: "Graphify",
+    multiSelect: false,
+    options: [
+      { label: "No (Recommended)", description: "Skip knowledge graph. Use when dependency graphs are not needed." },
+      { label: "Yes", description: "Enable /sdd:graphify commands. Builds and queries a project knowledge graph." }
+    ]
   }
 ])
 ```
@@ -164,23 +328,38 @@ Merge new settings into existing config.json:
 ```json
 {
   ...existing_config,
-  "model_profile": "quality" | "balanced" | "budget" | "inherit",
+  "model_profile": "quality" | "balanced" | "budget" | "adaptive" | "inherit",
+  "commit_docs": true/false,
   "workflow": {
     "research": true/false,
     "plan_check": true/false,
     "verifier": true/false,
     "auto_advance": true/false,
     "nyquist_validation": true/false,
+    "pattern_mapper": true/false,
     "ui_phase": true/false,
     "ui_safety_gate": true/false,
+    "ai_integration_phase": true/false,
+    "tdd_mode": true/false,
+    "code_review": true/false,
+    "code_review_depth": "quick" | "standard" | "deep",
+    "ui_review": true/false,
     "text_mode": true/false,
     "research_before_questions": true/false,
     "discuss_mode": "discuss" | "assumptions",
-    "skip_discuss": true/false
+    "skip_discuss": true/false,
+    "use_worktrees": true/false
+  },
+  "intel": {
+    "enabled": true/false
+  },
+  "graphify": {
+    "enabled": true/false
   },
   "git": {
     "branching_strategy": "none" | "phase" | "milestone",
-    "quick_branch_template": <string|null>
+    "quick_branch_template": <string|null>,
+    "create_tag": true/false
   },
   "hooks": {
     "context_warnings": true/false,
@@ -189,7 +368,9 @@ Merge new settings into existing config.json:
 }
 ```
 
-Write updated config to `.planning/config.json`.
+**Safe merge:** Apply each chosen value via `sdd-sdk query config-set <key.path> <value>` so unrelated keys are never clobbered. `code_review_depth` is written only if the code_review question was answered `on`; otherwise leave the existing value in place.
+
+Write updated config to `$SDD_CONFIG_PATH` (the workstream-aware path resolved in `ensure_and_load_config`). Never hardcode `.planning/config.json` — workstream installs route to `.planning/workstreams/<slug>/config.json`.
 </step>
 
 <step name="save_as_defaults">
@@ -231,9 +412,21 @@ Write `~/.sdd/defaults.json` with:
     "verifier": <current>,
     "auto_advance": <current>,
     "nyquist_validation": <current>,
+    "pattern_mapper": <current>,
     "ui_phase": <current>,
     "ui_safety_gate": <current>,
+    "ai_integration_phase": <current>,
+    "tdd_mode": <current>,
+    "code_review": <current>,
+    "code_review_depth": <current>,
+    "ui_review": <current>,
     "skip_discuss": <current>
+  },
+  "intel": {
+    "enabled": <current>
+  },
+  "graphify": {
+    "enabled": <current>
   }
 }
 ```
@@ -252,12 +445,22 @@ Display:
 | Model Profile        | {quality/balanced/budget/inherit} |
 | Plan Researcher      | {On/Off} |
 | Plan Checker         | {On/Off} |
+| Pattern Mapper       | {On/Off} |
 | Execution Verifier   | {On/Off} |
+| TDD Mode             | {On/Off} |
+| Code Review          | {On/Off} |
+| Code Review Depth    | {quick/standard/deep} |
+| UI Review            | {On/Off} |
+| Commit Docs          | {On/Off} |
+| Intel                | {On/Off} |
+| Graphify             | {On/Off} |
 | Auto-Advance         | {On/Off} |
 | Nyquist Validation   | {On/Off} |
 | UI Phase             | {On/Off} |
 | UI Safety Gate       | {On/Off} |
+| AI Integration Phase | {On/Off} |
 | Git Branching        | {None/Per Phase/Per Milestone} |
+| Git Tagging          | {On/Off} |
 | Skip Discuss         | {On/Off} |
 | Context Warnings     | {On/Off} |
 | Saved as Defaults    | {Yes/No} |
@@ -265,10 +468,12 @@ Display:
 These settings apply to future /sdd:plan-phase and /sdd:execute-phase runs.
 
 Quick commands:
-- /sdd:set-profile <profile> — switch model profile
+- /sdd:config --integrations — configure API keys (Brave/Firecrawl/Exa), review.models CLI routing, and agent_skills injection
+- /sdd:config --profile <profile> — switch model profile
 - /sdd:plan-phase --research — force research
 - /sdd:plan-phase --skip-research — skip research
 - /sdd:plan-phase --skip-verify — skip plan check
+- /sdd:config --advanced — power-user tuning (plan bounce, timeouts, branch templates, cross-AI, context window)
 ```
 </step>
 
@@ -276,7 +481,7 @@ Quick commands:
 
 <success_criteria>
 - [ ] Current config read
-- [ ] User presented with 10 settings (profile + 8 workflow toggles + git branching)
+- [ ] User presented with 23 settings (profile + workflow toggles + features + git branching + git tagging + ctx warnings), grouped into six sections: Planning, Execution, Docs & Output, Features, Model & Pipeline, Misc. `code_review_depth` is conditional on `code_review=on`.
 - [ ] Config updated with model_profile, workflow, and git sections
 - [ ] User offered to save as global defaults (~/.sdd/defaults.json)
 - [ ] Changes confirmed to user