@nforma.ai/nforma 0.28.0 → 0.29.0

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

@@ -1,354 +0,0 @@
-#!/usr/bin/env node
-// Test suite for hooks/nf-session-start.js
-// Uses Node.js built-in test runner: node --test hooks/nf-session-start.test.js
-//
-// All tests spawn the hook as a child process with a mock stdin JSON payload.
-// The hook has no exports — only subprocess integration tests are possible.
-// Timeout is 8000ms to account for async operations (bootstrap secrets sync).
-
-'use strict';
-
-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-session-start.js');
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function makeTmpDir() {
-  const dir = path.join(
-    os.tmpdir(),
-    'nf-ss-' + Date.now() + '-' + Math.random().toString(36).slice(2)
-  );
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function runHook(stdinPayload, opts = {}) {
-  const input = stdinPayload === null ? '' : JSON.stringify(stdinPayload);
-  const result = spawnSync('node', [HOOK_PATH], {
-    input,
-    encoding: 'utf8',
-    timeout: 8000,
-    ...opts,
-  });
-  return {
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    exitCode: result.status,
-    parsed: (() => { try { return JSON.parse(result.stdout); } catch { return null; } })(),
-  };
-}
-
-// Write a minimal package.json to the given dir.
-function writePackageJson(dir, name) {
-  fs.writeFileSync(
-    path.join(dir, 'package.json'),
-    JSON.stringify({ name }, null, 2),
-    'utf8'
-  );
-}
-
-// Write pending-fixes.json under .planning/telemetry/ in the given dir.
-function writePendingFixes(dir, issues) {
-  const telemetryDir = path.join(dir, '.planning', 'telemetry');
-  fs.mkdirSync(telemetryDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(telemetryDir, 'pending-fixes.json'),
-    JSON.stringify({ issues }, null, 2),
-    'utf8'
-  );
-}
-
-// Read pending-fixes.json back from disk.
-function readPendingFixes(dir) {
-  const fixesPath = path.join(dir, '.planning', 'telemetry', 'pending-fixes.json');
-  return JSON.parse(fs.readFileSync(fixesPath, 'utf8'));
-}
-
-// ─── Subprocess integration tests ───────────────────────────────────────────
-
-test('valid empty JSON stdin → exits 0 (secrets not found, silently skips)', () => {
-  // Pass a cwd that is not a nForma repo so telemetry branch also skips.
-  const tmpDir = makeTmpDir();
-  const { exitCode, stderr } = runHook({ cwd: tmpDir });
-  assert.equal(exitCode, 0, 'hook must exit 0 even when secrets module is absent');
-  // There should be no hard error in stderr (sync errors are expected-silent here)
-  // We allow stderr to contain debug notes but must not crash.
-  assert.ok(
-    !stderr.includes('TypeError') && !stderr.includes('ReferenceError'),
-    'should not throw a JS error on stderr: ' + stderr
-  );
-});
-
-test('invalid JSON stdin → exits 0 (fail-open)', () => {
-  const result = spawnSync('node', [HOOK_PATH], {
-    input: 'not valid json {{{',
-    encoding: 'utf8',
-    timeout: 8000,
-  });
-  assert.equal(result.status, 0, 'hook must exit 0 on JSON parse failure');
-});
-
-test('empty stdin → exits 0 (fail-open)', () => {
-  const result = spawnSync('node', [HOOK_PATH], {
-    input: '',
-    encoding: 'utf8',
-    timeout: 8000,
-  });
-  assert.equal(result.status, 0, 'hook must exit 0 when stdin is empty');
-});
-
-test('telemetry: unsurfaced issue with priority >= 50 → outputs additionalContext and marks issue surfaced', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-001',
-      description: 'Quorum scoreboard drift detected in last 3 sessions',
-      action: 'Run node bin/update-scoreboard.cjs --repair',
-      priority: 80,
-      surfaced: false,
-    },
-  ]);
-
-  const { exitCode, parsed } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  assert.ok(parsed !== null, 'stdout should be valid JSON');
-  assert.ok(parsed.hookSpecificOutput, 'output must have hookSpecificOutput');
-  assert.equal(
-    parsed.hookSpecificOutput.hookEventName,
-    'SessionStart',
-    'hookEventName must be SessionStart'
-  );
-
-  const ctx = parsed.hookSpecificOutput.additionalContext;
-  assert.ok(typeof ctx === 'string' && ctx.length > 0, 'additionalContext must be a non-empty string');
-  assert.ok(
-    ctx.includes('Quorum scoreboard drift detected'),
-    'additionalContext must include the issue description'
-  );
-  assert.ok(
-    ctx.includes('priority=80'),
-    'additionalContext must include the priority'
-  );
-  assert.ok(
-    ctx.includes('node bin/update-scoreboard.cjs --repair'),
-    'additionalContext must include the suggested action'
-  );
-
-  // Verify the file was updated on disk to mark the issue surfaced.
-  const updated = readPendingFixes(tmpDir);
-  const issue = updated.issues[0];
-  assert.equal(issue.surfaced, true, 'issue.surfaced must be set to true after surfacing');
-  assert.ok(
-    typeof issue.surfacedAt === 'string' && issue.surfacedAt.length > 0,
-    'issue.surfacedAt must be an ISO timestamp string'
-  );
-});
-
-test('telemetry: issue already surfaced (surfaced=true) → no additionalContext output', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-002',
-      description: 'Old issue already surfaced',
-      action: 'Nothing to do',
-      priority: 90,
-      surfaced: true,
-      surfacedAt: '2026-02-01T00:00:00.000Z',
-    },
-  ]);
-
-  const { exitCode, stdout } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  // When no telemetry issue is surfaced the hook writes nothing to stdout.
-  assert.equal(stdout.trim(), '', 'stdout must be empty when issue is already surfaced');
-});
-
-test('telemetry: priority below 50 → no additionalContext output', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-003',
-      description: 'Low priority noise item',
-      action: 'Ignore for now',
-      priority: 30,
-      surfaced: false,
-    },
-  ]);
-
-  const { exitCode, stdout } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  assert.equal(stdout.trim(), '', 'stdout must be empty when issue priority is below 50');
-});
-
-test('telemetry: priority exactly 50 → outputs additionalContext (boundary value)', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-004',
-      description: 'Boundary priority issue at exactly 50',
-      action: 'Check threshold logic',
-      priority: 50,
-      surfaced: false,
-    },
-  ]);
-
-  const { exitCode, parsed } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  assert.ok(parsed !== null, 'stdout should be valid JSON at boundary priority=50');
-  const ctx = parsed.hookSpecificOutput.additionalContext;
-  assert.ok(
-    ctx.includes('Boundary priority issue at exactly 50'),
-    'additionalContext must include the boundary issue description'
-  );
-});
-
-test('non-nForma repo (package.json name != "nforma") → no telemetry output', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'some-other-project');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-005',
-      description: 'Should never be surfaced in non-nForma repo',
-      action: 'N/A',
-      priority: 99,
-      surfaced: false,
-    },
-  ]);
-
-  const { exitCode, stdout } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  assert.equal(stdout.trim(), '', 'stdout must be empty for non-nForma repo');
-
-  // Verify the file was NOT modified (issue.surfaced remains false).
-  const unchanged = readPendingFixes(tmpDir);
-  assert.equal(
-    unchanged.issues[0].surfaced,
-    false,
-    'issue.surfaced must remain false when repo is not nForma'
-  );
-});
-
-test('missing .planning/telemetry/pending-fixes.json → exits 0 silently', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  // Do NOT write pending-fixes.json — directory does not even exist.
-
-  const { exitCode, stdout, stderr } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0 when pending-fixes.json is absent');
-  assert.equal(stdout.trim(), '', 'stdout must be empty when pending-fixes.json is absent');
-  assert.ok(
-    !stderr.includes('TypeError') && !stderr.includes('ReferenceError'),
-    'no JS error on stderr when telemetry file is absent: ' + stderr
-  );
-});
-
-test('telemetry: multiple issues, only first unsurfaced high-priority one is surfaced', () => {
-  const tmpDir = makeTmpDir();
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-low',
-      description: 'Low priority skipped item',
-      action: 'Skip me',
-      priority: 20,
-      surfaced: false,
-    },
-    {
-      id: 'fix-surfaced',
-      description: 'Already surfaced item',
-      action: 'Already done',
-      priority: 95,
-      surfaced: true,
-      surfacedAt: '2026-02-01T00:00:00.000Z',
-    },
-    {
-      id: 'fix-high',
-      description: 'High priority unsurfaced item that should be picked',
-      action: 'Fix the high priority thing',
-      priority: 75,
-      surfaced: false,
-    },
-    {
-      id: 'fix-second-high',
-      description: 'Second high priority item that should NOT be picked this session',
-      action: 'Fix the second thing',
-      priority: 70,
-      surfaced: false,
-    },
-  ]);
-
-  const { exitCode, parsed } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0, 'hook must exit 0');
-  assert.ok(parsed !== null, 'stdout should be valid JSON');
-  const ctx = parsed.hookSpecificOutput.additionalContext;
-  assert.ok(
-    ctx.includes('High priority unsurfaced item that should be picked'),
-    'additionalContext must include the first eligible unsurfaced issue'
-  );
-  assert.ok(
-    !ctx.includes('Second high priority item that should NOT be picked'),
-    'additionalContext must NOT include the second unsurfaced issue'
-  );
-
-  // Verify only fix-high was marked surfaced on disk.
-  const updated = readPendingFixes(tmpDir);
-  const fixHigh = updated.issues.find(i => i.id === 'fix-high');
-  const fixSecond = updated.issues.find(i => i.id === 'fix-second-high');
-  assert.equal(fixHigh.surfaced, true, 'fix-high must be marked surfaced');
-  assert.equal(fixSecond.surfaced, false, 'fix-second-high must remain unsurfaced');
-});
-
-test('cwd field absent in stdin JSON → exits 0 (defaults to process.cwd, no crash)', () => {
-  // Pass an object with no cwd field. The hook should default to process.cwd()
-  // and not crash regardless of whether that directory has a nForma package.json.
-  const { exitCode } = runHook({});
-  assert.equal(exitCode, 0, 'hook must exit 0 when cwd is absent from stdin');
-});
-
-test('stdout is either empty or valid JSON (never partial/corrupt output)', () => {
-  const tmpDir = makeTmpDir();
-  // Repo with a surfaceable issue to exercise the stdout write path.
-  writePackageJson(tmpDir, 'nforma');
-  writePendingFixes(tmpDir, [
-    {
-      id: 'fix-json-integrity',
-      description: 'Test JSON output integrity',
-      action: 'Verify output is parseable',
-      priority: 60,
-      surfaced: false,
-    },
-  ]);
-
-  const { stdout, exitCode } = runHook({ cwd: tmpDir });
-
-  assert.equal(exitCode, 0);
-  if (stdout.trim().length > 0) {
-    let parsed;
-    try {
-      parsed = JSON.parse(stdout);
-    } catch (e) {
-      assert.fail('stdout is non-empty but not valid JSON: ' + stdout);
-    }
-    assert.ok(
-      parsed && typeof parsed === 'object',
-      'parsed stdout must be an object'
-    );
-  }
-});

package/hooks/dist/nf-slot-correlator.test.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-// Test suite for hooks/nf-slot-correlator.js
-// Uses Node.js built-in test runner: node --test hooks/nf-slot-correlator.test.js
-
-'use strict';
-
-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-slot-correlator.js');
-
-// Helper: create isolated tmpdir per test
-function makeTmpDir() {
-  return path.join(os.tmpdir(), 'nf-sc-' + Date.now() + '-' + Math.random().toString(36).slice(2));
-}
-
-// Helper: run the hook with a given stdin JSON payload using tmpDir as cwd
-function runHook(stdinPayload, tmpDir) {
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const result = spawnSync('node', [HOOK_PATH], {
-    input: JSON.stringify(stdinPayload),
-    cwd: tmpDir,
-    encoding: 'utf8',
-    timeout: 5000,
-  });
-  return {
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    exitCode: result.status,
-  };
-}
-
-test('writes correlation placeholder for nf-quorum-slot-worker', () => {
-  const tmpDir = makeTmpDir();
-
-  const payload = {
-    agent_type: 'nf-quorum-slot-worker',
-    agent_id: 'agent42',
-  };
-
-  const { exitCode } = runHook(payload, tmpDir);
-  assert.equal(exitCode, 0);
-
-  const corrFile = path.join(tmpDir, '.planning', 'quorum', 'correlations', 'quorum-slot-corr-agent42.json');
-  assert.equal(fs.existsSync(corrFile), true, 'Correlation file should exist');
-
-  const data = JSON.parse(fs.readFileSync(corrFile, 'utf8'));
-  assert.equal(data.agent_id, 'agent42');
-  assert.equal(data.slot, null, 'slot should be null in SubagentStart (prompt not available)');
-  assert.ok(data.ts, 'ts field should be present');
-});
-
-test('non-nf agent type: exits 0, no file written', () => {
-  const tmpDir = makeTmpDir();
-
-  const payload = {
-    agent_type: 'other',
-    agent_id: 'agent99',
-  };
-
-  const { exitCode } = runHook(payload, tmpDir);
-  assert.equal(exitCode, 0);
-
-  const planningDir = path.join(tmpDir, '.planning');
-  // No .planning dir should be created at all
-  const anyFile = fs.existsSync(planningDir);
-  assert.equal(anyFile, false, 'No files should be written for non-nf agents');
-});
-
-test('missing agent_id: exits 0 gracefully', () => {
-  const tmpDir = makeTmpDir();
-
-  const payload = {
-    agent_type: 'nf-quorum-slot-worker',
-    agent_id: null,
-  };
-
-  const { exitCode } = runHook(payload, tmpDir);
-  assert.equal(exitCode, 0);
-  // No crash — exits gracefully when agent_id is null
-});

package/hooks/dist/nf-spec-regen.test.js

@@ -1,73 +0,0 @@
-'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/nf-statusline.test.js

@@ -1,157 +0,0 @@
-#!/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 });
-  }
-});