@principles/pd-cli 1.73.0

package/tests/commands/trace.test.ts

@@ -0,0 +1,314 @@
+/**
+ * pd runtime trace show command unit tests.
+ *
+ * Tests the trace command's external contract via mocked PainChainReadModel.
+ * Tests pain-to-ledger chain tracing, latency reporting, consistency checks,
+ * and failure classification output.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockTraceByPainId = vi.fn();
+const mockPainChainClose = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  PainChainReadModel: vi.fn().mockImplementation(function () {
+    return { traceByPainId: mockTraceByPainId, close: mockPainChainClose };
+  }),
+}));
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+import { handleTraceShow } from '../../src/commands/trace.js';
+
+const WS = '/fake/workspace';
+
+function fullChainTrace() {
+  return {
+    painId: 'pain_001',
+    taskId: 'diagnosis_pain_001',
+    runId: 'run_001',
+    artifactId: 'art_001',
+    candidateIds: ['c1', 'c2'],
+    ledgerEntryIds: ['l1'],
+    status: 'succeeded',
+    latencyMs: {
+      painToTask: 100,
+      taskToRun: 200,
+      runToArtifact: 50,
+      artifactToCandidate: 30,
+      candidateToLedger: 20,
+    },
+    failureCategory: null,
+    checkedAt: '2026-05-03T12:00:00.000Z',
+    missingLinks: [],
+  };
+}
+
+function mockProcessExit() {
+  return vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+}
+
+describe('handleTraceShow', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.exitCode = undefined;
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('outputs full chain trace with all fields (--json)', async () => {
+    mockTraceByPainId.mockResolvedValue(fullChainTrace());
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.painId).toBe('pain_001');
+    expect(jsonOutput.taskId).toBe('diagnosis_pain_001');
+    expect(jsonOutput.runId).toBe('run_001');
+    expect(jsonOutput.artifactId).toBe('art_001');
+    expect(jsonOutput.candidateIds).toEqual(['c1', 'c2']);
+    expect(jsonOutput.ledgerEntryIds).toEqual(['l1']);
+    expect(jsonOutput.status).toBe('succeeded');
+    expect(jsonOutput.latencyMs).toBeDefined();
+  });
+
+  it('outputs readable text with latency breakdown', async () => {
+    mockTraceByPainId.mockResolvedValue(fullChainTrace());
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Pain ID:       pain_001');
+    expect(allOutput).toContain('Task ID:       diagnosis_pain_001');
+    expect(allOutput).toContain('Status:        succeeded');
+    expect(allOutput).toContain('Run ID:        run_001');
+    expect(allOutput).toContain('Artifact ID:   art_001');
+    expect(allOutput).toContain('Candidate IDs:  c1, c2');
+    expect(allOutput).toContain('Ledger Entries: l1');
+    expect(allOutput).toContain('Checked at:    2026-05-03T12:00:00.000Z');
+    expect(allOutput).toContain('Latency:');
+    expect(allOutput).toContain('pain→task:          100ms');
+    expect(allOutput).toContain('task→run:           200ms');
+  });
+
+  it('outputs all latency segments in text mode', async () => {
+    mockTraceByPainId.mockResolvedValue(fullChainTrace());
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('run→artifact:       50ms');
+    expect(allOutput).toContain('artifact→candidate: 30ms');
+    expect(allOutput).toContain('candidate→ledger:   20ms');
+  });
+
+  it('outputs failure category in text mode when present', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      ...fullChainTrace(),
+      status: 'failed',
+      failureCategory: 'runtime_timeout',
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Failure:       runtime_timeout');
+  });
+
+  it('omits candidate/ledger lines when arrays are empty', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      ...fullChainTrace(),
+      candidateIds: [],
+      ledgerEntryIds: [],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).not.toContain('Candidate IDs:');
+    expect(allOutput).not.toContain('Ledger Entries:');
+  });
+
+  it('handles not_found status with exit code 1', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      painId: 'pain_001',
+      taskId: 'diagnosis_pain_001',
+      status: 'not_found',
+      failureCategory: 'runtime_unavailable',
+      checkedAt: '2026-05-03T12:00:00.000Z',
+      missingLinks: ['task'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No task found'));
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('handles not_found in text mode with derived taskId and workspace', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      painId: 'pain_001',
+      taskId: 'diagnosis_pain_001',
+      status: 'not_found',
+      failureCategory: 'runtime_unavailable',
+      checkedAt: '2026-05-03T12:00:00.000Z',
+      missingLinks: ['task'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('diagnosis_pain_001'));
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining(WS));
+  });
+
+  it('handles error status with config_missing in JSON mode', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      painId: 'pain_001',
+      taskId: 'diagnosis_pain_001',
+      status: 'error',
+      failureCategory: 'config_missing',
+      checkedAt: '2026-05-03T12:00:00.000Z',
+      missingLinks: ['state_manager_init'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.status).toBe('error');
+    expect(jsonOutput.failureCategory).toBe('config_missing');
+    expect(jsonOutput.message).toContain('Failed to initialize state manager');
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('handles error status in text mode', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      painId: 'pain_001',
+      taskId: 'diagnosis_pain_001',
+      status: 'error',
+      failureCategory: 'config_missing',
+      checkedAt: '2026-05-03T12:00:00.000Z',
+      missingLinks: ['state_manager_init'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to open workspace'));
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('reports missing links in text output', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      ...fullChainTrace(),
+      status: 'degraded',
+      failureCategory: 'ledger_write_failed',
+      missingLinks: ['candidate:c1 consumed but missing from ledger'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Missing links');
+    expect(allOutput).toContain('candidate:c1 consumed but missing from ledger');
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('handles missing painId gracefully', async () => {
+    await handleTraceShow({ painId: '', workspace: WS, json: false });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('--pain-id'));
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('reports failed status with exit code 1', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      ...fullChainTrace(),
+      status: 'failed',
+      failureCategory: 'runtime_timeout',
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('reports degraded status with exit code 1', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      ...fullChainTrace(),
+      status: 'degraded',
+      failureCategory: 'candidate_missing',
+      missingLinks: ['No candidates generated for succeeded task'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('closes PainChainReadModel after use', async () => {
+    mockTraceByPainId.mockResolvedValue(fullChainTrace());
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    expect(mockPainChainClose).toHaveBeenCalled();
+  });
+
+  it('closes PainChainReadModel even when traceByPainId throws', async () => {
+    mockTraceByPainId.mockRejectedValue(new Error('Database connection failed'));
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    expect(mockPainChainClose).toHaveBeenCalled();
+  });
+
+  it('handles traceByPainId throwing an error', async () => {
+    mockTraceByPainId.mockRejectedValue(new Error('Database connection failed'));
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.status).toBe('error');
+    expect(jsonOutput.failureCategory).toBe('runtime_unavailable');
+    expect(jsonOutput.message).toContain('Database connection failed');
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('outputs not_found in JSON format with correct fields', async () => {
+    mockTraceByPainId.mockResolvedValue({
+      painId: 'pain_001',
+      taskId: 'diagnosis_pain_001',
+      status: 'not_found',
+      failureCategory: 'runtime_unavailable',
+      checkedAt: '2026-05-03T12:00:00.000Z',
+      missingLinks: ['task'],
+    });
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.painId).toBe('pain_001');
+    expect(jsonOutput.taskId).toBe('diagnosis_pain_001');
+    expect(jsonOutput.status).toBe('not_found');
+    expect(jsonOutput.message).toContain('No task found');
+    expect(jsonOutput.workspace).toBe(WS);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('does not set exit code for succeeded status', async () => {
+    mockTraceByPainId.mockResolvedValue(fullChainTrace());
+
+    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
+
+    expect(process.exitCode).toBeUndefined();
+  });
+});

package/tests/e2e/candidate-intake-e2e.test.ts

@@ -0,0 +1,316 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import Database from 'better-sqlite3';
+
+describe('E2E: pd candidate intake flow', () => {
+  let tempWorkspace: string;
+  let db: Database.Database;
+  const pdCliPath = join(process.cwd(), 'dist/index.js');
+
+  beforeEach(() => {
+    tempWorkspace = mkdtempSync(join(tmpdir(), 'pd-e2e-'));
+    const pdDir = join(tempWorkspace, '.pd');
+    mkdirSync(pdDir, { recursive: true });
+
+    const dbPath = join(pdDir, 'state.db');
+    db = new Database(dbPath);
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        task_id TEXT PRIMARY KEY,
+        task_kind TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        lease_owner TEXT,
+        lease_expires_at TEXT,
+        attempt_count INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL DEFAULT 3,
+        last_error TEXT,
+        input_ref TEXT,
+        result_ref TEXT,
+        diagnostic_json TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS runs (
+        run_id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        runtime_kind TEXT NOT NULL,
+        execution_status TEXT NOT NULL DEFAULT 'queued',
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        reason TEXT,
+        output_ref TEXT,
+        input_payload TEXT,
+        output_payload TEXT,
+        error_category TEXT,
+        attempt_number INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS artifacts (
+        artifact_id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        artifact_kind TEXT NOT NULL,
+        content_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS commits (
+        commit_id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        run_id TEXT NOT NULL UNIQUE,
+        artifact_id TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        status TEXT NOT NULL DEFAULT 'committed',
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE,
+        FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,
+        FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS principle_candidates (
+        candidate_id TEXT PRIMARY KEY,
+        artifact_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        source_run_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL,
+        confidence REAL,
+        source_recommendation_json TEXT,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TEXT NOT NULL,
+        consumed_at TEXT,
+        FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE,
+        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE,
+        FOREIGN KEY (source_run_id) REFERENCES runs(run_id) ON DELETE CASCADE
+      );
+    `);
+  });
+
+  afterEach(() => {
+    if (db) db.close();
+    if (existsSync(tempWorkspace)) {
+      rmSync(tempWorkspace, { recursive: true, force: true });
+    }
+  });
+
+  function insertPendingCandidate(candidateId: string, taskId: string, artifactId: string, runId: string) {
+    const now = new Date().toISOString();
+
+    db.prepare('INSERT OR IGNORE INTO tasks (task_id, task_kind, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?)')
+      .run(taskId, 'diagnostician', 'succeeded', now, now);
+
+    db.prepare('INSERT OR IGNORE INTO runs (run_id, task_id, runtime_kind, execution_status, attempt_number, started_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(runId, taskId, 'openclaw-cli', 'completed', 1, now, now, now);
+
+    const artifactContent = JSON.stringify({
+      recommendation: {
+        title: 'Test Principle',
+        text: 'Always write tests',
+        triggerPattern: 'missing tests',
+        action: 'add test files',
+      },
+    });
+    db.prepare('INSERT OR IGNORE INTO artifacts (artifact_id, run_id, task_id, artifact_kind, content_json, created_at) VALUES (?, ?, ?, ?, ?, ?)')
+      .run(artifactId, runId, taskId, 'diagnostician_output_v1', artifactContent, now);
+
+    db.prepare('INSERT OR IGNORE INTO commits (commit_id, task_id, run_id, artifact_id, idempotency_key, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .run(`commit-${candidateId}`, taskId, runId, artifactId, `key-${candidateId}`, 'committed', now);
+
+    db.prepare(`INSERT INTO principle_candidates (candidate_id, artifact_id, task_id, source_run_id, title, description, confidence, source_recommendation_json, idempotency_key, status, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+      .run(candidateId, artifactId, taskId, runId, 'Test Principle', 'Always write tests', 0.95, artifactContent, `candidate-key-${candidateId}`, 'pending', now);
+  }
+
+  function runPdCommand(args: string[]): { stdout: string; stderr: string; status: number } {
+    try {
+      const stdout = execFileSync('node', [pdCliPath, ...args], {
+        env: { ...process.env, NODE_PATH: '' },
+        encoding: 'utf-8',
+        timeout: 30000,
+      });
+      return { stdout, stderr: '', status: 0 };
+    } catch (err: any) {
+      return {
+        stdout: err.stdout || '',
+        stderr: err.stderr || '',
+        status: err.status || 1,
+      };
+    }
+  }
+
+  function readLedgerFile(workspace: string): any[] {
+    const ledgerPath = join(workspace, '.pd', 'principle-tree-ledger.json');
+    if (!existsSync(ledgerPath)) return [];
+    const content = readFileSync(ledgerPath, 'utf-8');
+    const data = JSON.parse(content);
+    return data.principles || [];
+  }
+
+  it('Test 1 (Happy path E2E): pending candidate → intake → consumed → ledgerEntryId in output', () => {
+    const candidateId = 'e2e-cand-001';
+    const taskId = 'e2e-task-001';
+    const artifactId = 'e2e-art-001';
+    const runId = 'e2e-run-001';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    const { stdout, status } = runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+
+    expect(status).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.candidateId).toBe(candidateId);
+    expect(result.status).toBe('consumed');
+    expect(result.ledgerEntryId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+  });
+
+  it('Test 2 (Ledger entry created): ledger file contains entry with correct sourceRef', () => {
+    const candidateId = 'e2e-cand-002';
+    const taskId = 'e2e-task-002';
+    const artifactId = 'e2e-art-002';
+    const runId = 'e2e-run-002';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+
+    const ledgerEntries = readLedgerFile(tempWorkspace);
+    expect(ledgerEntries.length).toBe(1);
+    expect(ledgerEntries[0].sourceRef).toBe(`candidate://${candidateId}`);
+    expect(ledgerEntries[0].status).toBe('probation');
+    expect(ledgerEntries[0].evaluability).toBe('weak_heuristic');
+  });
+
+  it('Test 3 (Idempotency): intake same candidate twice → one ledger entry, no duplicate', () => {
+    const candidateId = 'e2e-cand-003';
+    const taskId = 'e2e-task-003';
+    const artifactId = 'e2e-art-003';
+    const runId = 'e2e-run-003';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    const { stdout: stdout1 } = runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+    const result1 = JSON.parse(stdout1);
+    expect(result1.status).toBe('consumed');
+
+    const { stdout: stdout2, status: status2 } = runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+    expect(status2).toBe(0);
+    const result2 = JSON.parse(stdout2);
+    expect(result2.status).toBe('already_consumed');
+    expect(result2.ledgerEntryId).toBe(result1.ledgerEntryId);
+
+    const ledgerEntries = readLedgerFile(tempWorkspace);
+    expect(ledgerEntries.length).toBe(1);
+  });
+
+  it('Test 4 (pd candidate list): shows candidate with consumed status after intake', () => {
+    const candidateId = 'e2e-cand-004';
+    const taskId = 'e2e-task-004';
+    const artifactId = 'e2e-art-004';
+    const runId = 'e2e-run-004';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+
+    const { stdout, status } = runPdCommand([
+      'candidate', 'list',
+      '--task-id', taskId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+    expect(status).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.taskId).toBe(taskId);
+    expect(result.candidates.length).toBe(1);
+    expect(result.candidates[0].candidateId).toBe(candidateId);
+    expect(result.candidates[0].status).toBe('consumed');
+  });
+
+  it('Test 5 (pd candidate show with ledger link): shows ledgerEntryId after intake', () => {
+    const candidateId = 'e2e-cand-005';
+    const taskId = 'e2e-task-005';
+    const artifactId = 'e2e-art-005';
+    const runId = 'e2e-run-005';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    const { stdout: intakeStdout } = runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+    const intakeResult = JSON.parse(intakeStdout);
+    const ledgerEntryId = intakeResult.ledgerEntryId;
+
+    const { stdout, status } = runPdCommand([
+      'candidate', 'show',
+      candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+    expect(status).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.candidateId).toBe(candidateId);
+    expect(result.status).toBe('consumed');
+    expect(result.ledgerEntryId).toBe(ledgerEntryId);
+  });
+
+  it('Test 6 (DB state): candidate status is consumed in DB after intake', () => {
+    const candidateId = 'e2e-cand-006';
+    const taskId = 'e2e-task-006';
+    const artifactId = 'e2e-art-006';
+    const runId = 'e2e-run-006';
+
+    insertPendingCandidate(candidateId, taskId, artifactId, runId);
+
+    runPdCommand([
+      'candidate', 'intake',
+      '--candidate-id', candidateId,
+      '--workspace', tempWorkspace,
+      '--json',
+    ]);
+
+    const row = db.prepare('SELECT status FROM principle_candidates WHERE candidate_id = ?')
+      .get(candidateId) as { status: string };
+    expect(row.status).toBe('consumed');
+  });
+});