@hegemonart/get-design-done 1.57.1 → 1.57.2

package/hooks/gdd-risk-gate.js

@@ -8,7 +8,10 @@
  *
  * Quantifies the confidence/risk of a writer action with the PURE scorer
  * `scripts/lib/risk/compute-risk.cjs` (executor A), emits a `risk_assessment`
- * telemetry event, and routes by the scorer's `suggested_action`:
+ * telemetry event, writes a rolling-50 calibration row via
+ * `scripts/lib/risk/calibration.cjs` updateCalibration() (Phase 56 CAL-01 — this
+ * closes the calibration loop end-to-end: production traffic, not just tests,
+ * drives detectDrift), and routes by the scorer's `suggested_action`:
  *
  *   allow                -> { continue: true }                                  (silent)
  *   review               -> { continue: true, hookSpecificOutput: { … } }       (advisory, non-blocking)
@@ -83,6 +86,85 @@ let _riskLoadError = null;
   }
 })();
 
+// ── Calibration sibling resolver (same walk-up shape as the risk module) ────
+// scripts/lib/risk/calibration.cjs is the rolling-50 per-agent calibration
+// store (Phase 56 CAL-01). We call updateCalibration AFTER scoring so the
+// store grows over time with real per-agent (risk, accepted) outcomes — that
+// is what wires the calibration loop end-to-end (under_scoring / over_scoring
+// drift becomes detectable from real traffic, not just from synthetic tests).
+const CAL_REL = path.join('scripts', 'lib', 'risk', 'calibration.cjs');
+
+function findCalibrationModule(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 64; i++) {
+    const candidate = path.join(dir, CAL_REL);
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch { /* keep climbing */ }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+let _cal = null;
+let _calLoadError = null;
+(function loadCal() {
+  try {
+    const modPath = findCalibrationModule(__dirname);
+    if (!modPath) {
+      _calLoadError = `calibration.cjs not found above ${__dirname}`;
+      return;
+    }
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    _cal = require(modPath);
+  } catch (err) {
+    _calLoadError = err && err.message ? err.message : String(err);
+  }
+})();
+
+// ── Calibration write (best-effort, never throws) ───────────────────────────
+// Records one (agent, risk, accepted) outcome for the rolling-50 window.
+//
+// The signal we can KNOW at PreToolUse time:
+//   * action === 'block' -> definitive accepted:false (the hook rejected the
+//     call; the user never sees the tool run).
+//   * action ∈ {allow, review, require_confirmation} -> accepted:true at the
+//     PreToolUse boundary. The action proceeds past the risk gate; a later
+//     hook may still block, and the user may later /gdd:override or undo, but
+//     for THIS gate's calibration loop "the risk gate let it through" IS the
+//     acceptance signal. user_undo / post_apply_correct are deliberately left
+//     null (unresolved) — a future PostToolUse pass can resolve them later.
+//
+// Agent gate: a calibration row needs an agent key. When the agent is unknown
+// (the common case for a generic PreToolUse hook) we skip the write rather
+// than pool everything into an 'unknown' bucket that would render drift
+// detection meaningless. The risk_assessment event still fires either way.
+//
+// Always best-effort: a calibration write must NEVER break a tool call.
+function recordCalibration(agent, assessment, cwd) {
+  try {
+    if (!_cal || typeof _cal.updateCalibration !== 'function') return;
+    if (!agent || typeof agent !== 'string') return;
+    const action = assessment && assessment.suggested_action;
+    if (!action) return;
+    const score = typeof assessment.score === 'number' ? assessment.score : 0;
+    _cal.updateCalibration(
+      agent,
+      {
+        risk: score,
+        accepted: action !== 'block',
+        user_undo: false,
+        post_apply_correct: null,
+      },
+      { root: cwd || process.cwd() },
+    );
+  } catch {
+    /* swallow — calibration writes must never throw into the gate */
+  }
+}
+
 // ── Best-effort `risk_assessment` event emit ────────────────────────────────
 // The firehose (`appendEvent`, sdk/event-stream) is the sink the wire-in tests
 // read via GDD_EVENTS_PATH. `type` is free-form on the envelope, so emitting
@@ -358,6 +440,14 @@ async function main() {
     sessionId,
   );
 
+  // Update the rolling-50 per-agent calibration window with this outcome
+  // (Phase 56 CAL-01). Best-effort; no-op when the agent is unknown. This is
+  // what closes the calibration loop end-to-end: the store accrues real
+  // (risk, accepted) pairs across the writer agent's actions, so detectDrift
+  // can flag under_scoring / over_scoring from production traffic rather than
+  // only from synthetic test calls.
+  recordCalibration(agent, assessment, cwd);
+
   // Mirror the decision onto the hook.fired row (allow|review|confirm|block).
   const firedDecision = action === 'block' ? 'block' : 'allow';
   emitHookFired(firedDecision, { suggested_action: action, score: assessment.score });
@@ -404,6 +494,8 @@ if (require.main === module) {
 // Exported for tests — pure helpers + the resolver. main() owns the I/O + contract.
 module.exports = {
   findRiskModule,
+  findCalibrationModule,
+  recordCalibration,
   buildMergedTables,
   compileFileSensitivityExtra,
   isReadOnlyAgent,

package/hooks/gdd-sessionstart-recap.js

@@ -21,12 +21,29 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const SNAPSHOT_DIR = path.resolve(process.cwd(), '.design', 'snapshots');
-const STATE_MD_PATH = path.resolve(process.cwd(), '.design', 'STATE.md');
-const EVENTS_PATH = path.resolve(process.cwd(), '.design', 'telemetry', 'events.jsonl');
-const RECAP_JSON_PATH = path.join(SNAPSHOT_DIR, 'last-recap.json');
 const SCHEMA_VERSION = '1.0.0';
 
+/**
+ * Resolve the bundle of paths the hook reads/writes, anchored at `cwd`.
+ *
+ * Phase 27.6 originally resolved these at module load via `process.cwd()`,
+ * which is the wrong anchor when Claude Code invokes the hook from a
+ * worktree (the harness's cwd at module load can be the parent / `.claude`
+ * directory, not the project root). Resolving against `payload.cwd` matches
+ * how 8 sibling hooks already work (gdd-protected-paths, gdd-fact-force,
+ * gdd-decision-injector, gdd-mcp-circuit-breaker, gdd-a11y-gate,
+ * gdd-design-quality-check, gdd-risk-gate, gdd-turn-closeout).
+ */
+function computePaths(cwd) {
+  const snapshotDir = path.resolve(cwd, '.design', 'snapshots');
+  return {
+    snapshotDir,
+    stateMdPath: path.resolve(cwd, '.design', 'STATE.md'),
+    eventsPath: path.resolve(cwd, '.design', 'telemetry', 'events.jsonl'),
+    recapJsonPath: path.join(snapshotDir, 'last-recap.json'),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Harness detection (D-10) — mirrors gdd-precompact-snapshot.js
 // ---------------------------------------------------------------------------
@@ -60,11 +77,11 @@ function getAppendEvent() {
 // needs frontmatter + a flat decisions list for the diff)
 // ---------------------------------------------------------------------------
 
-function readStateMd() {
-  if (!fs.existsSync(STATE_MD_PATH)) return { frontmatter: {}, decisions: [] };
+function readStateMd(paths) {
+  if (!fs.existsSync(paths.stateMdPath)) return { frontmatter: {}, decisions: [] };
   let body;
   try {
-    body = fs.readFileSync(STATE_MD_PATH, 'utf8');
+    body = fs.readFileSync(paths.stateMdPath, 'utf8');
   } catch {
     return { frontmatter: {}, decisions: [] };
   }
@@ -92,11 +109,11 @@ function readStateMd() {
 // Snapshot discovery — highest-mtime *.json (excluding last-recap.json)
 // ---------------------------------------------------------------------------
 
-function findLatestSnapshot() {
-  if (!fs.existsSync(SNAPSHOT_DIR)) return null;
+function findLatestSnapshot(paths) {
+  if (!fs.existsSync(paths.snapshotDir)) return null;
   let files;
   try {
-    files = fs.readdirSync(SNAPSHOT_DIR);
+    files = fs.readdirSync(paths.snapshotDir);
   } catch {
     return null;
   }
@@ -108,7 +125,7 @@ function findLatestSnapshot() {
   let best = null;
   let bestMtime = -1;
   for (const name of candidates) {
-    const full = path.join(SNAPSHOT_DIR, name);
+    const full = path.join(paths.snapshotDir, name);
     try {
       const mtime = fs.statSync(full).mtimeMs;
       if (mtime > bestMtime) {
@@ -126,11 +143,11 @@ function findLatestSnapshot() {
 // Event count since snapshot timestamp (JSONL-tolerant)
 // ---------------------------------------------------------------------------
 
-function countEventsSince(isoTimestamp) {
-  if (!fs.existsSync(EVENTS_PATH)) return 0;
+function countEventsSince(paths, isoTimestamp) {
+  if (!fs.existsSync(paths.eventsPath)) return 0;
   let body;
   try {
-    body = fs.readFileSync(EVENTS_PATH, 'utf8');
+    body = fs.readFileSync(paths.eventsPath, 'utf8');
   } catch {
     return 0;
   }
@@ -154,16 +171,34 @@ function countEventsSince(isoTimestamp) {
 // Main
 // ---------------------------------------------------------------------------
 
-function main() {
+async function main() {
   const harness = detectHarness();
   if (harness === 'codex') {
-    // D-10: SessionStart on Codex skips recap; Phase 45 dep for full
-    // pre-large-context-action integration.
-    process.stderr.write('[gdd-sessionstart-recap] codex harness no-op (Phase 45 dep)\n');
+    // D-10: SessionStart on Codex skips recap. Tracked in the runtime-parity
+    // matrix; full pre-large-context-action integration is on the roadmap.
+    process.stderr.write('[gdd-sessionstart-recap] codex harness no-op\n');
     process.exit(0);
   }
 
-  const snapshotPath = findLatestSnapshot();
+  // Drain stdin and extract payload.cwd (Claude Code SessionStart pipes a JSON
+  // envelope). Falls back to process.cwd() when stdin is empty (unit tests,
+  // direct invocation).
+  let buf = '';
+  try {
+    for await (const chunk of process.stdin) buf += chunk;
+  } catch {
+    /* swallow — empty stdin is fine */
+  }
+  let payload = {};
+  try {
+    payload = JSON.parse(buf || '{}');
+  } catch {
+    /* malformed stdin → fall through with empty payload */
+  }
+  const cwd = (payload && typeof payload.cwd === 'string') ? payload.cwd : process.cwd();
+  const paths = computePaths(cwd);
+
+  const snapshotPath = findLatestSnapshot(paths);
   if (!snapshotPath) {
     process.stderr.write('[gdd-sessionstart-recap] no prior snapshot\n');
     process.exit(0);
@@ -181,13 +216,13 @@ function main() {
     process.exit(0);
   }
 
-  const current = readStateMd();
+  const current = readStateMd(paths);
   const priorDecisions = Array.isArray(snapshot.last_n_decisions)
     ? snapshot.last_n_decisions
     : [];
   const priorSet = new Set(priorDecisions);
   const newDecisions = current.decisions.filter((d) => !priorSet.has(d));
-  const newEventCount = countEventsSince(snapshot.timestamp || '1970-01-01T00:00:00.000Z');
+  const newEventCount = countEventsSince(paths, snapshot.timestamp || '1970-01-01T00:00:00.000Z');
 
   const priorCycle = snapshot.cycle_id || 'unknown';
   const currentCycle = current.frontmatter.milestone || 'unknown';
@@ -226,9 +261,9 @@ function main() {
   try {
     // mkdir -p for safety — directory should exist if snapshotPath was found,
     // but defensive ensure for race conditions.
-    fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
-    fs.writeFileSync(RECAP_JSON_PATH + '.tmp', JSON.stringify(recap, null, 2), 'utf8');
-    fs.renameSync(RECAP_JSON_PATH + '.tmp', RECAP_JSON_PATH);
+    fs.mkdirSync(paths.snapshotDir, { recursive: true });
+    fs.writeFileSync(paths.recapJsonPath + '.tmp', JSON.stringify(recap, null, 2), 'utf8');
+    fs.renameSync(paths.recapJsonPath + '.tmp', paths.recapJsonPath);
   } catch (err) {
     process.stderr.write(
       '[gdd-sessionstart-recap] sidecar write failed: ' +

package/hooks/hooks.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap.sh\""
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap.cjs\""
           }
         ]
       },
@@ -13,7 +13,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/update-check.sh\""
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/update-check.cjs\""
           }
         ]
       },
@@ -21,7 +21,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/first-run-nudge.sh\""
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/first-run-nudge.cjs\""
           }
         ]
       },
@@ -38,7 +38,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/inject-using-gdd.sh\""
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/inject-using-gdd.cjs\""
           }
         ]
       }
@@ -151,6 +151,15 @@
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gdd-design-quality-check.js\""
           }
         ]
+      },
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gdd-intel-trigger.js\""
+          }
+        ]
       }
     ],
     "Stop": [

package/hooks/inject-using-gdd.cjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * hooks/inject-using-gdd.cjs — SessionStart per-harness context injector (D-07).
+ *
+ * Node CommonJS port of hooks/inject-using-gdd.sh. Written so it runs natively on
+ * Windows (where bash is often absent or stubbed) without spawning a subshell.
+ *
+ * The forcing function GDD lacked: on every session start / /clear / compact this
+ * reads skills/using-gdd/SKILL.md (the bootstrap discipline contract) and emits
+ * it as the host harness's SessionStart "additionalContext" shape so the agent is
+ * primed with the 1%-rule + red-flags + skill-priority before it acts.
+ *
+ * Three emitted shapes (ONE JSON object on stdout, terminated by "\n"):
+ *   Cursor       (CURSOR_PLUGIN_ROOT set)        -> {"additional_context": "<escaped>"}
+ *   Claude Code  (CLAUDE_PLUGIN_ROOT set, no Cursor)
+ *                                                -> {"hookSpecificOutput":
+ *                                                     {"hookEventName": "SessionStart",
+ *                                                      "additionalContext": "<escaped>"}}
+ *   SDK-standard (neither; e.g. COPILOT_CLI)     -> {"additionalContext": "<escaped>"}
+ *
+ * Branch order: check Cursor BEFORE Claude Code — a Cursor session may also export
+ * CLAUDE_PLUGIN_ROOT, and Cursor's own var must win.
+ *
+ * Byte-format preserved: the original bash uses `printf '{"key": %s}\n' "$ESCAPED"`,
+ * which yields a single space after each colon and a trailing newline. We build the
+ * envelope by hand (using JSON.stringify only for the escaped string value) so the
+ * stdout bytes match the bash original. JSON.parse is whitespace-insensitive, so
+ * tests pass either way, but matching the wire format keeps any downstream
+ * byte-sensitive consumer happy.
+ *
+ * Silent-on-failure: every error path exits 0 (matching the bash defensive contract
+ * — a partial install or missing SKILL.md must still produce a syntactically valid
+ * JSON envelope). The bash never had non-zero exits, so neither do we.
+ *
+ * Sourcing guard: helpers are exported via module.exports; main() runs only when
+ * this file is the entry point (require.main === module). Mirrors the bash
+ * `[ "${BASH_SOURCE[0]}" = "$0" ]` pattern so tests can require this module and
+ * exercise helpers without firing the emit side-effect.
+ *
+ * NO-CASCADE (D-06): wired ONLY under SessionStart in hooks/hooks.json. Subagent
+ * spawns do not fire SessionStart, so the inject cannot cascade into a subagent's
+ * context. (Structural guarantee; behavioral proof = P33.)
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Resolve the plugin root the same way the bash original does:
+ *   CURSOR_PLUGIN_ROOT -> CLAUDE_PLUGIN_ROOT -> dirname(__file__)/..
+ * Then normalize Windows backslashes to forward slashes (matching the bash
+ * `"${ROOT//\\//}"` parameter substitution) so downstream path joins are stable.
+ *
+ * @param {NodeJS.ProcessEnv} env  Environment (defaults to process.env).
+ * @param {string} selfDir         Directory of this script (defaults to __dirname).
+ * @returns {string}               Plugin root, forward-slash normalized.
+ */
+function resolveRoot(env, selfDir) {
+  const e = env || process.env;
+  const sd = selfDir || __dirname;
+  // Bash: ROOT="${CURSOR_PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-${SELF_DIR}/..}}"
+  // The :- operator treats both unset AND empty as "use the fallback". Match that
+  // by treating empty strings as absent here too.
+  const cursor = e.CURSOR_PLUGIN_ROOT;
+  const claude = e.CLAUDE_PLUGIN_ROOT;
+  let root;
+  if (cursor && cursor.length > 0) {
+    root = cursor;
+  } else if (claude && claude.length > 0) {
+    root = claude;
+  } else {
+    root = path.join(sd, '..');
+  }
+  // Normalize backslashes -> forward slashes (Windows). Matches bash ${ROOT//\\//}.
+  return root.replace(/\\/g, '/');
+}
+
+/**
+ * Read the SKILL.md bootstrap contract. Defensive: never throw — return '' on any
+ * read failure so the emitted JSON envelope is still well-formed. Matches the
+ * bash `[[ -r "${SKILL}" ]]` guard (returns "" on missing / unreadable).
+ *
+ * Bash `CONTENT="$(cat "${SKILL}")"` strips ALL trailing newlines from the file —
+ * that's a fundamental POSIX command-substitution rule. To stay byte-identical
+ * with the original on every emitted JSON envelope, we replicate that here: trim
+ * the trailing run of LF/CRLF after reading. Interior newlines are untouched (so
+ * the multi-line round-trip the tests check still works).
+ *
+ * @param {string} root  Plugin root (already normalized).
+ * @returns {string}     File contents, or '' if missing/unreadable.
+ */
+function readSkill(root) {
+  const skillPath = `${root}/skills/using-gdd/SKILL.md`;
+  let raw;
+  try {
+    raw = fs.readFileSync(skillPath, 'utf8');
+  } catch {
+    return '';
+  }
+  // Match bash $() trailing-newline stripping. /(\r?\n)+$/ also handles CRLF
+  // line endings on Windows checkouts so a single CRLF tail strips to ''.
+  return raw.replace(/(?:\r?\n)+$/, '');
+}
+
+/**
+ * JSON-escape a string and wrap it in double-quotes — the bash original was
+ * hand-rolled in pure parameter substitution because the script must run with no
+ * jq/python dependency. In Node, JSON.stringify handles every code-point the bash
+ * version handled (backslash, double-quote, \t, \r, \n) AND the ones it didn't
+ * (other C0 controls, lone surrogates) more correctly. Output includes the
+ * surrounding quotes so callers can splice the value directly into a JSON object
+ * literal — matching the bash `printf '"%s"' "$s"` contract.
+ *
+ * @param {string} s
+ * @returns {string}  e.g. `"hello\nworld"`
+ */
+function escapeForJson(s) {
+  return JSON.stringify(String(s == null ? '' : s));
+}
+
+/**
+ * Build the harness-specific JSON envelope as the exact byte sequence the bash
+ * `printf` produces — single space after each colon, trailing `\n`. Branch order
+ * matches the bash: Cursor BEFORE Claude Code so a Cursor session that also
+ * exports CLAUDE_PLUGIN_ROOT still gets the Cursor shape.
+ *
+ * @param {string} escapedJsonValue  Already JSON-encoded string including quotes.
+ * @param {NodeJS.ProcessEnv} env    Environment (defaults to process.env).
+ * @returns {string}                 The full stdout payload, terminated by '\n'.
+ */
+function buildEnvelope(escapedJsonValue, env) {
+  const e = env || process.env;
+  const cursor = e.CURSOR_PLUGIN_ROOT;
+  const claude = e.CLAUDE_PLUGIN_ROOT;
+  if (cursor && cursor.length > 0) {
+    // Cursor: top-level additional_context.
+    return `{"additional_context": ${escapedJsonValue}}\n`;
+  }
+  if (claude && claude.length > 0) {
+    // Claude Code: hookSpecificOutput envelope (mirrors gdd-decision-injector.js).
+    return `{"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": ${escapedJsonValue}}}\n`;
+  }
+  // SDK-standard (COPILOT_CLI or none): top-level additionalContext.
+  return `{"additionalContext": ${escapedJsonValue}}\n`;
+}
+
+/**
+ * End-to-end main: resolve root, read skill, escape, emit, exit 0. All error
+ * paths swallow and still emit a well-formed envelope (silent-on-failure).
+ *
+ * @returns {number}  Always 0.
+ */
+function main() {
+  let payload;
+  try {
+    const root = resolveRoot(process.env, __dirname);
+    const content = readSkill(root);
+    const escaped = escapeForJson(content);
+    payload = buildEnvelope(escaped, process.env);
+  } catch {
+    // Belt-and-braces: if anything above unexpectedly throws (e.g. JSON.stringify
+    // on a hostile input — shouldn't happen with a string), still emit a valid
+    // empty envelope so the SessionStart pipeline never breaks.
+    payload = buildEnvelope('""', process.env);
+  }
+  // Use process.stdout.write so we don't get a console.log-added newline on top
+  // of the one already in the payload. Matches bash printf '...\n' exactly.
+  process.stdout.write(payload);
+  return 0;
+}
+
+module.exports = {
+  resolveRoot,
+  readSkill,
+  escapeForJson,
+  buildEnvelope,
+  main,
+};
+
+// Sourcing guard: only run main() when invoked as the entry point. Tests can
+// `require('./inject-using-gdd.cjs')` to exercise helpers in isolation without
+// firing the emit side-effect — mirrors the bash `[ "${BASH_SOURCE[0]}" = "$0" ]`
+// pattern.
+if (require.main === module) {
+  process.exit(main());
+}