@hegemonart/get-design-done 1.30.0 → 1.30.6

package/bin/gdd-graph

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+// bin/gdd-graph — Plan 30.6-02 Task 3
+//
+// Native CLI replacing every `gsd-tools.cjs graphify *` dispatch in our
+// tree. This bin is a thin CJS dispatcher that dynamic-imports the ESM
+// handler modules (package.json has no "type":"module", so the no-ext
+// bin file is resolved as CJS by Node — we bridge with `await import()`).
+//
+// Subcommands shipped in 30.6-02:
+//   build         — read .design/intel/graph.json, write .design/graph/graph.json
+//   status        — report graph file state (configured/exists/counts/stale)
+//   diff <a> <b>  — emit added/removed/changed nodes + edges
+//
+// Subcommands shipped in 30.6-03 (this plan):
+//   query <term> [--budget N]   — search graph, return ranked matches +
+//                                 1-hop neighbors, budget-truncated per D-04
+//   upsert-node --json '<json>' — create/update a node by id (idempotent)
+//   upsert-edge --json '<json>' — create/update an edge by (from,to,kind);
+//                                 fails if either endpoint node is absent
+
+'use strict';
+
+const path = require('node:path');
+
+const SUBCOMMANDS = new Set([
+  'build', 'status', 'diff', 'query', 'upsert-node', 'upsert-edge',
+]);
+
+function printUsage(stream) {
+  stream.write([
+    'Usage: gdd-graph <subcommand> [options]',
+    '',
+    'Subcommands:',
+    '  build  [--intel <path>] [--out <path>] [--now <iso>]',
+    '         Build .design/graph/graph.json from .design/intel/graph.json.',
+    '  status [--graph <path>] [--intel <path>] [--format json|text]',
+    '         Report graph store state (configured/exists/counts/stale).',
+    '  diff   <from> <to> [--format json|text]',
+    '         Diff two graph.json files; emit added/removed/changed nodes+edges.',
+    '  query  <term> [--budget N] [--graph <path>]',
+    '         Search graph; return ranked matches + 1-hop neighbors,',
+    '         budget-truncated per D-04 (chars/4 heuristic, default 8000).',
+    '  upsert-node {--json \'<obj>\' | --id <id> --type <type> [--label <l>] [--source <s>] [--attrs <json>]}',
+    '         Idempotent node upsert by id; bootstraps graph file if absent.',
+    '  upsert-edge {--json \'<obj>\' | --from <id> --to <id> --kind <kind> [--weight N] [--source <s>] [--attrs <json>]}',
+    '         Idempotent edge upsert by (from,to,kind); requires both endpoint',
+    '         nodes to exist — emits GDD_GRAPH_MISSING_ENDPOINT otherwise.',
+    '',
+    'Env:',
+    '  GDD_GRAPH_DEBUG=1            include stack traces in error JSON',
+    '  GDD_GRAPH_TOKEN_FACTOR <int>  override chars-per-token divisor (D-04)',
+    '',
+    'Exit codes:',
+    '  0 success / 1 failure (structured-error JSON on stderr)',
+    '',
+  ].join('\n'));
+}
+
+function parseArgs(rest) {
+  // Minimal hand-rolled parser. Positional args land in `_`; flags with
+  // `--name value` (and `--name=value`) land in `opts`.
+  const opts = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === '--' ) { positional.push(...rest.slice(i + 1)); break; }
+    if (arg.startsWith('--')) {
+      const eq = arg.indexOf('=');
+      if (eq !== -1) {
+        opts[arg.slice(2, eq)] = arg.slice(eq + 1);
+      } else {
+        const next = rest[i + 1];
+        if (next === undefined || next.startsWith('--')) {
+          opts[arg.slice(2)] = true;
+        } else {
+          opts[arg.slice(2)] = next;
+          i++;
+        }
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { _: positional, opts };
+}
+
+function emitError(subcommand, err, exitCode = 1) {
+  const payload = {
+    ok: false,
+    subcommand,
+    message: err && err.message ? err.message : String(err),
+  };
+  if (err && err.code) payload.code = err.code;
+  if (err && err.schemaErrors) payload.schemaErrors = err.schemaErrors;
+  if (err && err.missingEndpoints) payload.missingEndpoints = err.missingEndpoints;
+  if (process.env.GDD_GRAPH_DEBUG && err && err.stack) payload.stack = err.stack;
+  process.stderr.write(JSON.stringify(payload) + '\n');
+  process.exit(exitCode);
+}
+
+async function dispatch(subcommand, parsed) {
+  const lib = await import(
+    // Resolve via relative require root — bin/ is sibling of scripts/.
+    'file://' + path.resolve(__dirname, '..', 'scripts', 'lib', 'graph', 'index.mjs').replace(/\\/g, '/')
+  );
+
+  if (subcommand === 'build') {
+    const r = lib.buildGraph({
+      intelPath: parsed.opts.intel,
+      outPath: parsed.opts.out,
+      now: parsed.opts.now,
+    });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+
+  if (subcommand === 'status') {
+    const r = lib.statusGraph({
+      graphPath: parsed.opts.graph,
+      intelPath: parsed.opts.intel,
+    });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+
+  if (subcommand === 'diff') {
+    const [fromPath, toPath] = parsed._;
+    if (!fromPath || !toPath) {
+      const err = new Error('diff requires two positional args: <from> <to>');
+      err.code = 'DIFF_ARGS_MISSING';
+      throw err;
+    }
+    const r = lib.diffGraph({ fromPath, toPath });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+
+  if (subcommand === 'query') {
+    const [term] = parsed._;
+    if (!term) {
+      const err = new Error('query requires a positional argument: <term>');
+      err.code = 'QUERY_TERM_MISSING';
+      throw err;
+    }
+    const budget = parsed.opts.budget !== undefined
+      ? Number.parseInt(parsed.opts.budget, 10)
+      : undefined;
+    if (parsed.opts.budget !== undefined && !Number.isFinite(budget)) {
+      const err = new Error(`query --budget must be an integer (got: ${parsed.opts.budget})`);
+      err.code = 'QUERY_BUDGET_INVALID';
+      throw err;
+    }
+    const r = lib.queryGraph({
+      graphPath: parsed.opts.graph,
+      query: term,
+      budget,
+    });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+
+  if (subcommand === 'upsert-node') {
+    const node = parseUpsertInput(parsed, 'upsert-node');
+    const r = lib.upsertNode({
+      graphPath: parsed.opts.graph,
+      node,
+    });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+
+  if (subcommand === 'upsert-edge') {
+    const edge = parseUpsertInput(parsed, 'upsert-edge');
+    const r = lib.upsertEdge({
+      graphPath: parsed.opts.graph,
+      edge,
+    });
+    process.stdout.write(JSON.stringify(r) + '\n');
+    return;
+  }
+}
+
+/**
+ * Parse the upsert payload from argv. Supports two shapes:
+ *  - `--json '<json-string>'` (preferred — single source of truth for batch
+ *    callers in agents/gdd-graph-refresh.md and skills/graphify)
+ *  - flat flags `--id ... --type ... --label ... --from ... --to ... --kind ...
+ *    --weight N --source ... --attrs '<json>'` (convenience for shell users
+ *    + matches the upstream gsd-tools.cjs graphify flag surface verbatim
+ *    per RESEARCH.md §8-callsite inventory)
+ *
+ * Conflict: `--json` wins when both are provided.
+ */
+function parseUpsertInput(parsed, subcommand) {
+  if (parsed.opts.json !== undefined) {
+    try {
+      const obj = JSON.parse(parsed.opts.json);
+      if (!obj || typeof obj !== 'object') {
+        throw new Error(`${subcommand} --json must decode to an object`);
+      }
+      return obj;
+    } catch (e) {
+      const err = new Error(`${subcommand} --json parse failed: ${e.message}`);
+      err.code = 'UPSERT_JSON_PARSE_FAILED';
+      throw err;
+    }
+  }
+  // Flat-flag mode — assemble from individual --field flags.
+  const obj = {};
+  for (const key of ['id', 'type', 'label', 'from', 'to', 'kind', 'source']) {
+    if (parsed.opts[key] !== undefined && parsed.opts[key] !== true) {
+      obj[key] = parsed.opts[key];
+    }
+  }
+  if (parsed.opts.weight !== undefined) {
+    const w = Number.parseFloat(parsed.opts.weight);
+    if (!Number.isFinite(w)) {
+      const err = new Error(`${subcommand} --weight must be a number (got: ${parsed.opts.weight})`);
+      err.code = 'UPSERT_WEIGHT_INVALID';
+      throw err;
+    }
+    obj.weight = w;
+  }
+  if (parsed.opts.attrs !== undefined) {
+    try {
+      obj.attrs = JSON.parse(parsed.opts.attrs);
+    } catch (e) {
+      const err = new Error(`${subcommand} --attrs parse failed: ${e.message}`);
+      err.code = 'UPSERT_ATTRS_PARSE_FAILED';
+      throw err;
+    }
+  }
+  return obj;
+}
+
+(async () => {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+    printUsage(process.stderr);
+    process.exit(argv.length === 0 ? 1 : 0);
+  }
+  const subcommand = argv[0];
+  if (!SUBCOMMANDS.has(subcommand)) {
+    process.stderr.write(JSON.stringify({
+      ok: false,
+      message: `unknown subcommand: ${subcommand}`,
+    }) + '\n');
+    process.exit(1);
+  }
+  const parsed = parseArgs(argv.slice(1));
+  try {
+    await dispatch(subcommand, parsed);
+    process.exit(0);
+  } catch (err) {
+    emitError(subcommand, err, 1);
+  }
+})().catch((err) => {
+  // Last-resort guard. dispatch() already routes via emitError; this only
+  // fires for bugs in argv parsing or the dispatch glue itself.
+  emitError('<bootstrap>', err, 1);
+});

package/connections/connections.md

@@ -185,15 +185,16 @@ Note: First Chromatic run has no baseline — all stories become new snapshots.
 **Graphify probe (execute at agent entry, before using graph):**
 
 ```
-Step G1 — Config check:
-  node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify status
-  → Error or { enabled: false }  → graphify: not_configured
-  → { enabled: true }            → proceed to Step G2
-
-Step G2 — Graph file check:
-  Check if graphify-out/graph.json exists in project root
-  → Absent    → graphify: unavailable  (graph not built yet)
-  → Present   → graphify: available
+Step G1 — Config check (per D-09 direct read, no CLI subcommand):
+  Bash: node -e "try{const c=JSON.parse(require('fs').readFileSync('.design/config.json','utf8'));process.stdout.write(String(c.graphify?.enabled===true))}catch{process.stdout.write('false')}"
+  → false → graphify: not_configured
+  → true  → proceed to Step G2
+
+Step G2 — Graph file check (native CLI):
+  Bash: node bin/gdd-graph status --format json
+  → { configured: true, exists: true }  → graphify: available
+  → { configured: true, exists: false } → graphify: unavailable  (graph not built yet)
+  → { configured: false, exists: ... }  → graphify: not_configured  (mirrors G1)
 
 Write graphify status to STATE.md <connections>.
 ```

package/connections/graphify.md

@@ -1,46 +1,43 @@
 # Graphify — Connection Specification
 
-This file is the connection specification for Graphify within the get-design-done pipeline. Graphify builds a queryable knowledge graph over the codebase — mapping component↔token↔decision relationships via Tree-sitter static analysis and LLM semantic extraction. See `connections/connections.md` for the full connection index and capability matrix.
+This file is the connection specification for **Graphify** within the get-design-done pipeline. Graphify builds a queryable knowledge graph over the codebase and design intel — mapping component↔token↔decision relationships from `.design/intel/` slices. See `connections/connections.md` for the full connection index and capability matrix.
+
+> **Native, no external dependency.** Phase 30.6 (v1.30.6) replaced the previous runtime dispatch to `~/.claude/get-shit-done/bin/gsd-tools.cjs graphify *` with a native CLI shipped in this repo at `bin/gdd-graph`. No Python, no separate install — just Node ≥22.
 
 ---
 
 ## Setup
 
 **Prerequisites:**
-- Python 3.9+ available on PATH
-- GSD framework with `graphify.enabled = true` in `.planning/config.json`
+- Node ≥22 (per `package.json` engines)
+- get-design-done installed (provides `bin/gdd-graph`)
 
-**Install:**
-```
-pip install graphifyy
-graphify install        # installs skill files into ~/.claude/skills/graphify/
-```
+**Enable in project config** (per D-09 — direct file edit, no CLI subcommand):
 
-**Enable in GSD config:**
-```
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" config-set graphify.enabled true
+Edit `.design/config.json` and set:
+```json
+{
+  "graphify": {
+    "enabled": true
+  }
+}
 ```
 
-**Build the graph (initial):**
-```
-graphify .              # run in project root; produces graphify-out/graph.json
-# or via GSD tools:
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify build
-```
+If `.design/config.json` does not exist, create it. Missing file = disabled.
 
-**Recommended: auto-rebuild after commits:**
+**Build the graph (initial):**
 ```
-graphify hook install
+node bin/gdd-graph build
 ```
+Produces `.design/graph/graph.json` (Ajv-validated against `scripts/lib/graph/schema.json`).
 
 **Verification:**
-After building, run:
 ```
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify status
+node bin/gdd-graph status --format json
 ```
-Expect: `{ enabled: true, graph_path: "...", node_count: N, edge_count: N, stale: false }`
+Expect: `{ configured: true, exists: true, node_count: N, edge_count: M, built_at: "<iso>", schema_version: "1.0" }`.
 
-**Note:** Graphify is an optional external dependency. It requires Python and takes 1-5 minutes to build on a large codebase. Do NOT add to plugin bootstrap — users opt in manually.
+**Note:** Graphify is optional. It is a pre-search oracle for planner and verifier agents, never a hard requirement. All stages MUST degrade gracefully when graphify is `unavailable` or `not_configured`.
 
 ---
 
@@ -50,7 +47,7 @@ Expect: `{ enabled: true, graph_path: "...", node_count: N, edge_count: N, stale
 
 | Node type | Source | ID pattern |
 |-----------|--------|-----------|
-| component | `.stories.tsx` / `src/components/*.tsx` | `component:<name>` |
+| component | `.stories.tsx` / `src/components/*.tsx` (via intel slices) | `component:<name>` |
 | token:color | CSS custom properties / Figma variables | `token:color/<name>` |
 | token:spacing | CSS custom properties | `token:spacing/<name>` |
 | token:typography | CSS custom properties | `token:typography/<name>` |
@@ -65,7 +62,7 @@ Expect: `{ enabled: true, graph_path: "...", node_count: N, edge_count: N, stale
 
 ### Edge Types
 
-| Edge | From | To | Meaning |
+| Edge kind | From | To | Meaning |
 |------|------|-----|---------|
 | `uses` | component | token | Component references this token |
 | `renders` | page | component | Page renders this component |
@@ -74,22 +71,32 @@ Expect: `{ enabled: true, graph_path: "...", node_count: N, edge_count: N, stale
 | `maps-to` | figma-variable | token | Figma variable corresponds to CSS token |
 | `detected-at` | anti-pattern | component | Anti-pattern found in this component |
 
-### graph.json structure
+### graph.json structure (schema v1.0)
 
 ```json
 {
+  "schema_version": "1.0",
+  "built_at": "2026-05-28T12:00:00.000Z",
   "nodes": [
-    { "id": "component:Button", "label": "Button", "type": "component",
-      "description": "Primary interactive element", "source": "src/components/Button.tsx" }
+    {
+      "id": "component:Button",
+      "type": "component",
+      "label": "Button",
+      "attrs": { "source": "src/components/Button.tsx" }
+    }
   ],
   "edges": [
-    { "source": "component:Button", "target": "token:color/primary/500",
-      "label": "uses", "confidence": "EXTRACTED", "confidence_score": 0.95 }
+    {
+      "from": "component:Button",
+      "to": "token:color/primary/500",
+      "kind": "uses",
+      "weight": 0.95
+    }
   ]
 }
 ```
 
-Edge confidence tiers: EXTRACTED (found in source), INFERRED (semantic inference), AMBIGUOUS (flagged for review).
+Edges use the `{from, to, kind, weight?}` shape (per D-03.b — matches intel-store schema verbatim, no translation layer). The optional `weight: number` replaces the upstream three-tier confidence enum (per D-03.c).
 
 ---
 
@@ -110,18 +117,19 @@ Unlike MCP connections, Graphify has no ToolSearch check. The probe is file-exis
 
 **Graphify probe sequence (execute at agent entry, before using graph):**
 
-Step G1 — Config check:
+Step G1 — Config check (per D-09 — direct read, no CLI subcommand):
 ```
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify status
-→ Error or { enabled: false }  → graphify: not_configured  (skip all graph steps)
-→ { enabled: true }            → proceed to Step G2
+node -e "try{const c=JSON.parse(require('fs').readFileSync('.design/config.json','utf8'));process.stdout.write(String(c.graphify?.enabled===true))}catch{process.stdout.write('false')}"
+→ false → graphify: not_configured  (skip all graph steps)
+→ true  → proceed to Step G2
 ```
 
-Step G2 — Graph file check:
+Step G2 — Graph status check (native CLI):
 ```
-Check if graphify-out/graph.json exists in project root
-→ Absent                       → graphify: unavailable  (graph not built yet)
-→ Present                      → graphify: available
+node bin/gdd-graph status --format json
+→ { configured: true, exists: true }  → graphify: available
+→ { configured: true, exists: false } → graphify: unavailable  (graph not built yet)
+→ { configured: false, ... }          → graphify: not_configured  (mirrors G1; defensive)
 ```
 
 Write graphify status to `.design/STATE.md` `<connections>`.
@@ -138,8 +146,8 @@ This is the canonical pre-search pattern for agents. Copy inline — SKILL.md an
 
 Step 1: Query graph for decision node and its neighbors
 ```
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify query "decision:D-<nn>" --budget 1500
-→ Returns: connected components + tokens as JSON
+node bin/gdd-graph query "decision:D-<nn>" --budget 1500
+→ Returns: ranked match list — connected components + tokens as JSON
 → Use returned component IDs as grep seed list (reduces false-negative "not found")
 ```
 
@@ -150,15 +158,15 @@ Step 2: Grep each returned component for the decision pattern
 
 Step 1: Query graph for token node and its neighbors
 ```
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" graphify query "<token-name>" --budget 1500
-→ Returns: all components that reference this token
+node bin/gdd-graph query "<token-name>" --budget 1500
+→ Returns: all components that reference this token (ranked by D-04.a score)
 → Annotate planned task with "N components affected" before scoping
 ```
 
 Step 2: Include component list in the task description
 (then continue standard planning behavior)
 
-**Budget note:** Use `--budget 1500` for pre-search queries. High confidence_score edges (>= 0.8) are more reliable; AMBIGUOUS edges are hints only.
+**Budget note:** Use `--budget 1500` for pre-search queries. Higher-weight edges (`weight >= 0.8`) are more reliable; lower-weight edges are hints only.
 
 ---
 
@@ -177,21 +185,24 @@ The graph is a performance optimization and accuracy enhancer. It is never a har
 ## Anti-Patterns
 
 - **Do NOT use graphify to replace grep.** The graph is a seed list, not a complete index. Always grep after querying the graph.
-- **Do NOT embed graph.json contents in agent context.** Query specific nodes via gsd-tools; never read graph.json directly.
+- **Do NOT embed `graph.json` contents in agent context.** Query specific nodes via `bin/gdd-graph query`; never read `graph.json` directly.
 - **Do NOT query the graph during scan or design stages.** The graph is read-only and only useful when decisions already exist (plan, verify).
-- **Do NOT block on graph build time.** If `graphify build` takes >30 seconds mid-session, log "graphify build deferred — run /gdd:graphify build manually" and continue without graph.
-- **Do NOT assume graph covers .design/ artifacts.** Graphify analyzes source code (src/, components/). DESIGN-CONTEXT.md and DESIGN-PLAN.md are not graph nodes unless explicitly indexed.
+- **Do NOT block on graph build time.** If `gdd-graph build` takes >30 seconds mid-session, log "graphify build deferred — run /gdd:graphify build manually" and continue without graph.
+- **Do NOT assume graph covers `.design/` artifacts.** The build walks `.design/intel/` slices and project source; arbitrary planning docs are not graph nodes unless explicitly indexed.
 
 ---
 
 ## /gdd:graphify Commands
 
-| Subcommand | GSD tools call | Purpose |
+| Subcommand | Native CLI call | Purpose |
 |------------|----------------|---------|
-| `build` | `gsd-tools graphify build` | Build or rebuild the knowledge graph |
-| `query <term>` | `gsd-tools graphify query "<term>" --budget 2000` | Query the graph for a node and its neighbors |
-| `status` | `gsd-tools graphify status` | Check graph age, node count, enabled status |
-| `diff` | `gsd-tools graphify diff` | Show topology changes since last build |
+| `build` | `node bin/gdd-graph build` | Build or rebuild the knowledge graph |
+| `query <term>` | `node bin/gdd-graph query "<term>" --budget 2000` | Query the graph for a node and its neighbors |
+| `status` | `node bin/gdd-graph status` | Check graph age, node count, enabled status |
+| `diff` | `node bin/gdd-graph diff` | Show topology changes since last build |
+| `upsert-node` | `node bin/gdd-graph upsert-node --id X --type T --label L` | Programmatic single-node insert (used by gdd-graph-refresh agent) |
+| `upsert-edge` | `node bin/gdd-graph upsert-edge --from A --to B --kind R` | Programmatic single-edge insert (used by gdd-graph-refresh agent) |
+
+If `graphify.enabled` is `false` (or `.design/config.json` is missing), the `bin/gdd-graph` subcommands graceful-degrade — `status` returns `{ configured: false, exists: false }`, other subcommands no-op with exit 0 and a one-line stderr notice.
 
-If `graphify.enabled = false` in `.planning/config.json`, the skill prompts:
-"Graphify is not enabled. Enable with: gsd-tools config-set graphify.enabled true — then run /gdd:graphify build."
+To enable: edit `.design/config.json` and set `graphify.enabled: true`, then `node bin/gdd-graph build`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.30.0",
+  "version": "1.30.6",
   "description": "A design-quality pipeline for AI coding agents: brief, plan, implement, and verify UI work against your design system.",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -28,6 +28,7 @@
   ],
   "bin": {
     "gdd-events": "./scripts/cli/gdd-events.mjs",
+    "gdd-graph": "./bin/gdd-graph",
     "gdd-mcp": "./scripts/mcp-servers/gdd-mcp/server.ts",
     "gdd-sdk": "./bin/gdd-sdk",
     "gdd-state-mcp": "./scripts/mcp-servers/gdd-state/server.ts",
@@ -88,7 +89,8 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.143",
     "@clack/prompts": "^1.2.0",
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ajv": "^8.18.0"
   },
   "optionalDependencies": {
     "pngjs": "^7.0.0",

package/reference/capability-gap-stage-gate.md

@@ -159,10 +159,13 @@ appends the following verbatim block to the cycle markdown:
 > opt in with the project-local command below. You can always opt out
 > later by deleting the timestamps from `.design/config.json` (§ 7).
 >
-> <!-- TODO: confirm opt-in command — likely
->      `node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" config set capability_gap_gate.opted_in_at "$(date -Iseconds)"`
->      or a project-local equivalent. Plan 29-05 (apply-reflections
->      extension) will land the canonical command. -->
+> <!-- Phase 30.6 (D-09) update: per the convention adopted across the
+>      knowledge layer in v1.30.6, project-local config flips are direct
+>      edits to .design/config.json — no CLI subcommand. The canonical
+>      opt-in is therefore: edit .design/config.json to add
+>      { "capability_gap_gate": { "opted_in_at": "<ISO date>" } }.
+>      Plan 29-05 (apply-reflections extension) surfaces this as a guided
+>      prompt rather than a CLI invocation. -->
 >
 > This prompt is emitted at most once per project. If you ignore it,
 > the gate continues to evaluate every cycle but does not re-prompt