@hegemonart/get-design-done 1.57.1 → 1.57.3

package/hooks/gdd-precompact-snapshot.js

@@ -25,14 +25,27 @@
 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 RETENTION_COUNT = 10;
 const EVENTS_TAIL_COUNT = 50;
 const DECISIONS_TAIL_COUNT = 10;
 const SCHEMA_VERSION = '1.0.0';
 
+/**
+ * Resolve the bundle of paths the hook reads/writes, anchored at `cwd`.
+ *
+ * Originally these resolved 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 differ from the project root).
+ * Resolving against `payload.cwd` matches how 8 sibling hooks already work.
+ */
+function computePaths(cwd) {
+  return {
+    snapshotDir: path.resolve(cwd, '.design', 'snapshots'),
+    stateMdPath: path.resolve(cwd, '.design', 'STATE.md'),
+    eventsPath: path.resolve(cwd, '.design', 'telemetry', 'events.jsonl'),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Harness detection (D-10)
 // ---------------------------------------------------------------------------
@@ -66,13 +79,13 @@ function getAppendEvent() {
 // STATE.md tolerant parser — extracts frontmatter + decisions + blockers
 // ---------------------------------------------------------------------------
 
-function readStateSections() {
-  if (!fs.existsSync(STATE_MD_PATH)) {
+function readStateSections(paths) {
+  if (!fs.existsSync(paths.stateMdPath)) {
     return { frontmatter: {}, decisions: [], blockers: [], session: '' };
   }
   let body;
   try {
-    body = fs.readFileSync(STATE_MD_PATH, 'utf8');
+    body = fs.readFileSync(paths.stateMdPath, 'utf8');
   } catch {
     return { frontmatter: {}, decisions: [], blockers: [], session: '' };
   }
@@ -124,11 +137,11 @@ function readStateSections() {
 // Events tail reader — JSONL-tolerant (malformed lines are skipped)
 // ---------------------------------------------------------------------------
 
-function readEventsTail(count) {
-  if (!fs.existsSync(EVENTS_PATH)) return [];
+function readEventsTail(paths, count) {
+  if (!fs.existsSync(paths.eventsPath)) return [];
   let body;
   try {
-    body = fs.readFileSync(EVENTS_PATH, 'utf8');
+    body = fs.readFileSync(paths.eventsPath, 'utf8');
   } catch {
     return [];
   }
@@ -149,16 +162,16 @@ function readEventsTail(count) {
 // Retention prune — LRU by mtime, keep last RETENTION_COUNT (D-08)
 // ---------------------------------------------------------------------------
 
-function pruneSnapshots() {
+function pruneSnapshots(paths) {
   let files;
   try {
-    files = fs.readdirSync(SNAPSHOT_DIR);
+    files = fs.readdirSync(paths.snapshotDir);
   } catch {
     return;
   }
   const jsonFiles = files
     .filter((f) => f.endsWith('.json') && f !== 'last-recap.json')
-    .map((f) => ({ name: f, full: path.join(SNAPSHOT_DIR, f), mtime: 0 }));
+    .map((f) => ({ name: f, full: path.join(paths.snapshotDir, f), mtime: 0 }));
 
   for (const entry of jsonFiles) {
     try {
@@ -186,35 +199,43 @@ function pruneSnapshots() {
 async function main() {
   const harness = detectHarness();
   if (harness === 'codex') {
-    // D-10: Codex has no PreCompact event; emit notice + exit. Phase 45 dep
-    // for full `pre-large-context-action` interception.
+    // D-10: Codex has no PreCompact event; emit notice + exit. Tracked in
+    // the runtime-parity matrix; full pre-large-context-action interception
+    // is on the roadmap.
     process.stderr.write(
       '[gdd-precompact-snapshot] this harness does not emit PreCompact; snapshots disabled\n',
     );
     process.exit(0);
   }
 
-  // Drain stdin (Claude Code may pipe a hook event JSON; we don't need it
-  // but draining avoids EPIPE on the parent's writer side).
+  // Drain stdin and extract payload.cwd. Claude Code pipes a hook-event JSON
+  // envelope including the project cwd; we need it to anchor SNAPSHOT_DIR and
+  // friends correctly when the harness's process.cwd() at module load may not
+  // match (e.g. when invoked from a worktree). Draining also avoids EPIPE on
+  // the writer side. Falls back to process.cwd() when stdin is empty or
+  // malformed (unit tests, direct invocation).
+  let buf = '';
   try {
-    if (!process.stdin.isTTY) {
-      // Best-effort, non-blocking — we have nothing time-sensitive in stdin.
-      process.stdin.on('error', () => {
-        /* swallow */
-      });
-      process.stdin.resume();
-    }
+    for await (const chunk of process.stdin) buf += chunk;
   } catch {
-    /* swallow */
+    /* 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 ts = new Date().toISOString().replace(/[:.]/g, '-');
-  const snapshotPath = path.join(SNAPSHOT_DIR, ts + '.json');
+  const snapshotPath = path.join(paths.snapshotDir, ts + '.json');
   const tmpPath = snapshotPath + '.tmp';
 
   // Ensure snapshot dir exists (mkdir -p semantics).
   try {
-    fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+    fs.mkdirSync(paths.snapshotDir, { recursive: true });
   } catch {
     /* swallow — write will fail loudly below if truly missing */
   }
@@ -240,8 +261,8 @@ async function main() {
   }
 
   try {
-    const sections = readStateSections();
-    const events = readEventsTail(EVENTS_TAIL_COUNT);
+    const sections = readStateSections(paths);
+    const events = readEventsTail(paths, EVENTS_TAIL_COUNT);
     const decisions = sections.decisions.slice(-DECISIONS_TAIL_COUNT);
     const cycleId =
       sections.frontmatter && sections.frontmatter.milestone
@@ -280,7 +301,7 @@ async function main() {
     }
 
     // Retention prune (T-27.6.05-04 DoS mitigation).
-    pruneSnapshots();
+    pruneSnapshots(paths);
 
     // Best-effort event emit.
     const appendEvent = getAppendEvent();

package/hooks/gdd-protected-paths.js

@@ -59,28 +59,160 @@ function loadProtectedPaths(cwd) {
 }
 
 /**
- * Extract a target path from a Bash command, best-effort.
- * Returns an array of candidate paths; empty if none parsed.
+ * Tokenise a string of shell-style args into individual arguments, honoring
+ * single/double quotes and basic backslash escapes. Used by the bash target
+ * extractor to get reliable arg arrays for destructive coreutils.
+ */
+function parseShellArgs(s) {
+  const args = [];
+  let current = '';
+  let inQuote = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+        args.push(current);
+        current = '';
+      } else if (ch === '\\' && i + 1 < s.length && (s[i + 1] === inQuote || s[i + 1] === '\\')) {
+        current += s[++i];
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      if (current) { args.push(current); current = ''; }
+      inQuote = ch;
+    } else if (/\s/.test(ch)) {
+      if (current) { args.push(current); current = ''; }
+    } else if (ch === '\\' && i + 1 < s.length) {
+      current += s[++i];
+    } else {
+      current += ch;
+    }
+  }
+  if (current) args.push(current);
+  return args;
+}
+
+/**
+ * Extract destructive-op file targets from one shell pipeline segment
+ * (already split on `&&`/`||`/`;`/`|`). Catches:
+ *  - rm / cp / mv / mkdir / touch / rmdir / chmod / chown / ln / tee
+ *    with ALL their non-flag args (not just the first).
+ *  - git rm / mv / restore / checkout — same treatment.
+ *  - sed -i <args> file1 [file2 ...]
+ *  - > file and >> file redirects appearing anywhere in the segment.
+ *
+ * `sudo ` prefix is stripped before dispatch.
+ */
+function extractTargetsFromSegment(seg) {
+  const targets = [];
+  const cleaned = seg.replace(/^sudo\s+/, '');
+
+  // git destructive subcommands
+  const gitMatch = cleaned.match(/^git\s+(rm|mv|restore|checkout)\b(.*)$/);
+  if (gitMatch) {
+    const args = parseShellArgs(gitMatch[2]);
+    for (const arg of args) {
+      if (!arg.startsWith('-')) targets.push(arg);
+    }
+  }
+
+  // sed -i: only treat as destructive when -i is present
+  if (/^sed\b/.test(cleaned) && /(?:^|\s)-i(?:\b|=)/.test(cleaned)) {
+    const tokens = parseShellArgs(cleaned).slice(1); // drop 'sed'
+    let i = 0;
+    while (i < tokens.length) {
+      const tok = tokens[i];
+      // BSD `sed -i ''` consumes an extra empty-string arg
+      if (tok === '-i' && i + 1 < tokens.length && tokens[i + 1] === '') {
+        i += 2;
+        continue;
+      }
+      if (tok.startsWith('-')) { i++; continue; }
+      // First non-flag arg may be either an in-line sed script or a file;
+      // path matcher will simply not match a non-path. Be permissive: queue all.
+      targets.push(tok);
+      i++;
+    }
+  }
+
+  // Coreutils destructive verbs
+  const coreutilsMatch = cleaned.match(/^(rm|cp|mv|mkdir|touch|rmdir|chmod|chown|ln|tee)\b(.*)$/);
+  if (coreutilsMatch) {
+    const args = parseShellArgs(coreutilsMatch[2]);
+    for (const arg of args) {
+      if (!arg.startsWith('-')) targets.push(arg);
+    }
+  }
+
+  // Redirect targets: > file or >> file (appear anywhere in the segment)
+  const redirects = seg.matchAll(/(?:^|[^&>])>>?\s*([^\s|;&]+)/g);
+  for (const m of redirects) targets.push(m[1]);
+
+  return targets;
+}
+
+/**
+ * Extract all candidate file paths a Bash command may mutate. Walks the
+ * command string in three passes:
+ *
+ *   1. Recursively process every `$(...)` and `\`...\`` subshell. The
+ *      subshell is evaluated by the shell and its OUTPUT substitutes into
+ *      the parent command — but the inner commands themselves ALSO run,
+ *      so anything destructive inside is a target.
+ *   2. Strip subshells from the outer command to simplify splitting.
+ *   3. Split outer command on `&&`, `||`, `;`, `|` and feed each segment
+ *      to extractTargetsFromSegment.
+ *
+ * Previous implementation called String.prototype.match() (returns only
+ * the first match) and a single regex with a `[^\\s|;&>]+` capture group.
+ * That missed:
+ *   - chained commands (`rm safe.txt && rm secret`)
+ *   - multi-arg destructive verbs (`rm a b c` — only `a` was extracted)
+ *   - subshell content (`rm $(echo secret)`)
+ *   - backtick command substitution (`rm \`echo secret\``)
+ *
+ * xargs bypass — `find protected -print0 | xargs -0 rm` — is NOT closed
+ * here, because the targets come from stdin which we can't model without
+ * a full pipeline shape analysis. The `find` segment will be checked but
+ * the subsequent xargs+rm segment carries no explicit path. Project policy
+ * should rely on `find <protected-dir>` being blocked at the upstream
+ * segment via the .git/** / reference/** globs, plus general operator
+ * caution. Future enhancement: scan pipeline for xargs-with-destructive
+ * verbs and require the upstream stage to not reference protected globs.
  */
 function extractBashTargets(command) {
   if (!command) return [];
+
   const targets = [];
-  // rm / cp / mv / mkdir trailing arg(s)
-  const rmMatch = command.match(/\b(rm|cp|mv|mkdir|touch|rmdir|chmod|chown)\s+(?:-[A-Za-z]+\s+)*([^\s|;&>]+)/);
-  if (rmMatch) targets.push(rmMatch[2]);
-  // redirect / tee
-  const redirectMatch = command.match(/[>|]\s*(?:tee\s+)?([^\s|;&]+)$/);
-  if (redirectMatch) targets.push(redirectMatch[1]);
-  // sed -i <path> (BSD and GNU variants)
-  const sedMatch = command.match(/\bsed\s+-i(?:\s*['"][^'"]*['"])?\s+(?:-[A-Za-z]+\s+)*(?:['"][^'"]*['"]\s+)?([^\s|;&]+)/);
-  if (sedMatch) targets.push(sedMatch[1]);
-  // git rm / git mv
-  const gitMatch = command.match(/\bgit\s+(rm|mv|restore|checkout)\s+(?:-[A-Za-z]+\s+)*([^\s|;&]+)/);
-  if (gitMatch) targets.push(gitMatch[2]);
-
-  return targets
-    .filter(Boolean)
-    .map(p => p.replace(/^['"]|['"]$/g, ''));
+
+  // 1. Recursive subshell scan.
+  const SUBSHELL_RE = /\$\(([^()]*)\)|`([^`]*)`/g;
+  let m;
+  while ((m = SUBSHELL_RE.exec(command)) !== null) {
+    targets.push(...extractBashTargets(m[1] !== undefined ? m[1] : m[2]));
+  }
+
+  // 2. Strip subshells from outer command.
+  const stripped = command.replace(SUBSHELL_RE, '');
+
+  // 3. Split on shell separators and process each segment.
+  const segments = stripped.split(/\s*(?:&&|\|\||;|\|)\s*/);
+  for (const segment of segments) {
+    const seg = segment.trim();
+    if (!seg) continue;
+    targets.push(...extractTargetsFromSegment(seg));
+  }
+
+  // Dedup + strip surrounding quotes.
+  return [
+    ...new Set(
+      targets
+        .filter(Boolean)
+        .map((p) => p.replace(/^['"]|['"]$/g, '')),
+    ),
+  ];
 }
 
 async function main() {

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": [