@hegemonart/get-design-done 1.56.0 → 1.57.1

package/sdk/dashboard/data/_pkg-root.cjs

@@ -6,8 +6,8 @@
  * resolve a cross-tree sibling via a fixed `__dirname`-relative `../../..`
  * jump, because that breaks the moment a file is copied/moved or the layout
  * shifts. Instead, walk UP from this file's directory until we find the GDD
- * package.json (identified by `name === 'get-design-done'`), and resolve all
- * in-repo siblings relative to that root.
+ * package.json (identified by `name === '@hegemonart/get-design-done'`), and
+ * resolve all in-repo siblings relative to that root.
  *
  * Even though these dashboard `.cjs` files are NOT esbuild-bundled (R8 — the
  * bin trampoline runs them directly so the Phase 53 __dirname-rewrite trap
@@ -23,7 +23,7 @@ let _cachedRoot = null;
 
 /**
  * Walk up from `startDir` looking for the GDD package root. The GDD root is
- * the first ancestor whose package.json declares `name: "get-design-done"`;
+ * the first ancestor whose package.json declares `name: "@hegemonart/get-design-done"`;
  * if no such marker is found (e.g. running from an unusual layout), fall back
  * to the FIRST ancestor that has any package.json, then to `startDir`.
  *
@@ -44,7 +44,7 @@ function findPackageRoot(startDir) {
     }
     if (pkg) {
       if (firstWithPkg === null) firstWithPkg = dir;
-      if (pkg.name === 'get-design-done') return dir;
+      if (pkg.name === '@hegemonart/get-design-done') return dir;
     }
     const parent = path.dirname(dir);
     if (parent === dir) break;

package/sdk/dashboard/data/risk-surface.cjs

@@ -33,15 +33,20 @@
  *   (absent / unknown)  -> default
  */
 
-/** Canonical action → color map (the only colors the Findings pane uses). */
+/**
+ * Canonical action -> color map. Keys are lowercase (matching the emitter's
+ * suggested_action values from events.schema.json: allow/review/
+ * require_confirmation/block). The display label is separate from the key so
+ * the map can do a single case-insensitive lookup.
+ */
 const ACTION_COLOR = Object.freeze({
-  Allow: 'green',
-  Review: 'yellow',
-  RequireConfirmation: 'orange',
-  Block: 'red',
+  allow: 'green',
+  review: 'yellow',
+  require_confirmation: 'orange',
+  block: 'red',
 });
 
-/** The set of recognized suggested-action values (Phase 56 vocabulary). */
+/** The set of recognized suggested-action values (Phase 56 vocabulary, lowercase). */
 const VALID_ACTIONS = Object.freeze(Object.keys(ACTION_COLOR));
 
 /** The blank placeholder row emitted pre-56 (or for malformed/absent input). */
@@ -66,34 +71,64 @@ function finiteOrNull(v) {
 }
 
 /**
- * Map a suggested_action to its display color. Unknown / absent -> 'default'.
+ * Canonicalize a suggested_action to its lowercase snake_case key for lookup.
+ * Handles the emitter's lowercase values (allow/review/require_confirmation/block)
+ * AND legacy CamelCase (Allow/Review/RequireConfirmation/Block) - the CamelCase
+ * 'RequireConfirmation' lowercases to 'requireconfirmation' with no separator, so
+ * map that explicitly to 'require_confirmation'. Returns null for non-strings.
+ * @param {*} action
+ * @returns {string|null}
+ */
+function canonAction(action) {
+  if (typeof action !== 'string') return null;
+  let s = action.trim().toLowerCase().replace(/[\s-]+/g, '_');
+  if (s === 'requireconfirmation') s = 'require_confirmation';
+  return s;
+}
+
+/**
+ * Map a suggested_action to its display color. Case-insensitive so both
+ * 'allow' (emitter) and 'Allow' (legacy) resolve correctly. Unknown / absent -> 'default'.
  * @param {*} action
  * @returns {'green'|'yellow'|'orange'|'red'|'default'}
  */
 function colorForAction(action) {
-  if (typeof action === 'string' && Object.prototype.hasOwnProperty.call(ACTION_COLOR, action)) {
-    return ACTION_COLOR[action];
+  const canon = canonAction(action);
+  if (canon !== null && Object.prototype.hasOwnProperty.call(ACTION_COLOR, canon)) {
+    return ACTION_COLOR[canon];
   }
   return 'default';
 }
 
 /**
- * Surface the risk fields on ONE event/finding. Reads `risk_score`,
- * `confidence`, `suggested_action` WHEN PRESENT; otherwise returns the blank
- * placeholder. PURE; NEVER throws.
+ * Surface the risk fields on ONE event/finding. Accepts either a raw
+ * risk_assessment envelope (with a `.payload` sub-object) OR a bare payload
+ * object. When `.payload` is present it is used as the source of risk fields;
+ * otherwise `item` itself is inspected (bare-payload / legacy path).
  *
- * @param {*} item an event or finding (may be missing the risk fields pre-56)
+ * Reads `risk_score`, `confidence`, `suggested_action` WHEN PRESENT; otherwise
+ * returns the blank placeholder. PURE; NEVER throws.
+ *
+ * @param {*} item an event envelope or bare payload (may be missing risk fields pre-56)
  * @returns {{risk_score:number|null, confidence:number|null,
  *            suggested_action:string|null, color:string}}
  */
 function surfaceRiskOne(item) {
   if (!item || typeof item !== 'object') return blankRow();
 
-  const risk_score = finiteOrNull(item.risk_score);
-  const confidence = finiteOrNull(item.confidence);
-  const rawAction = item.suggested_action;
-  const suggested_action =
-    typeof rawAction === 'string' && VALID_ACTIONS.includes(rawAction) ? rawAction : null;
+  // Normalize: if the caller passed a full event envelope (with .payload), use the payload.
+  const src = (item.payload && typeof item.payload === 'object') ? item.payload : item;
+
+  const risk_score = finiteOrNull(src.risk_score);
+  const confidence = finiteOrNull(src.confidence);
+  const rawAction = src.suggested_action;
+  const canon = canonAction(rawAction);
+  const recognized =
+    canon !== null && Object.prototype.hasOwnProperty.call(ACTION_COLOR, canon);
+  // Preserve the action VERBATIM when recognized: the emitter sends lowercase
+  // (allow/review/require_confirmation/block), legacy callers may send CamelCase,
+  // and either is echoed back unchanged. Unrecognized / absent -> null.
+  const suggested_action = recognized ? rawAction : null;
 
   // Pre-56: when NONE of the risk fields are present, emit the blank placeholder
   // verbatim (color 'default') so the column reads as "not yet scored".
@@ -105,7 +140,7 @@ function surfaceRiskOne(item) {
     risk_score,
     confidence,
     suggested_action,
-    color: colorForAction(suggested_action),
+    color: recognized ? ACTION_COLOR[canon] : 'default',
   };
 }
 

package/sdk/dashboard/data/source.cjs

@@ -58,6 +58,10 @@ function tryRequire(relPath) {
 const designContextQuery = tryRequire('scripts/lib/design-context-query.cjs');
 const eventChain = tryRequire('scripts/lib/event-chain.cjs');
 const healthMirror = tryRequire('scripts/lib/health-mirror/index.cjs');
+// Phase 57 (Round 3-E): state-store provides backendName() so the dashboard
+// model can surface whether it read from SQLite or markdown. Soft-loaded so
+// a missing module degrades without crashing. Never throws.
+const stateStore = tryRequire('scripts/lib/state/state-store.cjs');
 
 // ---------------------------------------------------------------------------
 // .ts shared libs — dynamic import(pathToFileURL), memoized.
@@ -211,23 +215,54 @@ function scrapeEventsFile(eventsPath) {
 
 /**
  * Load STATE.md-derived fields: status, phase(stage), cycle, decisions[],
- * blockers[]. Tries the typed sdk/state read() first, then the file scrape.
+ * blockers[], backend. Tries the typed sdk/state read() first (which is
+ * already migration-active-aware for Phase 57: when BACKEND==='sqlite' and
+ * a sibling state.sqlite exists, the dual-write path ensures STATE.md is
+ * byte-equal with SQLite so read() returns the canonical view), then the
+ * file-scrape fallback. Never throws.
+ *
+ * The `backend` field reflects the active state-store backend:
+ *   'sqlite'   — better-sqlite3 + FTS5 available and migration active
+ *   'markdown' — markdown floor (the universal default and CI surface)
  *
  * @param {string} root
  * @param {string[]} degraded
  * @returns {Promise<{status:string|null, phase:string|null, cycle:string|null,
- *           decisions:Array, blockers:Array}>}
+ *           decisions:Array, blockers:Array, backend:'sqlite'|'markdown'}>}
  */
 async function loadState(root, degraded) {
   const statePath = path.join(root, '.design', 'STATE.md');
-  const empty = { status: null, phase: null, cycle: null, decisions: [], blockers: [] };
+  const empty = {
+    status: null, phase: null, cycle: null,
+    decisions: [], blockers: [],
+    backend: /** @type {'sqlite'|'markdown'} */ ('markdown'),
+  };
+
+  // Determine the active backend for this specific state path (Phase 57 R3-E).
+  // The migration-active gate is:
+  //   BACKEND==='sqlite' AND existsSync(<statePath-sibling>/state.sqlite)
+  //
+  // We use state-store.backendName() to check the global probe result, then
+  // confirm by checking whether a sibling state.sqlite exists next to STATE.md.
+  // This mirrors the migrationActive() logic in sdk/state/index.ts exactly.
+  const globalBackend =
+    (stateStore && typeof stateStore.backendName === 'function')
+      ? /** @type {'sqlite'|'markdown'} */ (stateStore.backendName())
+      : 'markdown';
+  const sqliteSibling = path.join(root, '.design', 'state.sqlite');
+  const activeBackend = /** @type {'sqlite'|'markdown'} */ (
+    globalBackend === 'sqlite' && fs.existsSync(sqliteSibling) ? 'sqlite' : 'markdown'
+  );
 
   if (!fs.existsSync(statePath)) {
     degraded.push('state: .design/STATE.md not found');
-    return empty;
+    return { ...empty, backend: activeBackend };
   }
 
   // 1) Typed lib read() — the in-process shared surface (R1).
+  // Phase 57: sdk/state read() is already migration-active-aware; when
+  // BACKEND==='sqlite' and state.sqlite sibling exists, STATE.md is kept
+  // byte-equal by the dual-write path, so no separate SQLite read needed.
   try {
     const stateMod = await importState();
     if (stateMod && typeof stateMod.read === 'function') {
@@ -239,6 +274,7 @@ async function loadState(root, degraded) {
         cycle: (parsed.frontmatter && parsed.frontmatter.cycle) || null,
         decisions: Array.isArray(parsed.decisions) ? parsed.decisions : [],
         blockers: Array.isArray(parsed.blockers) ? parsed.blockers : [],
+        backend: activeBackend,
       };
     }
     degraded.push('state: sdk/state import unavailable — using file scrape');
@@ -246,7 +282,7 @@ async function loadState(root, degraded) {
     degraded.push(`state: typed read failed (${errMsg(err)}) — using file scrape`);
   }
 
-  // 2) File-scrape fallback.
+  // 2) File-scrape fallback (ultimate fallback; never throws).
   const scraped = scrapeStateFile(statePath);
   if (scraped) {
     return {
@@ -255,6 +291,7 @@ async function loadState(root, degraded) {
       cycle: scraped.cycle,
       decisions: scraped.decisions,
       blockers: scraped.blockers,
+      backend: 'markdown',
     };
   }
   degraded.push('state: scrape fallback failed');
@@ -508,6 +545,7 @@ function errMsg(err) {
  *   sessions: Array,
  *   degraded: string[],
  *   root: string,
+ *   backend: 'sqlite'|'markdown',
  * }>}
  */
 async function loadDashboardModel(opts = {}) {
@@ -564,6 +602,7 @@ async function loadDashboardModel(opts = {}) {
     sessions,
     degraded,
     root,
+    backend: stateRes.backend,
   };
 }
 

package/sdk/dashboard/tui/index.cjs

@@ -37,6 +37,21 @@ const readline = require('node:readline');
 
 const ansi = require('./ansi.cjs');
 
+// Lazily require the risk-surface helper (same dep-free constraint as the data plane).
+let _surfaceRisk = null;
+function getSurfaceRisk() {
+  if (_surfaceRisk === null) {
+    try {
+      ({ surfaceRisk: _surfaceRisk } = require('../data/risk-surface.cjs'));
+    } catch {
+      // If the module is unavailable for any reason, fall back to a no-op that returns
+      // blank placeholder rows so the column still renders cleanly.
+      _surfaceRisk = () => ({ risk_score: null, confidence: null, suggested_action: null, color: 'default' });
+    }
+  }
+  return _surfaceRisk;
+}
+
 // Lazily require the data plane so `renderFrame` (the pure path) can be imported + unit-tested
 // without paying for the data module's transitive requires. `run` resolves it on demand.
 let _loadDashboardModel = null;
@@ -351,11 +366,22 @@ function bodyFindings(model, inner, scroll) {
   if (tail.length === 0) {
     lines.push('  ' + ansi.color('no events', { dim: true }));
   } else {
+    const surfaceRisk = getSurfaceRisk();
     for (const ev of tail) {
       const name = (ev && (ev.event || ev.type || ev.kind)) || 'event';
-      // Pre-Phase-56: risk/confidence are blank placeholders (D8).
+      // Phase-56+: surface risk/confidence from risk_assessment events.
+      // For pre-56 events that lack risk fields, surfaceRiskOne returns the blank placeholder.
+      const surfaced = (ev && ev.type === 'risk_assessment')
+        ? surfaceRisk(ev)
+        : { risk_score: null, confidence: null, suggested_action: null, color: 'default' };
+      const riskText = surfaced.risk_score !== null
+        ? ansi.color(surfaced.risk_score.toFixed(2), { fg: surfaced.color !== 'default' ? surfaced.color : undefined })
+        : ansi.color('·', { dim: true });
+      const confText = surfaced.confidence !== null
+        ? String(surfaced.confidence.toFixed(2))
+        : ansi.color('·', { dim: true });
       lines.push(ansi.columns(
-        [String(name), ansi.color('·', { dim: true }), ansi.color('·', { dim: true })],
+        [String(name), riskText, confText],
         [Math.max(8, inner - 14), 5, 5],
       ));
     }

package/sdk/mcp/gdd-state/server.js

@@ -36,7 +36,7 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 var import_node_fs5 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_types8 = require("@modelcontextprotocol/sdk/types.js");
@@ -196,6 +196,7 @@ __export(get_exports, {
 
 // sdk/state/index.ts
 var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
 
 // sdk/state/lockfile.ts
 var import_node_fs = require("node:fs");
@@ -349,7 +350,10 @@ function getErrnoCode(err) {
   return void 0;
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function acquireSqliteLock(sqlitePath, opts = {}) {
+  return acquire(sqlitePath, opts);
 }
 
 // sdk/state/parser.ts
@@ -1727,11 +1731,70 @@ function gateFor(from, to) {
 }
 
 // sdk/state/index.ts
+function _findPackageRoot(startDir) {
+  let dir = (0, import_node_path.resolve)(startDir);
+  let firstWithPkg = null;
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = (0, import_node_path.join)(dir, "package.json");
+    if ((0, import_node_fs2.existsSync)(pkgPath)) {
+      try {
+        const pkg = require(pkgPath);
+        if (firstWithPkg === null) firstWithPkg = dir;
+        if (pkg.name === "@hegemonart/get-design-done") return dir;
+      } catch {
+        if (firstWithPkg === null) firstWithPkg = dir;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return firstWithPkg;
+}
+var _backendCache = null;
+function _loadBackend() {
+  if (_backendCache !== null) return _backendCache === false ? null : _backendCache;
+  try {
+    const pkgRoot = _findPackageRoot(__dirname);
+    if (pkgRoot === null) {
+      _backendCache = false;
+      return null;
+    }
+    const backendPath = (0, import_node_path.join)(pkgRoot, "scripts", "lib", "state", "state-backend.cjs");
+    if (!(0, import_node_fs2.existsSync)(backendPath)) {
+      _backendCache = false;
+      return null;
+    }
+    _backendCache = require(backendPath);
+    return _backendCache;
+  } catch {
+    _backendCache = false;
+    return null;
+  }
+}
+function migrationActive(statePath) {
+  const backend = _loadBackend();
+  if (backend === null || backend.BACKEND !== "sqlite") return false;
+  const sqliteSibling = (0, import_node_path.join)((0, import_node_path.dirname)(statePath), "state.sqlite");
+  if (!(0, import_node_fs2.existsSync)(sqliteSibling)) return false;
+  try {
+    if ((0, import_node_fs2.statSync)(sqliteSibling).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  return true;
+}
 async function read(path2) {
   const raw = (0, import_node_fs2.readFileSync)(path2, "utf8");
   return parse(raw).state;
 }
 async function mutate(path2, fn) {
+  if (migrationActive(path2)) {
+    return _mutateSqliteActive(path2, fn);
+  }
+  return _mutateMarkdown(path2, fn);
+}
+async function _mutateMarkdown(path2, fn) {
   const release = await acquire(path2);
   const tmpPath = `${path2}.tmp`;
   try {
@@ -1768,6 +1831,46 @@ async function mutate(path2, fn) {
     await release();
   }
 }
+async function _mutateSqliteActive(path2, fn) {
+  const sqlitePath = (0, import_node_path.join)((0, import_node_path.dirname)(path2), "state.sqlite");
+  const releaseSqliteLock = await acquireSqliteLock(sqlitePath);
+  const release = await acquire(path2);
+  const tmpPath = `${path2}.tmp`;
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(path2, "utf8");
+    const { state, raw_bodies, raw_frontmatter, block_gaps, line_ending } = parse(raw);
+    const clone = structuredClone(state);
+    const next = fn(clone);
+    const out = serialize(next, {
+      raw_frontmatter,
+      raw_bodies,
+      block_gaps,
+      line_ending
+    });
+    (0, import_node_fs2.writeFileSync)(tmpPath, out, "utf8");
+    try {
+      (0, import_node_fs2.renameSync)(tmpPath, path2);
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+      if (code === "EPERM" || code === "EBUSY") {
+        await new Promise((r) => setTimeout(r, 50));
+        (0, import_node_fs2.renameSync)(tmpPath, path2);
+      } else {
+        throw err;
+      }
+    }
+    return next;
+  } catch (err) {
+    try {
+      if ((0, import_node_fs2.existsSync)(tmpPath)) (0, import_node_fs2.unlinkSync)(tmpPath);
+    } catch {
+    }
+    throw err;
+  } finally {
+    await release();
+    await releaseSqliteLock();
+  }
+}
 async function transition(path2, toStage) {
   const beforeMutate = await read(path2);
   const from = beforeMutate.position.stage;
@@ -1798,7 +1901,7 @@ async function transition(path2, toStage) {
 }
 
 // sdk/mcp/gdd-state/tools/shared.ts
-var import_node_path2 = __toESM(require("node:path"));
+var import_node_path3 = __toESM(require("node:path"));
 var import_node_fs4 = require("node:fs");
 var import_node_module2 = require("node:module");
 
@@ -1848,13 +1951,13 @@ var EventBus = class extends import_node_events.EventEmitter {
 
 // sdk/event-stream/writer.ts
 var import_node_fs3 = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
 var import_node_module = require("node:module");
 function _findRepoRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if ((0, import_node_fs3.existsSync)((0, import_node_path.join)(dir, "package.json"))) return dir;
-    const parent = (0, import_node_path.dirname)(dir);
+    if ((0, import_node_fs3.existsSync)((0, import_node_path2.join)(dir, "package.json"))) return dir;
+    const parent = (0, import_node_path2.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1863,16 +1966,16 @@ function _findRepoRoot() {
 var _redact;
 try {
   const _root = _findRepoRoot();
-  const _candidate = (0, import_node_path.resolve)(_root, "scripts/lib/redact.cjs");
+  const _candidate = (0, import_node_path2.resolve)(_root, "scripts/lib/redact.cjs");
   if ((0, import_node_fs3.existsSync)(_candidate)) {
-    const _redactRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(_root, "package.json"));
+    const _redactRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_root, "package.json"));
     const _mod = _redactRequire(_candidate);
     _redact = _mod.redact;
   } else {
-    const _altRoot = (0, import_node_path.resolve)(_root, "..", "..");
-    const _altCandidate = (0, import_node_path.resolve)(_altRoot, "scripts/lib/redact.cjs");
+    const _altRoot = (0, import_node_path2.resolve)(_root, "..", "..");
+    const _altCandidate = (0, import_node_path2.resolve)(_altRoot, "scripts/lib/redact.cjs");
     if ((0, import_node_fs3.existsSync)(_altCandidate)) {
-      const _altRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(_altRoot, "package.json"));
+      const _altRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_altRoot, "package.json"));
       const _altMod = _altRequire(_altCandidate);
       _redact = _altMod.redact;
     } else {
@@ -1898,7 +2001,7 @@ var EventWriter = class {
   directoryEnsured = false;
   constructor(opts = {}) {
     const rawPath = opts.path ?? DEFAULT_EVENTS_PATH;
-    this.path = (0, import_node_path.isAbsolute)(rawPath) ? rawPath : (0, import_node_path.resolve)(process.cwd(), rawPath);
+    this.path = (0, import_node_path2.isAbsolute)(rawPath) ? rawPath : (0, import_node_path2.resolve)(process.cwd(), rawPath);
     this.maxLineBytes = opts.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
   }
   /**
@@ -1959,7 +2062,7 @@ var EventWriter = class {
    */
   ensureDirectory() {
     if (this.directoryEnsured) return;
-    (0, import_node_fs3.mkdirSync)((0, import_node_path.dirname)(this.path), { recursive: true });
+    (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(this.path), { recursive: true });
     this.directoryEnsured = true;
   }
 };
@@ -2017,8 +2120,8 @@ function getSessionId() {
 function _findRepoRoot2() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if ((0, import_node_fs4.existsSync)(import_node_path2.default.join(dir, "package.json"))) return dir;
-    const parent = import_node_path2.default.dirname(dir);
+    if ((0, import_node_fs4.existsSync)(import_node_path3.default.join(dir, "package.json"))) return dir;
+    const parent = import_node_path3.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -2027,9 +2130,9 @@ function _findRepoRoot2() {
 var _worktree = (() => {
   try {
     const root = _findRepoRoot2();
-    const candidate = import_node_path2.default.resolve(root, "scripts/lib/worktree-resolve.cjs");
+    const candidate = import_node_path3.default.resolve(root, "scripts/lib/worktree-resolve.cjs");
     if (!(0, import_node_fs4.existsSync)(candidate)) return null;
-    const req = (0, import_node_module2.createRequire)(import_node_path2.default.join(root, "package.json"));
+    const req = (0, import_node_module2.createRequire)(import_node_path3.default.join(root, "package.json"));
     return req(candidate);
   } catch {
     return null;
@@ -2042,20 +2145,20 @@ function resolveStatePath() {
       try {
         const designRoot = _worktree.resolveDesignRoot();
         if (_worktree.isWorktree()) {
-          _worktree.noticeOnce(import_node_path2.default.dirname(designRoot));
+          _worktree.noticeOnce(import_node_path3.default.dirname(designRoot));
         }
-        return import_node_path2.default.join(designRoot, "STATE.md");
+        return import_node_path3.default.join(designRoot, "STATE.md");
       } catch {
       }
     }
     return ".design/STATE.md";
   }
-  if (import_node_path2.default.isAbsolute(override)) {
-    return import_node_path2.default.resolve(override);
+  if (import_node_path3.default.isAbsolute(override)) {
+    return import_node_path3.default.resolve(override);
   }
-  const root = import_node_path2.default.resolve(process.cwd());
-  const resolved = import_node_path2.default.resolve(root, override);
-  const withSep = root.endsWith(import_node_path2.default.sep) ? root : root + import_node_path2.default.sep;
+  const root = import_node_path3.default.resolve(process.cwd());
+  const resolved = import_node_path3.default.resolve(root, override);
+  const withSep = root.endsWith(import_node_path3.default.sep) ? root : root + import_node_path3.default.sep;
   if (resolved !== root && !resolved.startsWith(withSep)) {
     throwValidation(
       "STATE_PATH_ESCAPE",
@@ -2763,16 +2866,16 @@ var TOOL_COUNT = TOOL_MODULES.length;
 var SERVER_NAME = "gdd-state";
 var SERVER_VERSION = "1.20.0";
 function here() {
-  const expectedRel = (0, import_node_path3.join)("sdk", "mcp", "gdd-state");
+  const expectedRel = (0, import_node_path4.join)("sdk", "mcp", "gdd-state");
   const entry = process.argv[1];
   if (typeof entry === "string" && entry.length > 0) {
-    const entryDir = (0, import_node_path3.dirname)((0, import_node_path3.resolve)(entry));
-    if ((0, import_node_fs5.existsSync)((0, import_node_path3.join)(entryDir, "tools", "index.ts"))) {
+    const entryDir = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(entry));
+    if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(entryDir, "tools", "index.ts"))) {
       return entryDir;
     }
   }
-  const candidate = (0, import_node_path3.resolve)(process.cwd(), expectedRel);
-  if ((0, import_node_fs5.existsSync)((0, import_node_path3.join)(candidate, "tools", "index.ts"))) {
+  const candidate = (0, import_node_path4.resolve)(process.cwd(), expectedRel);
+  if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(candidate, "tools", "index.ts"))) {
     return candidate;
   }
   return candidate;
@@ -2780,7 +2883,7 @@ function here() {
 function loadTools() {
   const baseDir = here();
   return TOOL_MODULES.map((m) => {
-    const absPath = (0, import_node_path3.join)(baseDir, "tools", m.schemaPath);
+    const absPath = (0, import_node_path4.join)(baseDir, "tools", m.schemaPath);
     const raw = (0, import_node_fs5.readFileSync)(absPath, "utf8");
     const parsed = JSON.parse(raw);
     const rawInput = parsed.properties?.input;

package/sdk/mcp/gdd-state/tools/get.ts

@@ -5,6 +5,14 @@
 // event. Optionally projects a subset of fields when `input.fields` is
 // provided; unknown field names are silently ignored so callers can pass
 // a broad list without pre-flight knowledge of ParsedState shape.
+//
+// Phase 57 (Round 3-E): this tool already benefits from the SQLite read
+// path transparently. `sdk/state/index.ts` `read()` delegates through the
+// migration-active gate: when BACKEND==='sqlite' and a sibling state.sqlite
+// exists the dual-write path keeps STATE.md byte-equal with SQLite state,
+// so reading the on-disk STATE.md returns the canonical view regardless of
+// which backend is active. No behavioral change is required here and the
+// tool input/output SCHEMA IS UNCHANGED (no mcp-tools-manifest hash drift).
 
 import { read } from '../../../state/index.ts';
 import type { ParsedState } from '../../../state/types.ts';