@nforma.ai/nforma 0.2.1 → 0.28.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/nf-spec-regen.test.js

@@ -0,0 +1,73 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Wave 0 RED stubs for LOOP-02: hooks/nf-spec-regen.js
+// These tests define the contract. They will fail until Plan 03 implements the hook.
+
+function runHook(inputPayload) {
+  const hookPath = path.join(__dirname, 'nf-spec-regen.js');
+  const result = spawnSync(process.execPath, [hookPath], {
+    input: JSON.stringify(inputPayload),
+    encoding: 'utf8',
+    timeout: 15000,
+  });
+  return result;
+}
+
+test('LOOP-02: nf-spec-regen.js exits 0 and is a no-op for non-Write tool events', () => {
+  const result = runHook({
+    tool_name: 'Read',
+    tool_input: { file_path: '/some/file.ts' },
+    tool_response: {},
+    cwd: process.cwd(),
+    context_window: {}
+  });
+  // RED: script does not exist yet
+  assert.strictEqual(result.status, 0, 'LOOP-02: hook must exit 0 for non-Write tools. Not yet implemented.');
+});
+
+test('LOOP-02: nf-spec-regen.js exits 0 and is a no-op for Write to non-machine file', () => {
+  const result = runHook({
+    tool_name: 'Write',
+    tool_input: { file_path: '/some/other-file.ts' },
+    tool_response: {},
+    cwd: process.cwd(),
+    context_window: {}
+  });
+  assert.strictEqual(result.status, 0, 'LOOP-02: hook must exit 0 for Write to non-machine file. Not yet implemented.');
+  // Should produce no output or empty additionalContext for non-matching files
+});
+
+test('LOOP-02: nf-spec-regen.js exits 0 for Write to nf-workflow.machine.ts and returns additionalContext', () => {
+  const result = runHook({
+    tool_name: 'Write',
+    tool_input: { file_path: '/Users/jonathanborduas/code/QGSD/src/machines/nf-workflow.machine.ts' },
+    tool_response: {},
+    cwd: '/Users/jonathanborduas/code/QGSD',
+    context_window: {}
+  });
+  assert.strictEqual(result.status, 0, 'LOOP-02: hook must exit 0 for machine file write. Not yet implemented.');
+  // Output must be valid JSON with additionalContext field
+  if (result.stdout && result.stdout.trim()) {
+    let parsed;
+    assert.doesNotThrow(() => { parsed = JSON.parse(result.stdout); },
+      'LOOP-02: stdout must be valid JSON when hook fires. Not yet implemented.');
+    assert.ok(
+      parsed && parsed.hookSpecificOutput && parsed.hookSpecificOutput.additionalContext,
+      'LOOP-02: output must contain hookSpecificOutput.additionalContext. Not yet implemented.'
+    );
+  }
+});
+
+test('LOOP-02: nf-spec-regen.js exits 0 (fail-open) on malformed stdin JSON', () => {
+  const hookPath = path.join(__dirname, 'nf-spec-regen.js');
+  const result = spawnSync(process.execPath, [hookPath], {
+    input: 'not-valid-json',
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  assert.strictEqual(result.status, 0, 'LOOP-02: hook must exit 0 on malformed JSON (fail-open). Not yet implemented.');
+});

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/nf-statusline.test.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Test suite for hooks/nf-statusline.js
+// Uses Node.js built-in test runner: node --test hooks/nf-statusline.test.js
+//
+// Each test spawns the hook as a child process with mock stdin (JSON payload).
+// Captures stdout + exit code. The hook reads JSON from stdin and writes
+// formatted statusline text to stdout.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HOOK_PATH = path.join(__dirname, 'nf-statusline.js');
+
+// Helper: run the hook with a given stdin JSON payload and optional extra env vars
+function runHook(stdinPayload, extraEnv) {
+  const input = typeof stdinPayload === 'string'
+    ? stdinPayload
+    : JSON.stringify(stdinPayload);
+
+  const result = spawnSync('node', [HOOK_PATH], {
+    input,
+    encoding: 'utf8',
+    timeout: 5000,
+    env: extraEnv ? { ...process.env, ...extraEnv } : process.env,
+  });
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    exitCode: result.status,
+  };
+}
+
+// Helper: create a temp directory structure, write a file inside it, return tempDir
+function makeTempDir(suffix) {
+  const dir = path.join(os.tmpdir(), `nf-sl-test-${Date.now()}-${suffix}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// --- Test Cases ---
+
+// TC1: Minimal payload — stdout contains model name and directory basename
+test('TC1: minimal payload includes model name and directory name', () => {
+  const { stdout, exitCode } = runHook({
+    model: { display_name: 'TestModel' },
+    workspace: { current_dir: '/tmp/myproject' },
+  });
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.ok(stdout.includes('TestModel'), 'stdout must include model name "TestModel"');
+  assert.ok(stdout.includes('myproject'), 'stdout must include directory basename "myproject"');
+});
+
+// TC2: Context at 100% remaining (0% used) → green bar, 0%
+// rawUsed = 100 - 100 = 0; scaled = round(0 / 80 * 100) = 0; filled = 0 → all empty blocks
+test('TC2: context at 100% remaining shows all-empty bar at 0%', () => {
+  const { stdout, exitCode } = runHook({
+    model: { display_name: 'M' },
+    context_window: { remaining_percentage: 100 },
+  });
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.ok(stdout.includes('░░░░░░░░░░'), 'stdout must include all-empty bar (0% used)');
+  assert.ok(stdout.includes('0%'), 'stdout must include 0%');
+});
+
+// TC3: Context at 20% remaining (80% used → scaled 100%) → full bar, 100%
+// rawUsed = 80; scaled = round(80/80 * 100) = 100; filled = 10 → full blocks
+// At 100% scaled, the hook uses the skull emoji and blink+red ANSI code
+test('TC3: context at 20% remaining shows full bar at 100% (skull zone)', () => {
+  const { stdout, exitCode } = runHook({
+    model: { display_name: 'M' },
+    context_window: { remaining_percentage: 20 },
+  });
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.ok(stdout.includes('100%'), 'stdout must include 100%');
+  assert.ok(stdout.includes('██████████'), 'stdout must include full bar (10 filled segments)');
+});
+
+// TC4: Context at 51% remaining (49% used → scaled 61%) → green zone (scaled < 63)
+// rawUsed = 49; scaled = round(49/80 * 100) = round(61.25) = 61; 61 < 63 → green
+test('TC4: context at 51% remaining shows 61% in green (below 63% yellow threshold)', () => {
+  const { stdout, exitCode } = runHook({
+    model: { display_name: 'M' },
+    context_window: { remaining_percentage: 51 },
+  });
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.ok(stdout.includes('61%'), 'stdout must include 61%');
+  assert.ok(stdout.includes('\x1b[32m'), 'stdout must include green ANSI code \\x1b[32m');
+});
+
+// TC5: Context at 36% remaining (64% used → scaled 80%) → yellow zone (63 <= scaled < 81)
+// rawUsed = 64; scaled = round(64/80 * 100) = round(80) = 80; 63 <= 80 < 81 → yellow
+test('TC5: context at 36% remaining shows 80% in yellow (63–80% yellow zone)', () => {
+  const { stdout, exitCode } = runHook({
+    model: { display_name: 'M' },
+    context_window: { remaining_percentage: 36 },
+  });
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.ok(stdout.includes('80%'), 'stdout must include 80%');
+  assert.ok(stdout.includes('\x1b[33m'), 'stdout must include yellow ANSI code \\x1b[33m');
+});
+
+// TC6: Malformed JSON input → exits 0, stdout is empty (silent fail)
+test('TC6: malformed JSON input exits 0 with empty stdout (silent fail)', () => {
+  const { stdout, exitCode } = runHook('this is not valid json');
+  assert.strictEqual(exitCode, 0, 'exit code must be 0');
+  assert.strictEqual(stdout, '', 'stdout must be empty on malformed JSON input');
+});
+
+// TC7: Update available — output includes '/nf:update'
+test('TC7: update available banner shows /nf:update in output', () => {
+  const tempHome = makeTempDir('tc7');
+  const cacheDir = path.join(tempHome, '.claude', 'cache');
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const cacheFile = path.join(cacheDir, 'nf-update-check.json');
+  fs.writeFileSync(cacheFile, JSON.stringify({ update_available: true, latest: '1.0.1' }), 'utf8');
+
+  try {
+    const { stdout, exitCode } = runHook(
+      { model: { display_name: 'M' } },
+      { HOME: tempHome }
+    );
+    assert.strictEqual(exitCode, 0, 'exit code must be 0');
+    assert.ok(stdout.includes('/nf:update'), 'stdout must include /nf:update when update is available');
+  } finally {
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  }
+});
+
+// TC8: Task in progress — output includes the task's activeForm text
+test('TC8: in-progress task is shown in statusline output', () => {
+  const tempHome = makeTempDir('tc8');
+  const todosDir = path.join(tempHome, '.claude', 'todos');
+  fs.mkdirSync(todosDir, { recursive: true });
+
+  const sessionId = 'sess123';
+  const todosFile = path.join(todosDir, `${sessionId}-agent-0.json`);
+  fs.writeFileSync(
+    todosFile,
+    JSON.stringify([{ status: 'in_progress', activeForm: 'Fix the thing' }]),
+    'utf8'
+  );
+
+  try {
+    const { stdout, exitCode } = runHook(
+      { model: { display_name: 'M' }, session_id: sessionId },
+      { HOME: tempHome }
+    );
+    assert.strictEqual(exitCode, 0, 'exit code must be 0');
+    assert.ok(stdout.includes('Fix the thing'), 'stdout must include the in-progress task activeForm text');
+  } finally {
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  }
+});

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',