@principles/pd-cli 1.73.0

package/src/services/synthetic-baseline-runner.ts

@@ -0,0 +1,291 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { RuntimeStateManager } from '@principles/core/runtime-v2';
+import { SqliteContextAssembler } from '@principles/core/runtime-v2';
+import { SqliteHistoryQuery } from '@principles/core/runtime-v2';
+import { StoreEventEmitter } from '@principles/core/runtime-v2';
+import { DiagnosticianRunner } from '@principles/core/runtime-v2';
+import { PassThroughValidator } from '@principles/core/runtime-v2';
+import { SqliteDiagnosticianCommitter } from '@principles/core/runtime-v2';
+import { TestDoubleRuntimeAdapter } from '@principles/core/runtime-v2';
+import { PainSignalBridge } from '@principles/core/runtime-v2';
+import { CandidateIntakeService } from '@principles/core/runtime-v2';
+import { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
+import { auditCandidateLedgerConsistency } from '@principles/core/runtime-v2';
+import { OperatorHealthReadModel } from '@principles/core/runtime-v2';
+import { createInternalizationQueueReadModel } from '@principles/core/runtime-v2';
+import { createPITaskDiagnosticJson } from '@principles/core/runtime-v2';
+import {
+  computeOverallStatus,
+  boundedEvidence,
+  truncateReason,
+  recommendNextIssue,
+  makeDeterministicDiagnosticianOutput,
+} from '@principles/core/runtime-v2';
+import type {
+  SyntheticBaselineSummary,
+  SyntheticBaselineStage,
+  SyntheticBaselineStageName,
+  SyntheticBaselineFailStage,
+} from '@principles/core/runtime-v2';
+
+export interface SyntheticBaselineRunnerOptions {
+  workspaceDir: string;
+  workspaceMode: 'temp' | 'explicit_workspace';
+  failAfterStage?: SyntheticBaselineFailStage;
+}
+
+export async function runSyntheticBaseline(opts: SyntheticBaselineRunnerOptions): Promise<SyntheticBaselineSummary> {
+  const { workspaceDir, workspaceMode, failAfterStage } = opts;
+  const stages: SyntheticBaselineStage[] = [];
+  const generatedAt = new Date().toISOString();
+
+  const painId = `synth-pain-${Date.now()}`;
+  const diagnosticianOutput = makeDeterministicDiagnosticianOutput(painId);
+
+  let stateManager: RuntimeStateManager | null = null;
+
+  try {
+    const pdDir = path.join(workspaceDir, '.pd');
+    const stateDir = path.join(workspaceDir, '.state');
+    await fs.promises.mkdir(pdDir, { recursive: true });
+    await fs.promises.mkdir(stateDir, { recursive: true });
+
+    stateManager = new RuntimeStateManager({ workspaceDir });
+    await stateManager.initialize();
+
+    if (failAfterStage === 'before_pain_intake') {
+      stages.push({
+        name: 'pain_intake',
+        status: 'failed',
+        reason: truncateReason('Injected failure: pain intake stage forced to fail for testing'),
+      });
+      for (const name of ['diagnostician_task_created', 'candidate_created', 'ledger_consistent', 'internalization_queue_ready', 'canary_health'] as SyntheticBaselineStageName[]) {
+        stages.push({ name, status: 'failed', reason: 'Prerequisite stage pain_intake failed' });
+      }
+      const status = computeOverallStatus(stages);
+      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
+    }
+
+    const { connection: sqliteConn, taskStore, runStore } = stateManager;
+    const historyQuery = new SqliteHistoryQuery(sqliteConn);
+    const contextAssembler = new SqliteContextAssembler(taskStore, historyQuery, runStore);
+    const eventEmitter = new StoreEventEmitter();
+    const committer = new SqliteDiagnosticianCommitter(sqliteConn);
+    const validator = new PassThroughValidator();
+
+    const runtimeAdapter = new TestDoubleRuntimeAdapter(
+      { onFetchOutput: () => ({ runId: `synth-${painId}`, payload: diagnosticianOutput }) },
+      `diagnosis_${painId}`,
+    );
+
+    const runner = new DiagnosticianRunner(
+      {
+        stateManager,
+        contextAssembler,
+        runtimeAdapter,
+        eventEmitter,
+        validator,
+        committer,
+      },
+      {
+        owner: 'synthetic-baseline',
+        runtimeKind: 'test-double',
+        pollIntervalMs: 50,
+        timeoutMs: 10000,
+      },
+    );
+
+    const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir });
+    const intakeService = new CandidateIntakeService({ stateManager, ledgerAdapter });
+
+    const bridge = new PainSignalBridge({
+      stateManager,
+      runner,
+      intakeService,
+      ledgerAdapter,
+      autoIntakeEnabled: true,
+    });
+
+    const bridgeResult = await bridge.onPainDetected({
+      painId,
+      painType: 'tool_failure',
+      source: 'synthetic-baseline',
+      reason: 'Synthetic baseline deterministic pain signal',
+    });
+
+    const painPassed = bridgeResult.status === 'succeeded';
+    stages.push({
+      name: 'pain_intake',
+      status: painPassed ? 'passed' : 'failed',
+      ...(painPassed ? {} : { reason: truncateReason(bridgeResult.message ?? `PainSignalBridge returned status=${bridgeResult.status}`) }),
+      evidence: boundedEvidence({
+        painId: bridgeResult.painId,
+        bridgeStatus: bridgeResult.status,
+      }),
+    });
+
+    if (failAfterStage === 'after_pain_intake') {
+      stages.push({ name: 'diagnostician_task_created', status: 'failed', reason: 'Injected failure: forced fail after pain_intake' });
+      stages.push({ name: 'candidate_created', status: 'failed', reason: 'Prerequisite stage diagnostician_task_created failed' });
+      stages.push({ name: 'ledger_consistent', status: 'failed', reason: 'Prerequisite stage candidate_created failed' });
+      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Prerequisite stage ledger_consistent failed' });
+      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
+      const status = computeOverallStatus(stages);
+      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
+    }
+
+    const { taskId } = bridgeResult;
+    const task = await stateManager.getTask(taskId);
+    const taskPassed = task !== null && task.status === 'succeeded';
+    stages.push({
+      name: 'diagnostician_task_created',
+      status: taskPassed ? 'passed' : 'failed',
+      ...(taskPassed ? {} : { reason: truncateReason(`Task ${taskId} not found or not succeeded. task=${task ? task.status : 'null'}`) }),
+      evidence: boundedEvidence({
+        taskId,
+        taskStatus: task?.status ?? 'not_found',
+      }),
+    });
+
+    const candidates = await stateManager.getCandidatesByTaskId(taskId);
+    const candidatePassed = candidates.length > 0;
+    stages.push({
+      name: 'candidate_created',
+      status: candidatePassed ? 'passed' : 'failed',
+      ...(candidatePassed ? {} : { reason: truncateReason(`No candidates found for task ${taskId}`) }),
+      evidence: boundedEvidence({
+        candidateCount: candidates.length,
+        candidateIds: candidates.map(c => c.candidateId).slice(0, 5),
+      }),
+    });
+
+    if (failAfterStage === 'after_candidate_created') {
+      stages.push({ name: 'ledger_consistent', status: 'failed', reason: 'Injected failure: forced fail after candidate_created' });
+      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Prerequisite stage ledger_consistent failed' });
+      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
+      const status = computeOverallStatus(stages);
+      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
+    }
+
+    const auditResult = await auditCandidateLedgerConsistency(workspaceDir);
+    const ledgerPassed = auditResult.status === 'ok';
+    stages.push({
+      name: 'ledger_consistent',
+      status: ledgerPassed ? 'passed' : 'failed',
+      ...(ledgerPassed ? {} : { reason: truncateReason(`Ledger audit status=${auditResult.status}. orphanCandidates=${auditResult.orphanCandidateCount} missingLedger=${auditResult.missingLedgerCount}`) }),
+      evidence: boundedEvidence({
+        auditStatus: auditResult.status,
+        consumedCount: auditResult.consumedCount,
+        orphanCandidateCount: auditResult.orphanCandidateCount,
+        missingLedgerCount: auditResult.missingLedgerCount,
+      }),
+    });
+
+    if (failAfterStage === 'after_ledger_consistent') {
+      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Injected failure: forced fail after ledger_consistent' });
+      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
+      const status = computeOverallStatus(stages);
+      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
+    }
+
+    const piTaskId = `synth-dreamer-${Date.now()}`;
+    await stateManager.createTask({
+      taskId: piTaskId,
+      taskKind: 'dreamer',
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: createPITaskDiagnosticJson({
+        dependencyTaskIds: [],
+        channel: 'prompt',
+        timeoutMs: 300_000,
+        inputArtifactRefs: [],
+        outputArtifactRefs: [],
+      }),
+    });
+
+    const { readModel: queueReadModel, close: queueClose } = await createInternalizationQueueReadModel({
+      workspaceDir,
+      readonly: true,
+    });
+    try {
+      const queueSnapshot = await queueReadModel.getSnapshot();
+      const queueReady = queueSnapshot.readyTasks.length > 0;
+      stages.push({
+        name: 'internalization_queue_ready',
+        status: queueReady ? 'passed' : 'failed',
+        ...(queueReady ? {} : { reason: truncateReason(`Queue has no ready tasks. pendingCount=${queueSnapshot.pendingCount} noReadyTasks=${queueSnapshot.noReadyTasks?.reason ?? 'n/a'}`) }),
+        evidence: boundedEvidence({
+          readyCount: queueSnapshot.readyTasks.length,
+          pendingCount: queueSnapshot.pendingCount,
+          noReadyReason: queueSnapshot.noReadyTasks?.reason ?? null,
+        }),
+      });
+    } catch (err) {
+      stages.push({
+        name: 'internalization_queue_ready',
+        status: 'failed',
+        reason: truncateReason(`Queue read model failed: ${err instanceof Error ? err.message : String(err)}`),
+      });
+    } finally {
+      await queueClose();
+    }
+
+    const healthModel = new OperatorHealthReadModel({ workspaceDir });
+    try {
+      const healthSnapshot = await healthModel.getSnapshot();
+      const healthPassed = healthSnapshot.overallStatus === 'healthy' || healthSnapshot.overallStatus === 'degraded';
+      stages.push({
+        name: 'canary_health',
+        status: healthPassed ? 'passed' : 'failed',
+        ...(healthPassed ? {} : { reason: truncateReason(`Operator health: ${healthSnapshot.overallStatus}. Actions: ${healthSnapshot.recommendedActions.join('; ')}`) }),
+        evidence: boundedEvidence({
+          overallStatus: healthSnapshot.overallStatus,
+          recommendedActions: healthSnapshot.recommendedActions.slice(0, 3),
+        }),
+      });
+    } catch (err) {
+      stages.push({
+        name: 'canary_health',
+        status: 'failed',
+        reason: truncateReason(`Health read model failed: ${err instanceof Error ? err.message : String(err)}`),
+      });
+    } finally {
+      await healthModel.close();
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const stageNames: SyntheticBaselineStageName[] = [
+      'pain_intake',
+      'diagnostician_task_created',
+      'candidate_created',
+      'ledger_consistent',
+      'internalization_queue_ready',
+      'canary_health',
+    ];
+    const existingNames = new Set(stages.map(s => s.name));
+    for (const name of stageNames) {
+      if (!existingNames.has(name)) {
+        stages.push({
+          name,
+          status: 'failed',
+          reason: truncateReason(`Unexpected error: ${errorMessage}`),
+        });
+      }
+    }
+  } finally {
+    if (stateManager) {
+      await stateManager.close();
+    }
+  }
+
+  const status = computeOverallStatus(stages);
+  return {
+    status,
+    workspaceMode,
+    generatedAt,
+    stages,
+    recommendedNextIssue: recommendNextIssue(stages),
+  };
+}

package/tests/commands/candidate-audit-repair.test.ts

@@ -0,0 +1,338 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { handleCandidateAudit, handleCandidateRepair } from '../../src/commands/candidate.js';
+
+// Use vi.hoisted to define mocks
+const { mockStateManager, mockAdapter, mockService, mockDb, mockLoadLedger, mockGetLedgerFilePath, MockRuntimeStateManager, MockCandidateIntakeService, MockPrincipleTreeLedgerAdapter } = vi.hoisted(() => {
+  const mockDbRows: Record<string, unknown[]> = {};
+  // Track all run() calls: { sql, args }[]
+  const runCalls: { sql: string; args: unknown[] }[] = [];
+
+  const mockDb = {
+    getDb: () => ({
+      prepare: (sql: string) => {
+        const key = sql.trim();
+        const rows = mockDbRows[key] ?? [];
+        return {
+          get: (..._args: unknown[]) => rows[0] ?? undefined,
+          all: () => rows,
+          run: (...args: unknown[]) => {
+            runCalls.push({ sql: key, args });
+          },
+        };
+      },
+    }),
+    setRows: (sql: string, rows: unknown[]) => {
+      mockDbRows[sql.trim()] = rows;
+    },
+    clearRows: () => {
+      for (const key of Object.keys(mockDbRows)) {
+        delete mockDbRows[key];
+      }
+      runCalls.length = 0;
+    },
+    runCalls,
+  };
+
+  const mockStateManager = {
+    initialize: vi.fn().mockResolvedValue(undefined),
+    getCandidate: vi.fn(),
+    close: vi.fn().mockResolvedValue(undefined),
+    connection: mockDb,
+  };
+
+  const mockAdapter = {
+    writeProbationEntry: vi.fn(),
+    existsForCandidate: vi.fn().mockReturnValue(null),
+  };
+
+  const mockService = {
+    intake: vi.fn(),
+  };
+
+  function MockRuntimeStateManager(this: unknown) {
+    return mockStateManager;
+  }
+  MockRuntimeStateManager.prototype = {};
+
+  function MockCandidateIntakeService(this: unknown) {
+    return mockService;
+  }
+  MockCandidateIntakeService.prototype = {};
+
+  function MockPrincipleTreeLedgerAdapter(this: unknown) {
+    return mockAdapter;
+  }
+  MockPrincipleTreeLedgerAdapter.prototype = {};
+
+  const mockLoadLedger = vi.fn();
+  const mockGetLedgerFilePath = vi.fn().mockReturnValue('/tmp/test-workspace/.state/principle_training_state.json');
+
+  return {
+    mockStateManager,
+    mockAdapter,
+    mockService,
+    mockDb,
+    mockLoadLedger,
+    mockGetLedgerFilePath,
+    MockRuntimeStateManager,
+    MockCandidateIntakeService,
+    MockPrincipleTreeLedgerAdapter,
+  };
+});
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  CandidateIntakeService: MockCandidateIntakeService,
+  CandidateIntakeError: class CandidateIntakeError extends Error {
+    code: string;
+    constructor(message: string, code: string) {
+      super(message);
+      this.name = 'CandidateIntakeError';
+      this.code = code;
+    }
+  },
+  RuntimeStateManager: MockRuntimeStateManager,
+  loadLedger: mockLoadLedger,
+  getLedgerFilePathPublic: mockGetLedgerFilePath,
+}));
+
+vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
+  PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
+}));
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/test-workspace'),
+}));
+
+describe('pd candidate audit', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockStateManager.initialize.mockResolvedValue(undefined);
+    mockStateManager.close.mockResolvedValue(undefined);
+    mockLoadLedger.mockReset();
+    mockGetLedgerFilePath.mockReturnValue('/tmp/test-workspace/.state/principle_training_state.json');
+    mockDb.clearRows();
+
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('audit ok: all consumed candidates have ledger entries', async () => {
+    // DB returns one consumed candidate
+    mockDb.setRows(
+      "SELECT candidate_id FROM principle_candidates WHERE status = 'consumed'",
+      [{ candidate_id: 'c1' }],
+    );
+
+    // Ledger contains a principle with derivedFromPainIds matching c1
+    mockLoadLedger.mockReturnValue({
+      tree: {
+        principles: {
+          p1: { id: 'p1', derivedFromPainIds: ['c1'] },
+        },
+      },
+    });
+
+    await handleCandidateAudit({ workspace: '/tmp/test-workspace', json: true });
+
+    const jsonOutput = consoleLogSpy.mock.calls.find((call) => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.status === 'ok';
+      } catch {
+        return false;
+      }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    expect(parsed.status).toBe('ok');
+    expect(parsed.consumedCount).toBe(1);
+    expect(parsed.missingLedgerEntryIds).toEqual([]);
+
+    // ok audit should NOT call process.exit(1)
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+  });
+
+  it('audit degraded: consumed candidate missing from ledger exits 1', async () => {
+    mockDb.setRows(
+      "SELECT candidate_id FROM principle_candidates WHERE status = 'consumed'",
+      [{ candidate_id: 'c1' }],
+    );
+
+    // Ledger has no matching derivedFromPainIds
+    mockLoadLedger.mockReturnValue({
+      tree: {
+        principles: {
+          p1: { id: 'p1', derivedFromPainIds: ['other-candidate'] },
+        },
+      },
+    });
+
+    await handleCandidateAudit({ workspace: '/tmp/test-workspace', json: true });
+
+    const jsonOutput = consoleLogSpy.mock.calls.find((call) => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.status === 'degraded';
+      } catch {
+        return false;
+      }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    expect(parsed.status).toBe('degraded');
+    expect(parsed.missingLedgerEntryIds).toEqual(['c1']);
+
+    // degraded audit must exit 1
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});
+
+describe('pd candidate repair', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockStateManager.initialize.mockResolvedValue(undefined);
+    mockStateManager.close.mockResolvedValue(undefined);
+    mockStateManager.getCandidate.mockReset();
+    mockAdapter.existsForCandidate.mockReset();
+    mockService.intake.mockReset();
+    mockDb.clearRows();
+
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('repair already_consistent with null consumed_at: sets consumed_at', async () => {
+    mockStateManager.getCandidate.mockResolvedValue({
+      candidateId: 'c1',
+      status: 'consumed',
+      artifactId: 'a1',
+      title: 'Test',
+      description: 'desc',
+    });
+
+    // Ledger entry exists
+    mockAdapter.existsForCandidate.mockReturnValue({ id: 'ledger-1', derivedFromPainIds: ['c1'] });
+
+    // consumed_at is null in DB
+    mockDb.setRows(
+      'SELECT consumed_at FROM principle_candidates WHERE candidate_id = ?',
+      [{ consumed_at: null }],
+    );
+
+    await handleCandidateRepair({ candidateId: 'c1', workspace: '/tmp/test-workspace', json: true });
+
+    const jsonOutput = consoleLogSpy.mock.calls.find((call) => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.status === 'already_consistent';
+      } catch {
+        return false;
+      }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    expect(parsed.status).toBe('already_consistent');
+    expect(parsed.ledgerEntryId).toBe('ledger-1');
+    // consumedAt should be a freshly written ISO timestamp
+    expect(parsed.consumedAt).toBeDefined();
+    expect(typeof parsed.consumedAt).toBe('string');
+    // Directly assert SQL UPDATE was executed
+    const updateCall = mockDb.runCalls.find((c) => c.sql.startsWith('UPDATE principle_candidates SET consumed_at'));
+    expect(updateCall).toBeDefined();
+    expect(updateCall!.args[0]).toBe(parsed.consumedAt); // timestamp arg
+    expect(updateCall!.args[1]).toBe('c1'); // candidate_id arg
+    // Should not exit 1
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+  });
+
+  it('repair missing ledger: re-intakes and sets consumed_at', async () => {
+    mockStateManager.getCandidate.mockResolvedValue({
+      candidateId: 'c2',
+      status: 'consumed',
+      artifactId: 'a2',
+      title: 'Test 2',
+      description: 'desc 2',
+    });
+
+    // No ledger entry exists
+    mockAdapter.existsForCandidate.mockReturnValue(null);
+
+    // intake returns new entry
+    mockService.intake.mockResolvedValue({
+      id: 'new-ledger-entry',
+      title: 'Test 2',
+      text: 'text',
+      status: 'probation',
+    });
+
+    // consumed_at is null
+    mockDb.setRows(
+      'SELECT consumed_at FROM principle_candidates WHERE candidate_id = ?',
+      [{ consumed_at: null }],
+    );
+
+    await handleCandidateRepair({ candidateId: 'c2', workspace: '/tmp/test-workspace', json: true });
+
+    // intake was called to restore ledger
+    expect(mockService.intake).toHaveBeenCalledWith('c2');
+
+    const jsonOutput = consoleLogSpy.mock.calls.find((call) => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.status === 'repaired';
+      } catch {
+        return false;
+      }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    expect(parsed.status).toBe('repaired');
+    expect(parsed.ledgerEntryId).toBe('new-ledger-entry');
+    expect(parsed.consumedAt).toBeDefined();
+    // Directly assert SQL UPDATE was executed
+    const updateCall = mockDb.runCalls.find((c) => c.sql.startsWith('UPDATE principle_candidates SET consumed_at'));
+    expect(updateCall).toBeDefined();
+    expect(updateCall!.args[0]).toBe(parsed.consumedAt);
+    expect(updateCall!.args[1]).toBe('c2');
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+  });
+
+  it('repair non-consumed candidate exits 1', async () => {
+    mockStateManager.getCandidate.mockResolvedValue({
+      candidateId: 'c3',
+      status: 'pending',
+      artifactId: 'a3',
+      title: 'Test 3',
+      description: 'desc 3',
+    });
+
+    await handleCandidateRepair({ candidateId: 'c3', workspace: '/tmp/test-workspace', json: true });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('is not consumed'),
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});