@principles/pd-cli 1.73.0

package/tests/commands/runtime-diagnostics-export.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const mockSchemaCheck = vi.hoisted(() => vi.fn());
+const mockHealthSnapshot = vi.hoisted(() => vi.fn());
+const mockHealthClose = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
+const mockOrphanCandidates = vi.hoisted(() => vi.fn());
+const mockQueueSnapshot = vi.hoisted(() => vi.fn());
+const mockQueueClose = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
+const mockAuditConsistency = vi.hoisted(() => vi.fn());
+const mockBuildGfiSnapshot = vi.hoisted(() => vi.fn());
+const mockIntegrityCheck = vi.hoisted(() => vi.fn());
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  SchemaConformanceReadModel: vi.fn().mockImplementation(function () {
+    return { check: mockSchemaCheck };
+  }),
+  OperatorHealthReadModel: vi.fn().mockImplementation(function () {
+    return { getSnapshot: mockHealthSnapshot, close: mockHealthClose };
+  }),
+  PruningReadModel: vi.fn().mockImplementation(function () {
+    return { getOrphanDerivedCandidates: mockOrphanCandidates };
+  }),
+  createInternalizationQueueReadModel: vi.fn().mockResolvedValue({
+    readModel: { getSnapshot: mockQueueSnapshot },
+    close: mockQueueClose,
+  }),
+  InternalizationChainIntegrityReadModel: vi.fn().mockImplementation(function () {
+    return { check: mockIntegrityCheck };
+  }),
+  auditCandidateLedgerConsistency: mockAuditConsistency,
+  buildGfiWorkspaceSnapshot: mockBuildGfiSnapshot,
+}));
+
+vi.mock('../../src/commands/runtime-canary.js', () => ({
+  runCanaryChecks: vi.fn().mockResolvedValue({
+    overallStatus: 'healthy',
+    checks: [],
+    recommendedNextActions: [],
+    generatedAt: new Date().toISOString(),
+  }),
+}));
+
+import { exportDiagnosticsBundle } from '../../src/commands/runtime-diagnostics-export.js';
+
+function healthySchemaResult() {
+  return {
+    overallStatus: 'ok' as const,
+    checkedDatabasePath: '/fake/workspace/.pd/state.db',
+    tables: { tasks: { exists: true, missingColumns: [] } },
+    indexes: { missingIndexes: [] },
+    migrationsNeeded: [],
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function healthyIntegrityResult() {
+  return {
+    overallStatus: 'ok' as const,
+    brokenLinks: [],
+    chainSummaries: { totalCandidates: 0, totalDreamerTasks: 0, totalPhilosopherTasks: 0, totalPIArtifacts: 0, chainsWithBrokenLinks: 0 },
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+describe('exportDiagnosticsBundle', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'diag-test-'));
+
+    mockSchemaCheck.mockReturnValue(healthySchemaResult());
+    mockHealthSnapshot.mockResolvedValue({ overallStatus: 'healthy', generatedAt: new Date().toISOString() });
+    mockHealthClose.mockResolvedValue(undefined);
+    mockOrphanCandidates.mockReturnValue({ candidates: [], dbReadable: true });
+    mockQueueSnapshot.mockResolvedValue({ pendingCount: 0, readyTasks: [] });
+    mockQueueClose.mockResolvedValue(undefined);
+    mockAuditConsistency.mockResolvedValue({ status: 'ok', consumedCount: 0, orphanCandidateCount: 0, missingLedgerCount: 0 });
+    mockBuildGfiSnapshot.mockReturnValue({ active: null, staleSessionCount: 0, totalSessionCount: 0, activeSessionCount: 0, generatedAt: new Date().toISOString() });
+    mockIntegrityCheck.mockReturnValue(healthyIntegrityResult());
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('generates bundle with all artifacts', async () => {
+    const outDir = path.join(tempDir, 'snapshots');
+    const manifest = await exportDiagnosticsBundle(tempDir, outDir);
+
+    expect(manifest.artifacts.length).toBeGreaterThanOrEqual(8);
+    expect(manifest.artifacts.every(a => a.status === 'ok')).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'manifest.json'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'schema-conformance.json'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'canary.json'))).toBe(true);
+  });
+
+  it('still generates manifest when sub-check fails', async () => {
+    mockHealthSnapshot.mockRejectedValue(new Error('DB error'));
+
+    const outDir = path.join(tempDir, 'snapshots');
+    const manifest = await exportDiagnosticsBundle(tempDir, outDir);
+
+    expect(manifest.artifacts.length).toBeGreaterThanOrEqual(8);
+    const failedArtifact = manifest.artifacts.find(a => a.name === 'runtime-health');
+    expect(failedArtifact?.status).toBe('failed');
+    expect(fs.existsSync(path.join(outDir, 'manifest.json'))).toBe(true);
+  });
+
+  it('rejects output path outside workspace', async () => {
+    await expect(
+      exportDiagnosticsBundle(tempDir, '/tmp/outside-workspace'),
+    ).rejects.toThrow('Output path must be within workspace directory');
+  });
+
+  it('rejects sibling path that starts with workspace prefix', async () => {
+    const siblingDir = tempDir + '-backup';
+    await expect(
+      exportDiagnosticsBundle(tempDir, siblingDir),
+    ).rejects.toThrow('Output path must be within workspace directory');
+  });
+
+  it('manifest contains path and status for each artifact', async () => {
+    const outDir = path.join(tempDir, 'snapshots');
+    const manifest = await exportDiagnosticsBundle(tempDir, outDir);
+
+    for (const artifact of manifest.artifacts) {
+      expect(artifact.path).toBeTruthy();
+      expect(artifact.status).toMatch(/^(ok|failed)$/);
+    }
+  });
+
+  it('does not include sensitive env/API key content', async () => {
+    mockSchemaCheck.mockReturnValue({
+      ...healthySchemaResult(),
+      apiKey: 'sk-secret-key-12345',
+      config: { token: 'bearer-abc123', safeValue: 'hello' },
+    });
+
+    const outDir = path.join(tempDir, 'snapshots');
+    await exportDiagnosticsBundle(tempDir, outDir);
+
+    const schemaContent = fs.readFileSync(path.join(outDir, 'schema-conformance.json'), 'utf8');
+    const parsed = JSON.parse(schemaContent);
+    expect(parsed.apiKey).toBe('[REDACTED]');
+    expect(parsed.config.token).toBe('[REDACTED]');
+    expect(parsed.config.safeValue).toBe('hello');
+  });
+
+  it('uses createInternalizationQueueReadModel with readonly: true (no RuntimeStateManager)', async () => {
+    const fs = await import('fs');
+    const src = fs.readFileSync(require.resolve('../../src/commands/runtime-diagnostics-export.ts'), 'utf-8');
+    expect(src).not.toContain('RuntimeStateManager');
+    expect(src).toContain('createInternalizationQueueReadModel');
+    expect(src).toMatch(/createInternalizationQueueReadModel\(\{[^}]*readonly:\s*true/);
+  });
+
+  it('calls queue close once on main path', async () => {
+    const outDir = path.join(tempDir, 'snapshots');
+    await exportDiagnosticsBundle(tempDir, outDir);
+    expect(mockQueueClose).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/commands/runtime-features.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { buildFeatureFlagsStatus } from '../../src/commands/runtime-features.js';
+import { loadEffectiveFeatureFlags } from '../../src/services/feature-flag-loader.js';
+
+describe('buildFeatureFlagsStatus', () => {
+  it('returns status ok with clean config (no config file)', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    try {
+      const output = buildFeatureFlagsStatus(tmpDir);
+      expect(output.status).toBe('ok');
+      expect(output.reason).toBeUndefined();
+      expect(output.nextAction).toBeUndefined();
+      expect(output.warnings).toEqual([]);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns status degraded with reason/nextAction when warnings present', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    const configDir = path.join(tmpDir, '.pd');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, 'feature-flags.yaml'), 'gfi:\n  enabled: "yes"\n', 'utf8');
+
+    try {
+      const output = buildFeatureFlagsStatus(tmpDir);
+      expect(output.status).toBe('degraded');
+      expect(output.reason).toBeDefined();
+      expect(output.nextAction).toBeDefined();
+      expect(output.warnings.length).toBeGreaterThan(0);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('JSON output contains all required fields', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    try {
+      const output = buildFeatureFlagsStatus(tmpDir);
+      const json = JSON.stringify(output);
+      const parsed = JSON.parse(json);
+
+      expect(parsed.status).toBe('ok');
+      expect(parsed.source).toBe('defaults');
+      expect(parsed.configPath).toBeTruthy();
+      expect(parsed.flags).toBeInstanceOf(Array);
+      expect(parsed.warnings).toBeInstanceOf(Array);
+      expect(typeof parsed.totalFlags).toBe('number');
+      expect(typeof parsed.enabledCount).toBe('number');
+      expect(typeof parsed.disabledCount).toBe('number');
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('YAML loader integration', () => {
+  it('rejects __proto__ key in YAML', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    const configDir = path.join(tmpDir, '.pd');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'feature-flags.yaml'),
+      '"__proto__":\n  enabled: true\n',
+      'utf8',
+    );
+
+    try {
+      const result = loadEffectiveFeatureFlags(tmpDir);
+      expect(result.warnings.some(w => w.includes('__proto__'))).toBe(true);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('handles malformed YAML gracefully', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    const configDir = path.join(tmpDir, '.pd');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, 'feature-flags.yaml'), 'gfi: [unterminated', 'utf8');
+
+    try {
+      const result = loadEffectiveFeatureFlags(tmpDir);
+      expect(result.warnings.some(w => w.includes('YAML'))).toBe(true);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('enables GFI via valid YAML config', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+    const configDir = path.join(tmpDir, '.pd');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'feature-flags.yaml'),
+      'gfi:\n  enabled: true\n',
+      'utf8',
+    );
+
+    try {
+      const result = loadEffectiveFeatureFlags(tmpDir);
+      expect(result.flags.gfi).toBeDefined();
+      if (result.flags.gfi) {
+        expect(result.flags.gfi.enabled).toBe(true);
+      }
+      expect(result.source).toBe('workspace_file');
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/commands/runtime-health-snapshot.test.ts

@@ -0,0 +1,357 @@
+/**
+ * pd runtime health snapshot CLI unit tests.
+ *
+ * Tests the CLI adapter layer: validation, OperatorHealthReadModel delegation,
+ * JSON/text output formatting, and exit code behavior.
+ * OperatorHealthReadModel is mocked — its own contract is tested in principles-core.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// ── Mock setup ──────────────────────────────────────────────────────────────
+
+const mockSnapshotFn = vi.fn();
+const mockCloseFn = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  OperatorHealthReadModel: vi.fn().mockImplementation(function () {
+    return { getSnapshot: mockSnapshotFn, close: mockCloseFn };
+  }),
+}));
+
+import { handleRuntimeHealthSnapshot } from '../../src/commands/runtime-health-snapshot.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+const WS = '/fake/workspace';
+
+function healthySnapshot() {
+  return {
+    generatedAt: '2026-05-03T12:00:00.000Z',
+    workspace: WS,
+    painChain: {
+      lastSuccessfulChain: {
+        painId: 'pain_001',
+        taskId: 'task_001',
+        runId: 'run_001',
+        artifactId: 'art_001',
+        candidateIds: ['c1'],
+        ledgerEntryIds: ['l1'],
+        status: 'succeeded',
+        latencyMs: { painToTask: 100 },
+        failureCategory: null,
+        checkedAt: '2026-05-03T12:00:00.000Z',
+        missingLinks: [],
+      },
+      failureCategory: null,
+    },
+    candidateLedger: {
+      auditStatus: 'ok' as const,
+      orphanCandidateCount: 0,
+      missingLedgerCount: 0,
+    },
+    pruning: {
+      watchCount: 0,
+      reviewCount: 0,
+      orphanDerivedCandidateCount: 0,
+    },
+    gfi: {
+      active: null,
+      staleSessionCount: 0,
+      staleGfiRange: null,
+      totalSessionCount: 0,
+      activeSessionCount: 0,
+      generatedAt: '2026-05-03T12:00:00.000Z',
+    },
+    overallStatus: 'healthy' as const,
+    recommendedActions: [],
+    totalTaskCount: 1,
+  };
+}
+
+function mockProcessExit() {
+  return vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('handleRuntimeHealthSnapshot', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  // ── Healthy ──────────────────────────────────────────────────────────────
+
+  it('outputs healthy JSON snapshot with all required fields (--json)', async () => {
+    mockSnapshotFn.mockResolvedValue(healthySnapshot());
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.generatedAt).toBe('2026-05-03T12:00:00.000Z');
+    expect(jsonOutput.workspace).toBe(WS);
+    expect(jsonOutput.painChain).toBeDefined();
+    expect(jsonOutput.painChain.lastSuccessfulChain).toBeDefined();
+    expect(jsonOutput.candidateLedger.auditStatus).toBe('ok');
+    expect(jsonOutput.pruning.watchCount).toBe(0);
+    expect(jsonOutput.overallStatus).toBe('healthy');
+    expect(jsonOutput.recommendedActions).toEqual([]);
+  });
+
+  it('outputs readable text for healthy snapshot', async () => {
+    mockSnapshotFn.mockResolvedValue(healthySnapshot());
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('HEALTHY');
+    expect(allOutput).toContain('No actions recommended');
+  });
+
+  // ── Degraded: candidate audit ────────────────────────────────────────────
+
+  it('reflects candidate audit degraded in overallStatus', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      candidateLedger: {
+        auditStatus: 'degraded' as const,
+        orphanCandidateCount: 2,
+        missingLedgerCount: 2,
+      },
+      overallStatus: 'degraded' as const,
+      recommendedActions: [
+        'Run `pd candidate audit --workspace <path> --json` for details.',
+      ],
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+    const exitSpy = mockProcessExit();
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.overallStatus).toBe('degraded');
+    expect(jsonOutput.recommendedActions).toContain(
+      'Run `pd candidate audit --workspace <path> --json` for details.',
+    );
+    expect(process.exitCode).toBe(1);
+
+    exitSpy.mockRestore();
+  });
+
+  // ── Degraded: pruning signals ────────────────────────────────────────────
+
+  it('reflects pruning watch/review signals in recommendedActions', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      pruning: {
+        watchCount: 2,
+        reviewCount: 1,
+        orphanDerivedCandidateCount: 0,
+      },
+      overallStatus: 'degraded' as const,
+      recommendedActions: [
+        'Run `pd runtime pruning report --workspace <path> --json` for lifecycle signals.',
+      ],
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+    const exitSpy = mockProcessExit();
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.overallStatus).toBe('degraded');
+    expect(jsonOutput.pruning.watchCount).toBe(2);
+    expect(jsonOutput.recommendedActions).toContain(
+      'Run `pd runtime pruning report --workspace <path> --json` for lifecycle signals.',
+    );
+
+    exitSpy.mockRestore();
+  });
+
+  // ── Degraded: no successful chain ────────────────────────────────────────
+
+  it('recommends UAT baseline when no successful chain exists', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      painChain: {
+        lastSuccessfulChain: null,
+        failureCategory: null,
+      },
+      overallStatus: 'degraded' as const,
+      recommendedActions: [
+        'Run `pd runtime uat --workspace <path> --count 3` to establish baseline.',
+      ],
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+    const exitSpy = mockProcessExit();
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.painChain.lastSuccessfulChain).toBeNull();
+    expect(jsonOutput.recommendedActions).toContain(
+      'Run `pd runtime uat --workspace <path> --count 3` to establish baseline.',
+    );
+
+    exitSpy.mockRestore();
+  });
+
+  // ── Error ────────────────────────────────────────────────────────────────
+
+  it('handles error status from missing state.db', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      candidateLedger: {
+        auditStatus: 'error' as const,
+        orphanCandidateCount: 0,
+        missingLedgerCount: 0,
+      },
+      overallStatus: 'error' as const,
+      recommendedActions: ['Initialize workspace with `pd pain record`.'],
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+    const exitSpy = mockProcessExit();
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.overallStatus).toBe('error');
+    expect(jsonOutput.candidateLedger.auditStatus).toBe('error');
+    expect(process.exitCode).toBe(1);
+
+    exitSpy.mockRestore();
+  });
+
+  // ── Multiple degraded conditions ─────────────────────────────────────────
+
+  it('accumulates multiple recommendedActions for multiple issues', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      painChain: { lastSuccessfulChain: null, failureCategory: null },
+      candidateLedger: {
+        auditStatus: 'degraded' as const,
+        orphanCandidateCount: 2,
+        missingLedgerCount: 2,
+      },
+      pruning: { watchCount: 3, reviewCount: 1, orphanDerivedCandidateCount: 0 },
+      overallStatus: 'degraded' as const,
+      recommendedActions: [
+        'Run `pd candidate audit --workspace <path> --json` for details.',
+        'Run `pd runtime pruning report --workspace <path> --json` for lifecycle signals.',
+        'Run `pd runtime uat --workspace <path> --count 3` to establish baseline.',
+      ],
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+    const exitSpy = mockProcessExit();
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.recommendedActions).toHaveLength(3);
+
+    exitSpy.mockRestore();
+  });
+
+  // ── GFI section (PRI-83) ──────────────────────────────────────────────────
+
+  it('includes gfi section in JSON output with active session data', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      gfi: {
+        active: {
+          currentGfi: 42,
+          stage: 'elevated',
+          dominantSource: 'tool_failure',
+          consecutiveErrors: 2,
+          dailyGfiPeak: 55,
+          consumers: {
+            attitudeMode: 'conciliatory',
+            painDiagnosticReason: 'high_gfi',
+          },
+        },
+        staleSessionCount: 1,
+        staleGfiRange: { min: 10, max: 20 },
+        totalSessionCount: 2,
+        activeSessionCount: 1,
+        generatedAt: '2026-05-03T12:00:00.000Z',
+      },
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.gfi).toBeDefined();
+    expect(jsonOutput.gfi.active).not.toBeNull();
+    expect(jsonOutput.gfi.active.currentGfi).toBe(42);
+    expect(jsonOutput.gfi.active.stage).toBe('elevated');
+    expect(jsonOutput.gfi.active.dominantSource).toBe('tool_failure');
+    expect(jsonOutput.gfi.activeSessionCount).toBe(1);
+    expect(jsonOutput.gfi.staleSessionCount).toBe(1);
+  });
+
+  it('includes compact GFI line in text output', async () => {
+    const snapshot = {
+      ...healthySnapshot(),
+      gfi: {
+        active: {
+          currentGfi: 42,
+          stage: 'elevated',
+          dominantSource: 'tool_failure',
+          consecutiveErrors: 2,
+          dailyGfiPeak: 55,
+          consumers: {
+            attitudeMode: 'conciliatory',
+            painDiagnosticReason: 'high_gfi',
+          },
+        },
+        staleSessionCount: 0,
+        staleGfiRange: null,
+        totalSessionCount: 1,
+        activeSessionCount: 1,
+        generatedAt: '2026-05-03T12:00:00.000Z',
+      },
+    };
+    mockSnapshotFn.mockResolvedValue(snapshot);
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('gfi:');
+    expect(allOutput).toContain('elevated');
+    expect(allOutput).toContain('42');
+  });
+
+  it('shows no active sessions in text when gfi.active is null', async () => {
+    mockSnapshotFn.mockResolvedValue(healthySnapshot());
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('no active sessions');
+  });
+
+  it('does not mark runtime unhealthy solely for missing GFI data', async () => {
+    mockSnapshotFn.mockResolvedValue(healthySnapshot());
+
+    await handleRuntimeHealthSnapshot({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.gfi.active).toBeNull();
+    expect(jsonOutput.overallStatus).toBe('healthy');
+  });
+});