@nforma.ai/nforma 0.2.1 → 0.29.0

package/hooks/dist/nf-session-start.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// hooks/nf-session-start.js
+// SessionStart hook — syncs nForma keychain secrets into ~/.claude.json
+// on every session start so mcpServers env blocks always reflect current keychain state.
+//
+// Runs synchronously (hook expects process to exit) — uses async IIFE with catch.
+
+'use strict';
+
+const path = require('path');
+const os   = require('os');
+const fs   = require('fs');
+
+const { loadConfig, shouldRunHook } = require('./config-loader');
+
+// ─── Stdin accumulation (for hook input JSON containing cwd) ─────────────────
+let _stdinRaw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => _stdinRaw += c);
+
+let _stdinReady;
+const _stdinPromise = new Promise(resolve => { _stdinReady = resolve; });
+process.stdin.on('end', () => _stdinReady());
+
+// Locate secrets.cjs — try installed global path first, then local dev path.
+//
+// IMPORTANT: install.js copies bin/*.cjs to ~/.claude/nf-bin/ (not ~/.claude/nf/bin/).
+// See bin/install.js line ~1679: binDest = path.join(targetDir, 'nf-bin')
+// where targetDir = os.homedir() + '/.claude'.
+function findSecrets() {
+  const candidates = [
+    path.join(os.homedir(), '.claude', 'nf-bin', 'secrets.cjs'),  // installed path
+    path.join(__dirname, '..', 'bin', 'secrets.cjs'),                 // local dev path
+  ];
+  for (const p of candidates) {
+    try {
+      return require(p);
+    } catch (_) {}
+  }
+  return null;
+}
+
+// ─── State reminder parser ──────────────────────────────────────────────────
+
+/**
+ * Parse STATE.md content for an in-progress phase and return a terse reminder.
+ * Returns null if no reminder is needed (complete, not started, or missing fields).
+ * @param {string} stateContent - Raw STATE.md content.
+ * @returns {string|null}
+ */
+function parseStateForReminder(stateContent) {
+  if (!stateContent || typeof stateContent !== 'string') return null;
+
+  const phaseMatch = stateContent.match(/Phase:\s*(.+)/);
+  const statusMatch = stateContent.match(/Status:\s*(.+)/);
+  const planMatch = stateContent.match(/Plan:\s*(.+)/);
+  const lastMatch = stateContent.match(/Last activity:\s*(.+)/);
+
+  if (!phaseMatch) return null;
+  if (!statusMatch) return null;
+
+  const status = statusMatch[1].trim();
+  if (status === 'Complete' || status === 'Not started') return null;
+
+  const phase = phaseMatch[1].trim();
+  const plan = planMatch ? planMatch[1].trim() : 'unknown plan';
+  const lastActivity = lastMatch ? lastMatch[1].trim() : 'unknown';
+
+  return 'SESSION STATE REMINDER: Phase ' + phase + ' -- ' + plan + ' -- ' + status + ' (last: ' + lastActivity + ')';
+}
+
+(async () => {
+  // Resolve project cwd from hook input JSON
+  await _stdinPromise;
+  let _hookCwd = process.cwd();
+  try { _hookCwd = JSON.parse(_stdinRaw).cwd || process.cwd(); } catch (_) {}
+
+  // Profile guard — exit early if this hook is not active for the current profile
+  const config = loadConfig(_hookCwd);
+  const profile = config.hook_profile || 'standard';
+  if (!shouldRunHook('nf-session-start', profile)) {
+    process.exit(0);
+  }
+
+  const secrets = findSecrets();
+  if (!secrets) {
+    // silently skip — nForma may not be installed yet or keytar absent
+    process.exit(0);
+  }
+  try {
+    await secrets.syncToClaudeJson(secrets.SERVICE);
+  } catch (e) {
+    // Non-fatal — write to stderr for debug logs, but never block session start
+    process.stderr.write('[nf-session-start] sync error: ' + e.message + '\n');
+  }
+
+  // Populate CCR config from keytar (fail-silent — CCR may not be installed)
+  try {
+    const { execFileSync } = require('child_process');
+    const nodeFsRef = require('fs');
+    const ccrCandidates = [
+      path.join(os.homedir(), '.claude', 'nf-bin', 'ccr-secure-config.cjs'),
+      path.join(__dirname, '..', 'bin', 'ccr-secure-config.cjs'),
+    ];
+    let ccrConfigPath = null;
+    for (const p of ccrCandidates) {
+      if (nodeFsRef.existsSync(p)) { ccrConfigPath = p; break; }
+    }
+    if (ccrConfigPath) {
+      execFileSync(process.execPath, [ccrConfigPath], { stdio: 'pipe', timeout: 10000 });
+    }
+  } catch (e) {
+    process.stderr.write('[nf-session-start] CCR config error: ' + e.message + '\n');
+  }
+
+  // Collect all additionalContext pieces — write once at the end
+  const _contextPieces = [];
+
+  // Telemetry surfacing — inject top unsurfaced issue as additionalContext
+  // Guard: only active when running inside the nForma dev repo itself
+  try {
+    const pkgPath = path.join(_hookCwd, 'package.json');
+    const isNfRepo = fs.existsSync(pkgPath) &&
+      JSON.parse(fs.readFileSync(pkgPath, 'utf8')).name === 'nforma';
+    const fixesPath = path.join(_hookCwd, '.planning', 'telemetry', 'pending-fixes.json');
+    if (isNfRepo && fs.existsSync(fixesPath)) {
+      const fixes = JSON.parse(fs.readFileSync(fixesPath, 'utf8'));
+      const issue = (fixes.issues || []).find(i => !i.surfaced && i.priority >= 50);
+      if (issue) {
+        issue.surfaced = true;
+        issue.surfacedAt = new Date().toISOString();
+        fs.writeFileSync(fixesPath, JSON.stringify(fixes, null, 2), 'utf8');
+        _contextPieces.push('Telemetry alert [priority=' + issue.priority + ']: ' + issue.description + '\nSuggested fix: ' + issue.action);
+      }
+    }
+  } catch (_) {}
+
+  // Session state reminder — inject brief context when work is in progress
+  try {
+    const statePath = path.join(_hookCwd, '.planning', 'STATE.md');
+    if (fs.existsSync(statePath)) {
+      const stateContent = fs.readFileSync(statePath, 'utf8');
+      const reminder = parseStateForReminder(stateContent);
+      if (reminder) {
+        _contextPieces.push(reminder);
+      }
+    }
+  } catch (_) {}
+
+  // Write combined additionalContext output (once)
+  if (_contextPieces.length > 0) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: _contextPieces.join('\n\n') }
+    }));
+  }
+
+  // Memory staleness check — warn about outdated MEMORY.md entries
+  try {
+    const validateMemoryCandidates = [
+      path.join(os.homedir(), '.claude', 'nf-bin', 'validate-memory.cjs'),
+      path.join(__dirname, '..', 'bin', 'validate-memory.cjs'),
+    ];
+    let validateMemoryMod = null;
+    for (const p of validateMemoryCandidates) {
+      try { validateMemoryMod = require(p); break; } catch (_) {}
+    }
+    if (validateMemoryMod) {
+      const { findings } = validateMemoryMod.validateMemory({ cwd: _hookCwd, quiet: true });
+      if (findings.length > 0) {
+        const summary = findings
+          .map(f => '[memory-check] ' + f.message)
+          .join('\n');
+        process.stderr.write(summary + '\n');
+      }
+    }
+  } catch (_) {}
+
+  process.exit(0);
+})();
+
+// Export for unit testing
+if (typeof module !== 'undefined') {
+  module.exports = module.exports || {};
+  module.exports.parseStateForReminder = parseStateForReminder;
+}

package/hooks/dist/{qgsd-slot-correlator.js → nf-slot-correlator.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-// hooks/qgsd-slot-correlator.js
-// SubagentStart hook — writes a correlation placeholder file for qgsd-quorum-slot-worker subagents.
+// hooks/nf-slot-correlator.js
+// SubagentStart hook — writes a correlation placeholder file for nf-quorum-slot-worker subagents.
 //
 // At SubagentStart time, the prompt/slot name is not available in the hook payload.
 // This hook writes a stub correlation file { agent_id, ts, slot: null } so the
@@ -8,7 +8,7 @@
 // The slot is resolved from last_assistant_message preamble by the token collector.
 //
 // Guards:
-//   - Only processes agent_type === 'qgsd-quorum-slot-worker' (exits 0 otherwise)
+//   - Only processes agent_type === 'nf-quorum-slot-worker' (exits 0 otherwise)
 //   - If agent_id is absent: exits 0 gracefully
 //   - Fail-open: any unhandled error exits 0
 
@@ -16,6 +16,7 @@
 
 const fs   = require('fs');
 const path = require('path');
+const { loadConfig, shouldRunHook } = require('./config-loader');
 
 function main() {
   let raw = '';
@@ -25,8 +26,15 @@ function main() {
     try {
       const input = JSON.parse(raw);
 
-      // Guard: only process qgsd-quorum-slot-worker subagents
-      if (input.agent_type !== 'qgsd-quorum-slot-worker') {
+      // Profile guard — exit early if this hook is not active for the current profile
+      const config = loadConfig();
+      const profile = config.hook_profile || 'standard';
+      if (!shouldRunHook('nf-slot-correlator', profile)) {
+        process.exit(0);
+      }
+
+      // Guard: only process nf-quorum-slot-worker subagents
+      if (input.agent_type !== 'nf-quorum-slot-worker') {
         process.exit(0);
       }
 

package/hooks/dist/{qgsd-spec-regen.js → nf-spec-regen.js}

@@ -1,6 +1,6 @@
 'use strict';
-// hooks/qgsd-spec-regen.js
-// PostToolUse hook: when Claude writes to qgsd-workflow.machine.ts,
+// hooks/nf-spec-regen.js
+// PostToolUse hook: when Claude writes to nf-workflow.machine.ts,
 // automatically trigger generate-formal-specs.cjs to regenerate TLA+/Alloy specs.
 //
 // LOOP-02 (v0.21-03): Self-Calibrating Feedback Loops
@@ -16,6 +16,7 @@
 const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const { loadConfig, shouldRunHook } = require('./config-loader');
 
 let raw = '';
 process.stdin.setEncoding('utf8');
@@ -23,11 +24,19 @@ process.stdin.on('data', (chunk) => { raw += chunk; });
 process.stdin.on('end', () => {
   try {
     const input = JSON.parse(raw);
+
+    // Profile guard — exit early if this hook is not active for the current profile
+    const config = loadConfig(input.cwd || process.cwd());
+    const profile = config.hook_profile || 'standard';
+    if (!shouldRunHook('nf-spec-regen', profile)) {
+      process.exit(0);
+    }
+
     const toolName = input.tool_name || '';
     const filePath = (input.tool_input && input.tool_input.file_path) || '';
 
-    // Only act on Write calls to qgsd-workflow.machine.ts
-    if (toolName !== 'Write' || !filePath.includes('qgsd-workflow.machine.ts')) {
+    // Only act on Write calls to nf-workflow.machine.ts
+    if (toolName !== 'Write' || !filePath.includes('nf-workflow.machine.ts')) {
       process.exit(0); // No-op — not a machine file write
     }
 
@@ -50,16 +59,16 @@ process.stdin.on('end', () => {
             (result.error ? String(result.error) : '');
     }
 
-    // Also regenerate QGSDQuorum_xstate.tla (xstate-to-tla.cjs)
+    // Also regenerate NFQuorum_xstate.tla (xstate-to-tla.cjs)
     const xstateScript = path.join(cwd, 'bin', 'xstate-to-tla.cjs');
-    const machineFile = path.join(cwd, 'src', 'machines', 'qgsd-workflow.machine.ts');
-    const guardsConfig = path.join(cwd, '.planning', 'formal', 'tla', 'guards', 'qgsd-workflow.json');
+    const machineFile = path.join(cwd, 'src', 'machines', 'nf-workflow.machine.ts');
+    const guardsConfig = path.join(cwd, '.planning', 'formal', 'tla', 'guards', 'nf-workflow.json');
 
     if (fs.existsSync(xstateScript) && fs.existsSync(guardsConfig)) {
       const xstateResult = spawnSync(process.execPath, [
         xstateScript, machineFile,
         '--config=' + guardsConfig,
-        '--module=QGSDQuorum'
+        '--module=NFQuorum'
       ], {
         encoding: 'utf8',
         cwd: cwd,

package/hooks/dist/{qgsd-statusline.js → nf-statusline.js}

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { loadConfig, shouldRunHook } = require('./config-loader');
 
 // Read JSON from stdin
 let input = '';
@@ -13,6 +14,14 @@ process.stdin.on('data', chunk => input += chunk);
 process.stdin.on('end', () => {
   try {
     const data = JSON.parse(input);
+
+    // Profile guard — exit early if this hook is not active for the current profile
+    const config = loadConfig(data.workspace?.current_dir || process.cwd());
+    const profile = config.hook_profile || 'standard';
+    if (!shouldRunHook('nf-statusline', profile)) {
+      process.exit(0);
+    }
+
     const model = data.model?.display_name || 'Claude';
     const dir = data.workspace?.current_dir || process.cwd();
     const session = data.session_id || '';
@@ -66,14 +75,14 @@ process.stdin.on('end', () => {
       }
     }
 
-    // QGSD update available?
+    // nForma update available?
     let gsdUpdate = '';
-    const cacheFile = path.join(homeDir, '.claude', 'cache', 'qgsd-update-check.json');
+    const cacheFile = path.join(homeDir, '.claude', 'cache', 'nf-update-check.json');
     if (fs.existsSync(cacheFile)) {
       try {
         const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
         if (cache.update_available) {
-          gsdUpdate = '\x1b[33m⬆ /qgsd:update\x1b[0m │ ';
+          gsdUpdate = '\x1b[33m⬆ /nf:update\x1b[0m │ ';
         }
       } catch (e) {}
     }

package/hooks/dist/{qgsd-stop.js → nf-stop.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// hooks/qgsd-stop.js
+// hooks/nf-stop.js
 // Stop hook — quorum verification gate for GSD planning commands.
 //
 // Reads JSON from stdin (Claude Code Stop event payload), applies guards in
@@ -7,9 +7,9 @@
 // evidence. Blocks with decision:block if a planning command was issued but
 // quorum tool calls are missing. Fails open on all errors.
 //
-// Config: ~/.claude/qgsd.json (two-layer merge via shared config-loader)
+// Config: ~/.claude/nf.json (two-layer merge via shared config-loader)
 // Unavailability: reads ~/.claude.json mcpServers to detect which models are installed
-//   (QGSD_CLAUDE_JSON env var overrides the path — for testing only)
+//   (NF_CLAUDE_JSON env var overrides the path — for testing only)
 
 'use strict';
 
@@ -17,9 +17,15 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const { loadConfig, DEFAULT_CONFIG, slotToToolCall } = require('./config-loader');
+const { loadConfig, DEFAULT_CONFIG, slotToToolCall, shouldRunHook } = require('./config-loader');
 const { schema_version } = require('./conformance-schema.cjs');
 
+// Cache module — fail-open: if require fails, all cache logic is skipped
+let cacheModule = null;
+try {
+  cacheModule = require(path.join(__dirname, '..', 'bin', 'quorum-cache.cjs'));
+} catch (_) { /* fail-open: cache unavailable */ }
+
 // Appends a structured conformance event to .planning/conformance-events.jsonl.
 // Uses appendFileSync (atomic for writes < POSIX PIPE_BUF = 4096 bytes).
 // Always wrapped in try/catch — hooks are fail-open; never crashes on logging failure.
@@ -30,14 +36,14 @@ function appendConformanceEvent(event) {
     const logPath = pp.resolve(process.cwd(), 'conformance-events');
     fs.appendFileSync(logPath, JSON.stringify(event) + '\n', 'utf8');
   } catch (err) {
-    process.stderr.write('[qgsd] conformance log write failed: ' + err.message + '\n');
+    process.stderr.write('[nf] conformance log write failed: ' + err.message + '\n');
   }
 }
 
-// Builds the regex that matches /gsd:<quorum-command> or /qgsd:<quorum-command> in any text.
+// Builds the regex that matches /nf:<cmd>, /gsd:<cmd>, or /qgsd:<cmd> in any text.
 function buildCommandPattern(quorumCommands) {
   const escaped = quorumCommands.map(c => c.replace(/-/g, '\\-'));
-  return new RegExp('\\/q?gsd:(' + escaped.join('|') + ')');
+  return new RegExp('\\/(nf|q?gsd):(' + escaped.join('|') + ')');
 }
 
 // Returns true if a parsed JSONL user entry is a human text message.
@@ -119,9 +125,9 @@ function hasQuorumCommand(currentTurnLines, cmdPattern) {
   return false;
 }
 
-// Extracts the matched /gsd:<command> or /qgsd:<command> text from the first matching user line.
+// Extracts the matched /nf:<cmd>, /gsd:<cmd>, or /qgsd:<cmd> text from the first matching user line.
 // Uses XML-tag-first strategy: prefers the <command-name> tag for accurate command identification.
-// Falls back to first 300 chars of message text, then to '/qgsd:plan-phase' as ultimate fallback.
+// Falls back to first 300 chars of message text, then to '/nf:plan-phase' as ultimate fallback.
 function extractCommand(currentTurnLines, cmdPattern) {
   for (const line of currentTurnLines) {
     try {
@@ -148,12 +154,12 @@ function extractCommand(currentTurnLines, cmdPattern) {
       // Skip malformed lines
     }
   }
-  return '/qgsd:plan-phase';
+  return '/nf:plan-phase';
 }
 
-// Returns true if any assistant turn used Task(subagent_type=qgsd-quorum-slot-worker).
+// Returns true if any assistant turn used Task(subagent_type=nf-quorum-slot-worker).
 // Slot-workers are the inline dispatch mechanism — one per active slot per round.
-// Replaced qgsd-quorum-orchestrator (deprecated quick-103) as full quorum evidence.
+// Replaced nf-quorum-orchestrator (deprecated quick-103) as full quorum evidence.
 function wasSlotWorkerUsed(currentTurnLines) {
   for (const line of currentTurnLines) {
     try {
@@ -165,7 +171,7 @@ function wasSlotWorkerUsed(currentTurnLines) {
         if (block.type !== 'tool_use' || block.name !== 'Task') continue;
         const input = block.input || {};
         const subagentType = input.subagent_type || input.subagentType || '';
-        if (subagentType === 'qgsd-quorum-slot-worker') return true;
+        if (subagentType === 'nf-quorum-slot-worker') return true;
       }
     } catch { /* skip */ }
   }
@@ -281,7 +287,7 @@ function buildAgentPool(config) {
 // Returns an array of derived tool prefixes (e.g. ['mcp__codex-cli-1__', 'mcp__gemini-cli-1__']).
 // Returns null if the file is missing or malformed — callers treat null as "unknown" (conservative).
 //
-// TESTING ONLY: set QGSD_CLAUDE_JSON env var to override the file path.
+// TESTING ONLY: set NF_CLAUDE_JSON env var to override the file path.
 // In production, always reads ~/.claude.json.
 //
 // KNOWN LIMITATION: Only reads ~/.claude.json (user-scoped MCPs). Project-scoped MCPs
@@ -289,14 +295,14 @@ function buildAgentPool(config) {
 // project level, it will be classified as unavailable and skipped (fail-open).
 // In practice, quorum models (Codex, Gemini, OpenCode) are global tools.
 function getAvailableMcpPrefixes() {
-  const claudeJsonPath = process.env.QGSD_CLAUDE_JSON || path.join(os.homedir(), '.claude.json');
+  const claudeJsonPath = process.env.NF_CLAUDE_JSON || path.join(os.homedir(), '.claude.json');
   if (!fs.existsSync(claudeJsonPath)) return null;
   try {
     const d = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
     const servers = d.mcpServers || {};
     return Object.keys(servers).map(name => 'mcp__' + name + '__');
   } catch (e) {
-    process.stderr.write('[qgsd] WARNING: Could not parse ~/.claude.json: ' + e.message + '\n');
+    process.stderr.write('[nf] WARNING: Could not parse ~/.claude.json: ' + e.message + '\n');
     return null;
   }
 }
@@ -313,6 +319,35 @@ const ARTIFACT_PATTERNS = [
   /PROJECT\.md/,      // PROJECT.md (new-project early commit)
 ];
 
+// Counts the number of distinct quorum dispatch rounds in the current turn.
+// A dispatch round is one assistant message that contains at least one Task tool_use
+// block targeting nf-quorum-slot-worker. Multiple parallel dispatches within one
+// assistant message count as a single round (they are dispatched simultaneously).
+// Returns Math.max(1, rounds) — at least round 1 even if no explicit dispatch detected.
+function countDeliberationRounds(currentTurnLines) {
+  let rounds = 0;
+  for (const line of currentTurnLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== 'assistant') continue;
+      const content = entry.message && entry.message.content;
+      if (!Array.isArray(content)) continue;
+      let hasSlotWorker = false;
+      for (const block of content) {
+        if (block.type === 'tool_use' && block.name === 'Task') {
+          const inputStr = JSON.stringify(block.input || {});
+          if (inputStr.includes('nf-quorum-slot-worker')) {
+            hasSlotWorker = true;
+            break; // One per assistant message — no need to check more blocks
+          }
+        }
+      }
+      if (hasSlotWorker) rounds++;
+    } catch { /* skip malformed lines */ }
+  }
+  return Math.max(1, rounds);
+}
+
 // Returns true if the current turn contains a Bash tool_use block that BOTH:
 // (a) invokes gsd-tools.cjs commit, AND
 // (b) references a planning artifact file path (not codebase/*.md).
@@ -401,6 +436,54 @@ function deriveMissingToolName(modelKey, modelDef) {
   return prefix + modelKey;
 }
 
+// Returns true if any user entry in currentTurnLines contains the NF_CACHE_HIT marker.
+// This marker is injected by nf-prompt.js when a valid cache hit is found.
+function hasCacheHitMarker(currentTurnLines) {
+  for (const line of currentTurnLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== 'user') continue;
+      const content = entry.message?.content;
+      let text = '';
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .filter(c => c?.type === 'text')
+          .map(c => c.text || '')
+          .join('');
+      }
+      if (text.includes('<!-- NF_CACHE_HIT -->')) return true;
+    } catch { /* skip malformed lines */ }
+  }
+  return false;
+}
+
+// Extracts the cache key from NF_CACHE_KEY marker in currentTurnLines.
+// Returns the hex string or null if not found.
+function extractCacheKey(currentTurnLines) {
+  const keyPattern = /<!-- NF_CACHE_KEY:([a-f0-9]+) -->/;
+  for (const line of currentTurnLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== 'user') continue;
+      const content = entry.message?.content;
+      let text = '';
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .filter(c => c?.type === 'text')
+          .map(c => c.text || '')
+          .join('');
+      }
+      const m = text.match(keyPattern);
+      if (m) return m[1];
+    } catch { /* skip malformed lines */ }
+  }
+  return null;
+}
+
 function main() {
   let raw = '';
   process.stdin.setEncoding('utf8');
@@ -426,6 +509,12 @@ function main() {
 
       const config = loadConfig();
 
+      // Profile guard — exit early if this hook is not active for the current profile
+      const profile = config.hook_profile || 'standard';
+      if (!shouldRunHook('nf-stop', profile)) {
+        process.exit(0);
+      }
+
       // Read and split transcript JSONL; skip empty lines
       const lines = fs.readFileSync(input.transcript_path, 'utf8')
         .split('\n')
@@ -435,7 +524,10 @@ function main() {
       const currentTurnLines = getCurrentTurnLines(lines);
 
       // Build command pattern once; reuse for detection and extraction
-      const cmdPattern = buildCommandPattern(config.quorum_commands);
+      // Strict mode: match ANY /nf: or /gsd: or /qgsd: command, not just quorum_commands list.
+      const cmdPattern = profile === 'strict'
+        ? /\/(nf|q?gsd):[\w][\w-]*/
+        : buildCommandPattern(config.quorum_commands);
 
       // GUARD 4: Only enforce quorum if a planning command is in current turn (STOP-06)
       if (!hasQuorumCommand(currentTurnLines, cmdPattern)) {
@@ -469,6 +561,24 @@ function main() {
         process.exit(0); // Solo mode: Claude's vote is the quorum — no block
       }
 
+      // GUARD 7: Cache hit bypass — nf-prompt.js validated the cache entry and injected
+      // the NF_CACHE_HIT marker. Trust it: the entry was completed, within TTL, and
+      // matches git HEAD + quorum_active composition (EventualConsensus preserved).
+      if (hasCacheHitMarker(currentTurnLines)) {
+        appendConformanceEvent({
+          ts:              new Date().toISOString(),
+          phase:           'DECIDING',
+          action:          'quorum_complete',
+          cache_hit:       true,
+          pass_at_k:       0,
+          slots_available: 0,
+          vote_result:     0,
+          outcome:         'APPROVE',
+          schema_version,
+        });
+        process.exit(0); // Cache hit: quorum approved via cached result
+      }
+
       // Build agent pool from config
       const agentPool = buildAgentPool(config);
 
@@ -481,7 +591,7 @@ function main() {
       }
 
       // Ceiling: require maxSize successful (non-error) responses from the full pool.
-      // Named maxSize for consistency with qgsd-prompt.js and the config schema.
+      // Named maxSize for consistency with nf-prompt.js and the config schema.
       // --n N override: N total participants means N-1 external models required.
       const maxSize = quorumSizeOverride !== null && quorumSizeOverride > 1
         ? quorumSizeOverride - 1  // --n N means N-1 external models required
@@ -532,10 +642,34 @@ function main() {
         process.exit(0);
       }
 
+      // Cache backfill: update pending cache entry with vote result after successful quorum
+      if (cacheModule) {
+        try {
+          const cKey = extractCacheKey(currentTurnLines);
+          if (cKey) {
+            const cacheDir = path.join(process.cwd(), '.planning', '.quorum-cache');
+            const pendingEntry = cacheModule.readCache(cKey, cacheDir);
+            // readCache returns null for pending entries (no completed field) — read raw instead
+            const cacheFilePath = path.join(cacheDir, `${cKey}.json`);
+            if (fs.existsSync(cacheFilePath)) {
+              const rawEntry = JSON.parse(fs.readFileSync(cacheFilePath, 'utf8'));
+              rawEntry.vote_result = successCount;
+              rawEntry.outcome = 'APPROVE';
+              rawEntry.completed = new Date().toISOString();
+              cacheModule.writeCache(cKey, rawEntry, cacheDir);
+            }
+          }
+        } catch (backfillErr) {
+          // Fail-open: backfill failure never blocks quorum approval
+          process.stderr.write('[nf] cache backfill failed (fail-open): ' + (backfillErr.message || backfillErr) + '\n');
+        }
+      }
+
       appendConformanceEvent({
         ts:              new Date().toISOString(),
         phase:           'DECIDING',
         action:          'quorum_complete',
+        pass_at_k:       countDeliberationRounds(currentTurnLines),
         slots_available: agentPool.length,
         vote_result:     successCount,
         outcome:         'APPROVE',

package/hooks/dist/{qgsd-token-collector.js → nf-token-collector.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-// hooks/qgsd-token-collector.js
+// hooks/nf-token-collector.js
 // SubagentStop hook — reads agent_transcript_path, sums message.usage fields,
 // appends a token record to .planning/token-usage.jsonl.
 //
 // Guards:
-//   - Only processes agent_type === 'qgsd-quorum-slot-worker' (exits 0 otherwise)
+//   - Only processes agent_type === 'nf-quorum-slot-worker' (exits 0 otherwise)
 //   - If transcript path is absent or missing: writes null-token record and exits 0 (fail-open)
 //   - isSidechain === true entries are excluded from token sum
 //   - isApiErrorMessage === true entries are excluded from token sum
@@ -15,6 +15,7 @@
 
 const fs   = require('fs');
 const path = require('path');
+const { loadConfig, shouldRunHook } = require('./config-loader');
 
 // Resolve slot name from correlation file or last_assistant_message preamble.
 // Order:
@@ -78,8 +79,15 @@ function main() {
     try {
       const input = JSON.parse(raw);
 
-      // Guard: only process qgsd-quorum-slot-worker subagents
-      if (input.agent_type !== 'qgsd-quorum-slot-worker') {
+      // Profile guard — exit early if this hook is not active for the current profile
+      const config = loadConfig();
+      const profile = config.hook_profile || 'standard';
+      if (!shouldRunHook('nf-token-collector', profile)) {
+        process.exit(0);
+      }
+
+      // Guard: only process nf-quorum-slot-worker subagents
+      if (input.agent_type !== 'nf-quorum-slot-worker') {
         process.exit(0);
       }