@principles/pd-cli 1.152.12 → 1.152.13

package/tests/commands/pain-list.test.ts

@@ -1,219 +0,0 @@
-/**
- * pd pain list command unit tests — PRI-640 (Host Attribution v0.1).
- *
- * External contract: listPains reads trajectory.db readonly and filters by
- * host (openclaw / codex / unknown); handlePainList preserves the strict
- * --json contract and degraded-failure shapes (cli-1/cli-6).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import Database from 'better-sqlite3';
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-import { handlePainList, listPains } from '../../src/commands/pain-list.js';
-import { resolveWorkspaceDir } from '../../src/resolve-workspace.js';
-
-const tempDirs: string[] = [];
-
-function openWorkspaceDb(prefix: string): { workspaceDir: string; db: Database.Database } {
-  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(workspaceDir);
-  const stateDir = path.join(workspaceDir, '.state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  return { workspaceDir, db: new Database(path.join(stateDir, 'trajectory.db')) };
-}
-
-/** Create a temp workspace whose trajectory.db uses the PRI-640 schema (host_kind column). */
-function makeWorkspace(): { workspaceDir: string; db: Database.Database } {
-  const { workspaceDir, db } = openWorkspaceDb('pd-pain-list-');
-  db.prepare('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, started_at TEXT NOT NULL, updated_at TEXT NOT NULL)').run();
-  db.prepare(`CREATE TABLE pain_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL, source TEXT NOT NULL, score REAL NOT NULL, reason TEXT,
-      severity TEXT, origin TEXT, confidence REAL, text TEXT,
-      canonical_pain_id TEXT, runtime_task_id TEXT, host_kind TEXT, created_at TEXT NOT NULL
-    )`).run();
-  db.prepare('CREATE UNIQUE INDEX idx_pain_events_canonical_pain_id ON pain_events(canonical_pain_id) WHERE canonical_pain_id IS NOT NULL').run();
-  return { workspaceDir, db };
-}
-
-/** Create a temp workspace whose trajectory.db predates PRI-640 (no host_kind column). */
-function makePre640Workspace(): { workspaceDir: string; db: Database.Database } {
-  const { workspaceDir, db } = openWorkspaceDb('pd-pain-pre640-');
-  db.prepare('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, started_at TEXT NOT NULL, updated_at TEXT NOT NULL)').run();
-  db.prepare(`CREATE TABLE pain_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL, source TEXT NOT NULL, score REAL NOT NULL, reason TEXT,
-      severity TEXT, origin TEXT, confidence REAL, text TEXT,
-      canonical_pain_id TEXT, runtime_task_id TEXT, created_at TEXT NOT NULL
-    )`).run();
-  db.prepare('CREATE UNIQUE INDEX idx_pain_events_canonical_pain_id ON pain_events(canonical_pain_id) WHERE canonical_pain_id IS NOT NULL').run();
-  return { workspaceDir, db };
-}
-
-function seedPain(db: Database.Database, row: { id: number; source: string; canonical: string; host: string | null; task?: string | null; created: string }): void {
-  db.prepare(`INSERT INTO pain_events (id, session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at)
-    VALUES (?, 's1', ?, 80, 'r', 'moderate', 'system_infer', NULL, NULL, ?, ?, ?, ?)`)
-    .run(row.id, row.source, row.canonical, row.task ?? null, row.host, row.created);
-}
-
-function dbPathOf(db: Database.Database): string {
-  return db.name;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 20 });
-  }
-});
-
-describe('listPains (PRI-640 host filter)', () => {
-  it('filters host=openclaw / codex / unknown and reports NULL as unknown', async () => {
-    const { workspaceDir, db } = makeWorkspace();
-    seedPain(db, { id: 1, source: 'user_correction', canonical: 'pain_oc_1', host: 'openclaw', task: 'diagnosis_pain_oc_1', created: '2026-09-01T10:00:00.000Z' });
-    seedPain(db, { id: 2, source: 'tool_failure', canonical: 'pain_cx_1', host: 'codex', created: '2026-09-01T11:00:00.000Z' });
-    seedPain(db, { id: 3, source: 'manual', canonical: 'pain_unknown_1', host: null, created: '2026-09-01T12:00:00.000Z' });
-    const dbPath = dbPathOf(db);
-    db.close();
-
-    const all = await listPains(dbPath, { limit: 10 });
-    expect(all.count).toBe(3);
-    expect(all.pains.map((p) => p.host)).toEqual(['unknown', 'codex', 'openclaw']); // newest first
-    expect(all.pains.find((p) => p.painId === 'pain_oc_1')).toMatchObject({ host: 'openclaw', source: 'user_correction', runtimeTaskId: 'diagnosis_pain_oc_1', createdAt: '2026-09-01T10:00:00.000Z' });
-    expect(all.workspace).toBe(workspaceDir);
-
-    expect((await listPains(dbPath, { limit: 10, host: 'openclaw' })).pains.map((p) => p.painId)).toEqual(['pain_oc_1']);
-    expect((await listPains(dbPath, { limit: 10, host: 'codex' })).pains.map((p) => p.painId)).toEqual(['pain_cx_1']);
-    expect((await listPains(dbPath, { limit: 10, host: 'unknown' })).pains.map((p) => p.painId)).toEqual(['pain_unknown_1']);
-    expect(all.warnings).toEqual([]);
-  });
-
-  it('reports legacy rows without a canonical id as row:<id>', async () => {
-    const { db } = makeWorkspace();
-    db.prepare(`INSERT INTO pain_events (session_id, source, score, created_at) VALUES ('s1', 'correction_rejected', 60, '2026-08-01T00:00:00.000Z')`).run();
-    const dbPath = dbPathOf(db);
-    db.close();
-
-    const result = await listPains(dbPath, { limit: 10 });
-    expect(result.count).toBe(1);
-    expect(result.pains[0]?.painId).toBe('row:1');
-    expect(result.pains[0]?.host).toBe('unknown');
-  });
-
-  it('PRI-743: byHost reports the full-table distribution independent of --host/--limit', async () => {
-    const { db } = makeWorkspace();
-    seedPain(db, { id: 1, source: 'user_correction', canonical: 'pain_oc_1', host: 'openclaw', created: '2026-09-01T10:00:00.000Z' });
-    seedPain(db, { id: 2, source: 'user_correction', canonical: 'pain_oc_2', host: 'openclaw', created: '2026-09-01T10:05:00.000Z' });
-    seedPain(db, { id: 3, source: 'tool_failure', canonical: 'pain_cx_1', host: 'codex', created: '2026-09-01T11:00:00.000Z' });
-    seedPain(db, { id: 4, source: 'manual', canonical: 'pain_null_1', host: null, created: '2026-09-01T12:00:00.000Z' });
-    seedPain(db, { id: 5, source: 'manual', canonical: 'pain_null_2', host: null, created: '2026-09-01T12:05:00.000Z' });
-    const dbPath = dbPathOf(db);
-    db.close();
-
-    // --limit narrows the row list but must NOT narrow the distribution.
-    const limited = await listPains(dbPath, { limit: 2 });
-    expect(limited.count).toBe(2);
-    expect(limited.byHost).toEqual({ openclaw: 2, codex: 1, unknown: 2 });
-
-    // --host narrows the row list but must NOT narrow the distribution.
-    const filtered = await listPains(dbPath, { limit: 10, host: 'codex' });
-    expect(filtered.count).toBe(1);
-    expect(filtered.byHost).toEqual({ openclaw: 2, codex: 1, unknown: 2 });
-  });
-
-  it('PRI-743: byHost is null (never guessed) on a pre-PRI-640 database', async () => {
-    const { db } = makePre640Workspace();
-    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at)
-      VALUES ('s1', 'tool_failure', 70, 'r', 'moderate', 'system_infer', NULL, NULL, 'pain_legacy', NULL, '2026-08-01T00:00:00.000Z')`).run();
-    const dbPath = dbPathOf(db);
-    db.close();
-
-    const result = await listPains(dbPath, { limit: 10 });
-    expect(result.byHost).toBeNull();
-    expect(result.warnings).toContain('host_kind_column_missing');
-  });
-
-  it('degrades observably on a pre-PRI-640 database without the host_kind column (rc-9)', async () => {
-    const { db } = makePre640Workspace();
-    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at)
-      VALUES ('s1', 'tool_failure', 70, 'r', 'moderate', 'system_infer', NULL, NULL, 'pain_legacy', NULL, '2026-08-01T00:00:00.000Z')`).run();
-    const dbPath = dbPathOf(db);
-    db.close();
-
-    const all = await listPains(dbPath, { limit: 10 });
-    expect(all.count).toBe(1);
-    expect(all.pains[0]?.host).toBe('unknown');
-    expect(all.warnings).toContain('host_kind_column_missing');
-
-    // Host filters that cannot match degrade to an explicit empty result.
-    expect(await listPains(dbPath, { limit: 10, host: 'codex' })).toMatchObject({ count: 0, pains: [] });
-    // unknown still returns the legacy rows.
-    expect((await listPains(dbPath, { limit: 10, host: 'unknown' })).count).toBe(1);
-  });
-});
-
-describe('handlePainList (CLI contract)', () => {
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-  let logSpy: ReturnType<typeof vi.spyOn>;
-  let errSpy: ReturnType<typeof vi.spyOn>;
-  let workspaceDir: string;
-
-  beforeEach(() => {
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-    const made = makeWorkspace();
-    workspaceDir = made.workspaceDir;
-    seedPain(made.db, { id: 1, source: 'user_correction', canonical: 'pain_cli_oc', host: 'openclaw', task: 't1', created: '2026-09-01T09:00:00.000Z' });
-    seedPain(made.db, { id: 2, source: 'tool_failure', canonical: 'pain_cli_cx', host: 'codex', created: '2026-09-01T09:30:00.000Z' });
-    made.db.close();
-    vi.mocked(resolveWorkspaceDir).mockReturnValue(workspaceDir);
-  });
-
-  afterEach(() => {
-    exitSpy.mockRestore();
-    logSpy.mockRestore();
-    errSpy.mockRestore();
-  });
-
-  it('--json emits one valid JSON object with stable host values', async () => {
-    await handlePainList({ json: true });
-    expect(exitSpy).not.toHaveBeenCalled();
-    const raw = logSpy.mock.calls.map((args) => String(args[0])).join('\n');
-    const parsed = JSON.parse(raw) as { count: number; pains: { host: string; painId: string }[]; hostFilter: unknown; warnings: string[]; byHost: { openclaw: number; codex: number; unknown: number } | null };
-    expect(parsed.count).toBe(2);
-    expect(parsed.pains.map((p) => `${p.painId}:${p.host}`).sort()).toEqual(['pain_cli_cx:codex', 'pain_cli_oc:openclaw']);
-    expect(parsed.hostFilter).toBeNull();
-    expect(parsed.warnings).toEqual([]);
-    expect(parsed.byHost).toEqual({ openclaw: 1, codex: 1, unknown: 0 });
-  });
-
-  it('--host filter is reflected in the JSON result', async () => {
-    await handlePainList({ json: true, host: 'codex' });
-    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { count: number; hostFilter: string; pains: unknown[] };
-    expect(parsed).toMatchObject({ count: 1, hostFilter: 'codex' });
-    expect(parsed.pains).toHaveLength(1);
-  });
-
-  it('an invalid --host value fails loudly with a structured reason (cli-6)', async () => {
-    await handlePainList({ json: true, host: 'claude' });
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { status: string; reason: string; nextAction: string };
-    expect(parsed).toMatchObject({ status: 'failed', reason: 'invalid_host_filter' });
-    expect(parsed.nextAction).toContain('--host openclaw');
-  });
-
-  it('a missing trajectory.db degrades with reason and next action (cli-6)', async () => {
-    fs.rmSync(path.join(workspaceDir, '.state', 'trajectory.db'));
-    await handlePainList({ json: true });
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { status: string; reason: string; nextAction: string };
-    expect(parsed).toMatchObject({ status: 'failed', reason: 'trajectory_db_not_found' });
-    expect(parsed.nextAction).toContain('pd runtime init');
-  });
-});

package/tests/commands/pain-record-async.test.ts

@@ -1,335 +0,0 @@
-/**
- * pd pain record async mode tests — PRI-369
- *
- * Tests the async CLI behavior:
- * - --json output is a single parseable JSON object in async mode
- * - Failed task-creation spawns nothing and mutates nothing
- * - Flag off => legacy sync behavior unchanged
- * - --wait overrides async flag to force sync
- * - asyncMode=true when flag enabled and --wait not set
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// ── Mock setup ──────────────────────────────────────────────────────────────
-
-let mockRecordPainResult: PainToPrincipleOutput;
-let lastServiceOpts: Record<string, unknown> | null = null;
-let mockIsFeatureEnabledReturn = false;
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/fake-workspace'),
-}));
-
-vi.mock('fs', () => ({
-  existsSync: vi.fn().mockReturnValue(false),
-  readFileSync: vi.fn(),
-}));
-
-vi.mock('../../src/commands/build-trajectory-evidence.js', () => ({
-  buildTrajectoryEvidenceFromDb: vi.fn().mockReturnValue([
-    { sourceRef: 'owner_reported:cli', note: 'No session context available' },
-  ]),
-}));
-
-vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
-  // PRI-642 review blocker 1: keep the REAL core evaluatePainIngress (the
-  // shared semantic authority) — only service/IO classes are mocked.
-  const actual = await importOriginal<typeof import('@principles/core/runtime-v2')>();
-  return {
-    ...actual,
-    PainToPrincipleService: vi.fn().mockImplementation(function(this: Record<string, unknown>, opts: Record<string, unknown>) {
-      lastServiceOpts = opts;
-      return {
-        recordPain: vi.fn(async () => mockRecordPainResult),
-      };
-    }),
-    PrincipleTreeLedgerAdapter: vi.fn().mockImplementation(function() { return {}; }),
-    computeEffectivePdConfig: vi.fn().mockReturnValue({
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_KEY',
-      timeoutMs: 300000,
-      agentId: 'main',
-      language: 'zh-CN',
-      warnings: [],
-    }),
-    resolveRuntimeConfig: vi.fn().mockReturnValue({
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_KEY',
-      timeoutMs: 300000,
-      agentId: 'main',
-    }),
-    isRuntimeConfigError: vi.fn().mockReturnValue(false),
-    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-    isFeatureEnabled: vi.fn().mockImplementation(() => mockIsFeatureEnabledReturn),
-  };
-});
-
-vi.mock('../../src/services/pd-config-loader.js', () => ({
-  loadPdConfig: vi.fn().mockReturnValue({
-    ok: true,
-    effective: { config: {}, source: 'defaults', warnings: [] },
-    source: 'defaults',
-    configPath: '/tmp/fake-workspace/.pd/config.yaml',
-    warnings: [],
-    legacyFilesDetected: [],
-  }),
-  computeFlagsFromLoadResult: vi.fn().mockReturnValue({
-    flags: {},
-    enabledChannels: [],
-    warnings: [],
-  }),
-}));
-
-import { handlePainRecord } from '../../src/commands/pain-record.js';
-import type { PainToPrincipleOutput, FailureCategory } from '@principles/core/runtime-v2';
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function mockProcessExit() {
-  return vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-}
-
-const SUBMITTED_RESULT: PainToPrincipleOutput = {
-  status: 'submitted',
-  painId: 'manual_123_abc',
-  taskId: 'diagnosis_manual_123_abc',
-  candidateIds: [],
-  ledgerEntryIds: [],
-  observabilityWarnings: [],
-  latencyMs: 120,
-  message: "Diagnosis submitted. Use 'pd task show diagnosis_manual_123_abc' to check progress.",
-};
-
-const SUCCEEDED_RESULT: PainToPrincipleOutput = {
-  status: 'succeeded',
-  painId: 'manual_123_abc',
-  taskId: 'diagnosis_manual_123_abc',
-  runId: 'run-001',
-  artifactId: 'art-001',
-  candidateIds: ['c1'],
-  ledgerEntryIds: ['l1'],
-  observabilityWarnings: [],
-  latencyMs: 42000,
-};
-
-// ── Tests ───────────────────────────────────────────────────────────────────
-
-describe('pd pain record async mode (PRI-369)', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockRecordPainResult = { ...SUBMITTED_RESULT };
-    lastServiceOpts = null;
-    mockIsFeatureEnabledReturn = false;
-  });
-
-  // 1. --json output is a single parseable JSON object in async mode
-  it('--json output is a single parseable JSON object with status=submitted', async () => {
-    mockIsFeatureEnabledReturn = true;
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', json: true });
-
-    expect(logSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]);
-    expect(jsonOutput.status).toBe('submitted');
-    expect(jsonOutput.painId).toBe('manual_123_abc');
-    expect(jsonOutput.taskId).toBe('diagnosis_manual_123_abc');
-    expect(jsonOutput.candidateIds).toEqual([]);
-    expect(jsonOutput.ledgerEntryIds).toEqual([]);
-    expect(jsonOutput.latencyMs).toBe(120);
-    expect(jsonOutput.message).toContain('pd task show');
-    expect(jsonOutput.reason).toContain('pd task show');
-    expect(jsonOutput.nextAction).toContain('pd diagnose run');
-    expect(jsonOutput.nextAction).toContain('--runtime pi-ai');
-    expect(jsonOutput.nextAction).toContain('--json');
-    // submitted should NOT cause exit(1)
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    logSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 2. submitted status outputs [SUBMITTED] in text mode
-  it('outputs [SUBMITTED] in text mode with no-consumer warning (PRI-570)', async () => {
-    mockIsFeatureEnabledReturn = true;
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain' });
-
-    const allOutput = logSpy.mock.calls.map(c => c.join(' ')).join(' ');
-    expect(allOutput).toContain('[SUBMITTED]');
-    expect(allOutput).toContain('submitted');
-    // PRI-570: the async path has NO automatic consumer — the warning must be
-    // explicit (rc-9), on stderr so it never pollutes piped stdout.
-    const errOutput = errSpy.mock.calls.map(c => c.join(' ')).join(' ');
-    expect(errOutput).toContain('no automatic consumer for diagnostician tasks');
-    expect(errOutput).toContain('pd diagnose run --task-id');
-    expect(errOutput).toContain('--wait');
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    logSpy.mockRestore();
-    errSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 3. Flag off => legacy sync behavior unchanged
-  it('flag off => legacy sync behavior (asyncMode=false passed to service)', async () => {
-    // mockIsFeatureEnabledReturn defaults to false
-    mockRecordPainResult = { ...SUCCEEDED_RESULT };
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', json: true });
-
-    // asyncMode should be false because the flag is off by default
-    expect(lastServiceOpts).toBeTruthy();
-    expect(lastServiceOpts!.asyncMode).toBe(false);
-
-    logSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 4. --wait overrides async flag to force sync
-  it('--wait overrides async flag to force sync (asyncMode=false even if flag on)', async () => {
-    mockIsFeatureEnabledReturn = true;
-    mockRecordPainResult = { ...SUCCEEDED_RESULT };
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', wait: true, json: true });
-
-    // --wait should force asyncMode=false even though flag is on
-    expect(lastServiceOpts).toBeTruthy();
-    expect(lastServiceOpts!.asyncMode).toBe(false);
-
-    logSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 5. asyncMode=true when flag is enabled and --wait is not set
-  it('asyncMode=true when flag enabled and --wait not set', async () => {
-    mockIsFeatureEnabledReturn = true;
-    mockRecordPainResult = { ...SUBMITTED_RESULT };
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', json: true });
-
-    expect(lastServiceOpts).toBeTruthy();
-    expect(lastServiceOpts!.asyncMode).toBe(true);
-
-    logSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 6. Failed task-creation: no side effects (no spawn, no ledger writes)
-  it('failed task-creation produces no candidateIds or ledgerEntryIds', async () => {
-    mockRecordPainResult = {
-      status: 'failed',
-      painId: 'manual_123_abc',
-      taskId: 'diagnosis_manual_123_abc',
-      candidateIds: [],
-      ledgerEntryIds: [],
-      observabilityWarnings: [],
-      failureCategory: 'runtime_unavailable' as FailureCategory,
-      latencyMs: 5,
-      message: 'Task creation failed',
-    };
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', json: true });
-
-    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]);
-    expect(jsonOutput.candidateIds).toEqual([]);
-    expect(jsonOutput.ledgerEntryIds).toEqual([]);
-    expect(jsonOutput.status).toBe('failed');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    logSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 7. Stubbed process.exit(1) does not cause side effects in JSON mode
-  it('stubbed process.exit(1) in JSON mode does not execute else branch', async () => {
-    mockRecordPainResult = {
-      status: 'failed',
-      painId: 'manual_123_abc',
-      taskId: 'diagnosis_manual_123_abc',
-      candidateIds: ['c1'],
-      ledgerEntryIds: ['l1'],
-      observabilityWarnings: [],
-      failureCategory: 'runtime_unavailable' as FailureCategory,
-      latencyMs: 5,
-      message: 'Task creation failed',
-    };
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain', json: true });
-
-    // Verify JSON output was printed
-    expect(logSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]);
-    expect(jsonOutput.status).toBe('failed');
-    expect(jsonOutput.candidateIds).toEqual(['c1']);
-
-    // Verify process.exit(1) was called
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    // Verify else branch was NOT executed (no error.log for [FAIL] message)
-    expect(errorSpy).not.toHaveBeenCalled();
-
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // 8. Stubbed process.exit(1) does not cause side effects in text mode
-  it('stubbed process.exit(1) in text mode stops after error message', async () => {
-    mockRecordPainResult = {
-      status: 'failed',
-      painId: 'manual_123_abc',
-      taskId: 'diagnosis_manual_123_abc',
-      candidateIds: ['c1'],
-      ledgerEntryIds: ['l1'],
-      observabilityWarnings: [],
-      failureCategory: 'runtime_unavailable' as FailureCategory,
-      latencyMs: 5,
-      message: 'Test failure message',
-    };
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = mockProcessExit();
-
-    await handlePainRecord({ reason: 'test pain' }); // Not json mode
-
-    // Verify [FAIL] error message was printed
-    expect(errorSpy).toHaveBeenCalledWith('[FAIL] Pain signal failed:', 'Test failure message');
-
-    // Verify process.exit(1) was called
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    // Verify no success/submitted/skip/retry messages were printed after exit
-    const allLogMessages = logSpy.mock.calls.flat();
-    const forbiddenPatterns = ['[OK]', '[SUBMITTED]', '[SKIP]', '[RETRY]'];
-    for (const pattern of forbiddenPatterns) {
-      expect(allLogMessages).not.toEqual(expect.stringContaining(pattern));
-    }
-
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-});