@devflow-tools/database 0.17.8 → 0.18.0

package/__tests__/database.retrieval-ledger.test.ts

@@ -1,68 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase, type RetrievalLedgerEventRecord } from '../src/index.js';
-
-describe('retrieval ledger', () => {
-  const directories: string[] = [];
-
-  afterEach(() => {
-    for (const directory of directories.splice(0)) rmSync(directory, { recursive: true, force: true });
-  });
-
-  it('is append-only and idempotent per immutable event identity', () => {
-    const database = createDatabase();
-    const selected = event({ id: 'selected-a', stage: 'selected' });
-    expect(database.appendRetrievalLedgerEvent(selected)).toBe(true);
-    expect(database.appendRetrievalLedgerEvent({ ...selected, reason: 'changed' })).toBe(false);
-    expect(database.appendRetrievalLedgerEvent(event({ id: 'exposed-a', stage: 'exposed' }))).toBe(true);
-    expect(database.listRetrievalLedgerEvents({ projectRoot: '/project' })).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: 'selected-a', stage: 'selected', reason: undefined }),
-      expect.objectContaining({ id: 'exposed-a', stage: 'exposed' }),
-    ]));
-    database.close();
-  });
-
-  it('rejects score loss between returned evidence and persisted selected evidence', () => {
-    const database = createDatabase();
-    expect(() => database.appendRetrievalLedgerEvent(event({
-      id: 'score-loss',
-      stage: 'selected',
-      finalScore: 0,
-      payload: { returnedFinalScore: 0.81 },
-    }))).toThrow('RETRIEVAL_LEDGER_INVALID_FINAL_SCORE');
-    database.close();
-  });
-
-  it('persists v1 provenance and reads legacy adopted rows as consumed', () => {
-    const database = createDatabase();
-    database.appendRetrievalLedgerEvent(event({
-      id: 'legacy-adopted', stage: 'adopted', taskSpecHash: 'spec:1', actor: 'tool:read',
-      sourceVersion: 'v1', sourceContentHash: 'sha256:1', evidenceIds: ['memory-a'],
-      reasonCode: 'structural_evidence_ref',
-    }));
-    expect(database.listRetrievalLedgerEvents({ projectRoot: '/project' })[0]).toMatchObject({
-      schemaVersion: 'retrieval-ledger-event.v1', stage: 'consumed', taskSpecHash: 'spec:1',
-      actor: 'tool:read', sourceVersion: 'v1', sourceContentHash: 'sha256:1',
-      evidenceIds: ['memory-a'], reasonCode: 'structural_evidence_ref',
-    });
-    database.close();
-  });
-
-  function createDatabase(): DevFlowDatabase {
-    const directory = mkdtempSync(join(tmpdir(), 'devflow-retrieval-ledger-'));
-    directories.push(directory);
-    return new DevFlowDatabase(join(directory, 'devflow.db'));
-  }
-
-  function event(overrides: Partial<RetrievalLedgerEventRecord>): RetrievalLedgerEventRecord {
-    return {
-      id: 'event-a', projectRoot: '/project', sessionId: 'session-a', executionId: 'execution-a',
-      requestId: 'request-a', contextReceipt: 'context-a', sourceType: 'memory', sourceId: 'memory-a',
-      stage: 'candidate', rank: 1, rawScore: 0.7, normalizedScore: 0.75, finalScore: 0.8,
-      applicability: ['formatting'], toolEvidence: [], payload: { returnedFinalScore: 0.8 }, createdAt: 100,
-      ...overrides,
-    };
-  }
-});

package/__tests__/database.retrieval-sessions.test.ts

@@ -1,79 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-
-describe('DevFlowDatabase retrieval sessions', () => {
-  let root: string;
-  let database: DevFlowDatabase;
-
-  beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), 'devflow-retrieval-session-'));
-    database = new DevFlowDatabase(root);
-  });
-
-  afterEach(() => {
-    database.close();
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const create = () => database.createRetrievalSession({
-    id: 'retrieval-1', requestId: 'request-1', projectRoot: '/project-a',
-    sessionId: 'session-1', executionId: 'execution-1', query: 'review player',
-    intent: 'performance', tokenBudget: 1000, baselineReceipt: 'baseline-1',
-    expiresAt: Date.now() + 60_000,
-  });
-
-  it('persists idempotent cycles and rejects changed evidence', () => {
-    expect(create()).toMatchObject({ id: 'retrieval-1', cycle: 0, remainingTokenBudget: 1000 });
-    expect(create()).toMatchObject({ id: 'retrieval-1' });
-    const input = {
-      retrievalSessionId: 'retrieval-1', projectRoot: '/project-a', sessionId: 'session-1',
-      baselineReceipt: 'baseline-1', cycle: 1,
-      gaps: [{ kind: 'caller' as const, reason: 'missing caller', evidence: [], resolver: 'codegraph' as const, priority: 80 }],
-      selectedIds: ['code:src/player.tsx'], rejectedIds: [], tokenCost: 200,
-      remainingTokenBudget: 800, quality: { status: 'healthy' }, receipt: 'cycle-1', evidenceHash: 'hash-1',
-    };
-    expect(database.appendRetrievalCycle(input)).toMatchObject({ cycle: 1, tokenCost: 200 });
-    expect(database.appendRetrievalCycle(input)).toMatchObject({ evidenceHash: 'hash-1' });
-    expect(() => database.appendRetrievalCycle({ ...input, evidenceHash: 'changed' }))
-      .toThrow('RETRIEVAL_CYCLE_CONFLICT:1');
-    expect(database.getRetrievalSession('/project-a', 'session-1', 'retrieval-1'))
-      .toMatchObject({ cycle: 1, remainingTokenBudget: 800 });
-  });
-
-  it('enforces ownership, sequence, terminal state, and expiration', () => {
-    create();
-    expect(database.getRetrievalSession('/project-b', 'session-1', 'retrieval-1')).toBeNull();
-    expect(() => database.appendRetrievalCycle({
-      retrievalSessionId: 'retrieval-1', projectRoot: '/project-a', sessionId: 'session-1',
-      baselineReceipt: 'baseline-1', cycle: 2, gaps: [], selectedIds: [], rejectedIds: [],
-      tokenCost: 1, remainingTokenBudget: 999, quality: {}, receipt: 'cycle-2', evidenceHash: 'hash-2',
-    })).toThrow('RETRIEVAL_CYCLE_SEQUENCE:0->2');
-    database.finalizeRetrievalSession({
-      id: 'retrieval-1', projectRoot: '/project-a', sessionId: 'session-1',
-      state: 'exhausted', finalReceipt: 'final-1',
-    });
-    expect(() => database.finalizeRetrievalSession({
-      id: 'retrieval-1', projectRoot: '/project-a', sessionId: 'session-1',
-      state: 'satisfied', finalReceipt: 'different',
-    })).toThrow('RETRIEVAL_SESSION_TERMINAL:exhausted');
-
-    database.createRetrievalSession({
-      id: 'retrieval-expire', requestId: 'request-expire', projectRoot: '/project-a',
-      sessionId: 'session-1', query: 'x', intent: 'debug', tokenBudget: 1,
-      baselineReceipt: 'baseline-expire', expiresAt: Date.now() + 10,
-    });
-    expect(database.expireRetrievalSessions(Date.now() + 20)).toBe(1);
-    expect(database.getRetrievalSession('/project-a', 'session-1', 'retrieval-expire')?.state).toBe('expired');
-  });
-
-  it('keeps retrieval rows stable across reopen', () => {
-    create();
-    database.close();
-    database = new DevFlowDatabase(root);
-    expect(database.getRetrievalSession('/project-a', 'session-1', 'retrieval-1'))
-      .toMatchObject({ requestId: 'request-1', baselineReceipt: 'baseline-1' });
-  });
-});

package/__tests__/database.semantic-resolution.test.ts

@@ -1,87 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-import type { SemanticResolutionRecord } from '../src/semantic-resolution';
-
-describe('DevFlowDatabase semantic resolution persistence', () => {
-  let directory: string;
-  let database: DevFlowDatabase;
-
-  beforeEach(() => {
-    directory = mkdtempSync(join(tmpdir(), 'devflow-semantic-resolution-'));
-    database = new DevFlowDatabase(directory);
-  });
-
-  afterEach(() => {
-    database.close();
-    rmSync(directory, { recursive: true, force: true });
-  });
-
-  it('appends, lists, and returns the latest immutable revision', () => {
-    const provisional = resolution();
-    const resolved = resolution({
-      frameHash: 'b'.repeat(64),
-      artifactHash: 'artifact:2',
-      artifactRevision: 2,
-      supersedesFrameHash: provisional.frameHash,
-      state: 'resolved',
-      frame: { frameHash: 'b'.repeat(64), state: 'resolved' },
-      createdAt: 2,
-    });
-    expect(database.appendSemanticResolution(provisional)).toBe(true);
-    expect(database.appendSemanticResolution(resolved)).toBe(true);
-    expect(database.listSemanticResolutions('/project', 'session:1', 'turn:1'))
-      .toEqual([provisional, resolved]);
-    expect(database.getLatestSemanticResolution('/project', 'session:1', 'turn:1'))
-      .toEqual(resolved);
-  });
-
-  it('makes identical replay idempotent and rejects hash conflicts', () => {
-    const record = resolution();
-    expect(database.appendSemanticResolution(record)).toBe(true);
-    expect(database.appendSemanticResolution(record)).toBe(false);
-    expect(() => database.appendSemanticResolution({
-      ...record,
-      durationMs: 9,
-    })).toThrow(`SEMANTIC_RESOLUTION_HASH_CONFLICT:${record.frameHash}`);
-  });
-
-  it('rejects another frame at the same artifact revision', () => {
-    const record = resolution();
-    database.appendSemanticResolution(record);
-    expect(() => database.appendSemanticResolution({
-      ...record,
-      frameHash: 'c'.repeat(64),
-      frame: { frameHash: 'c'.repeat(64), state: 'provisional' },
-    })).toThrow('SEMANTIC_RESOLUTION_REVISION_CONFLICT:turn:1:1');
-  });
-});
-
-function resolution(overrides: Partial<SemanticResolutionRecord> = {}): SemanticResolutionRecord {
-  const frameHash = overrides.frameHash ?? 'a'.repeat(64);
-  return {
-    frameHash,
-    projectRoot: '/project',
-    projectId: 'project:1',
-    hostId: 'claude-code',
-    sessionId: 'session:1',
-    turnId: 'turn:1',
-    requestId: 'request:1',
-    sourceHash: 'source:1',
-    artifactHash: 'artifact:1',
-    artifactRevision: 1,
-    state: 'provisional',
-    generatedBy: 'deterministic',
-    routeCatalogVersion: 'catalog.v1',
-    thresholdVersion: 'threshold.v1',
-    route: { status: 'unavailable' },
-    sampling: { attempted: false, status: 'not_needed' },
-    conflicts: [],
-    frame: { frameHash, state: 'provisional' },
-    durationMs: 0,
-    createdAt: 1,
-    ...overrides,
-  };
-}

package/__tests__/database.skill-executions.test.ts

@@ -1,456 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdtempSync, rmSync } from 'fs';
-
-describe('DevFlowDatabase - Skill Executions', () => {
-  let db: DevFlowDatabase;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'devflow-test-'));
-    db = new DevFlowDatabase(tmpDir);
-  });
-
-  afterEach(() => {
-    db.close();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('should insert and retrieve a skill execution', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now(),
-      status: 'running',
-    });
-
-    const execution = db.getSkillExecution('exec_001');
-    expect(execution).not.toBeNull();
-    expect(execution!.executionId).toBe('exec_001');
-    expect(execution!.skillName).toBe('devflow:react');
-    expect(execution!.status).toBe('running');
-    expect(execution!.totalToolCalls).toBe(0);
-  });
-
-  it('should list skill executions with limit', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now() - 1000,
-      status: 'completed',
-    });
-    db.insertSkillExecution({
-      executionId: 'exec_002',
-      skillName: 'devflow:vue',
-      startedAt: Date.now(),
-      status: 'running',
-    });
-
-    const executions = db.listSkillExecutions(10);
-    expect(executions).toHaveLength(2);
-    // Most recent first
-    expect(executions[0].executionId).toBe('exec_002');
-  });
-
-  it('should update skill execution on complete', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now() - 5000,
-      status: 'running',
-    });
-
-    db.updateSkillExecution('exec_001', {
-      status: 'completed',
-      finishedAt: Date.now(),
-      totalDuration: 5000,
-      totalTokens: 1500,
-      mcpComplianceRate: 85.5,
-    });
-
-    const execution = db.getSkillExecution('exec_001');
-    expect(execution!.status).toBe('completed');
-    expect(execution!.totalDuration).toBe(5000);
-    expect(execution!.mcpComplianceRate).toBe(85.5);
-  });
-
-  it('should insert and list tool call events', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now(),
-      status: 'running',
-    });
-
-    db.insertToolCallEvent({
-      eventId: 'evt_001',
-      executionId: 'exec_001',
-      timestamp: Date.now(),
-      toolName: 'mcp__devflow__react_diagnose_bug',
-      toolType: 'mcp',
-      isMcpTool: true,
-      mcpToolName: 'react_diagnose_bug',
-      mcpEnforced: true,
-      mcpFallback: false,
-      input: { bug: 'white screen' },
-      tokensUsed: 500,
-      duration: 2000,
-      blocked: false,
-    });
-
-    db.insertToolCallEvent({
-      eventId: 'evt_002',
-      executionId: 'exec_001',
-      timestamp: Date.now() + 100,
-      toolName: 'Read',
-      toolType: 'direct',
-      isMcpTool: false,
-      mcpEnforced: false,
-      mcpFallback: true,
-      input: { file_path: '/src/App.tsx' },
-      tokensUsed: 100,
-      duration: 50,
-      blocked: false,
-    });
-
-    const events = db.listToolCallEvents('exec_001');
-    expect(events).toHaveLength(2);
-    expect(events[0].toolName).toBe('mcp__devflow__react_diagnose_bug');
-    expect(events[0].isMcpTool).toBe(true);
-    expect(events[1].toolName).toBe('Read');
-    expect(events[1].isMcpTool).toBe(false);
-  });
-
-  it('should filter executions by skill name', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now(),
-      status: 'completed',
-    });
-    db.insertSkillExecution({
-      executionId: 'exec_002',
-      skillName: 'devflow:vue',
-      startedAt: Date.now(),
-      status: 'completed',
-    });
-
-    const reactExecs = db.listSkillExecutions(10, 'devflow:react');
-    expect(reactExecs).toHaveLength(1);
-    expect(reactExecs[0].skillName).toBe('devflow:react');
-  });
-
-  it('computes required MCP obligation compliance independently of direct calls', () => {
-    // React requires successful context plus at least one React domain tool.
-    db.insertSkillExecution({
-      executionId: 'exec_001',
-      skillName: 'devflow:react',
-      startedAt: Date.now(),
-      status: 'completed',
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_context_1', executionId: 'exec_001', timestamp: Date.now(),
-      toolName: 'mcp__devflow__get_project_context', toolType: 'mcp',
-      isMcpTool: true, mcpToolName: 'get_project_context', mcpEnforced: true,
-      mcpFallback: false, input: {}, output: { files: ['src/App.tsx'] }, duration: 20, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_001', executionId: 'exec_001', timestamp: Date.now(),
-      toolName: 'mcp__devflow__react_diagnose_bug', toolType: 'mcp',
-      isMcpTool: true, mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { findings: [{ id: 'finding-1' }] }, tokensUsed: 100, duration: 500, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_002', executionId: 'exec_001', timestamp: Date.now(),
-      toolName: 'mcp__devflow__react_review_hooks', toolType: 'mcp',
-      isMcpTool: true, mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { findings: [{ id: 'finding-2' }] }, tokensUsed: 100, duration: 500, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_003', executionId: 'exec_001', timestamp: Date.now(),
-      toolName: 'Read', toolType: 'direct',
-      isMcpTool: false, mcpEnforced: false, mcpFallback: false,
-      input: {}, tokensUsed: 50, duration: 100, blocked: false,
-    });
-
-    // Vue has the same context + domain obligations.
-    db.insertSkillExecution({
-      executionId: 'exec_002',
-      skillName: 'devflow:vue',
-      startedAt: Date.now(),
-      status: 'completed',
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_context_2', executionId: 'exec_002', timestamp: Date.now(),
-      toolName: 'mcp__devflow__get_project_context', toolType: 'mcp',
-      isMcpTool: true, mcpToolName: 'get_project_context', mcpEnforced: true,
-      mcpFallback: false, input: {}, output: { files: ['src/App.vue'] }, duration: 20, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_004', executionId: 'exec_002', timestamp: Date.now(),
-      toolName: 'mcp__devflow__vue_diagnose_bug', toolType: 'mcp',
-      isMcpTool: true, mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { findings: [{ id: 'finding-vue' }] }, tokensUsed: 100, duration: 500, blocked: false,
-    });
-
-    const compliance = db.getMcpCompliance();
-    expect(compliance.overall).toBe(100);
-    expect(compliance.bySkill['devflow:react']).toBe(100);
-    expect(compliance.bySkill['devflow:vue']).toBeCloseTo(100, 0);
-    expect(compliance.applicableObligations).toBe(4);
-    expect(compliance.satisfiedObligations).toBe(4);
-    expect(compliance.mcpCallShare).toBeCloseTo(83.33, 1);
-  });
-
-  it('persists missed tools, actual failures, and fallback reasons on reconciliation', () => {
-    db.ensureSession({ id: 'session-facts', projectRoot: '/project', startedAt: 100 });
-    db.insertSkillExecution({
-      executionId: 'exec-facts',
-      sessionId: 'session-facts',
-      skillName: 'devflow:react',
-      startedAt: 100,
-      status: 'running',
-    });
-    db.insertToolCallEvent({
-      eventId: 'event-failed', executionId: 'exec-facts', sessionId: 'session-facts', timestamp: 150,
-      toolName: 'mcp__devflow__get_project_context', toolType: 'mcp', isMcpTool: true,
-      mcpToolName: 'get_project_context', mcpEnforced: true, mcpFallback: false,
-      input: {}, error: 'route failed', duration: 20, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'event-fallback', executionId: 'exec-facts', sessionId: 'session-facts', timestamp: 160,
-      toolName: 'Read', toolType: 'direct', isMcpTool: false, mcpEnforced: false,
-      mcpFallback: true, input: {}, output: { content: 'fallback' }, duration: 10, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'event-memory-receipt', executionId: 'exec-facts', sessionId: 'session-facts', timestamp: 165,
-      toolName: 'mcp__devflow__memory_commit_turn', toolType: 'mcp', isMcpTool: true,
-      mcpToolName: 'memory_commit_turn', mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { receiptId: 'memory-receipt:host-commit' }, duration: 5, blocked: false,
-    });
-    db.insertToolCallEvent({
-      eventId: 'event-distill-receipt', executionId: 'exec-facts', sessionId: 'session-facts', timestamp: 166,
-      toolName: 'mcp__devflow__memory_save_distilled', toolType: 'mcp', isMcpTool: true,
-      mcpToolName: 'memory_save_distilled', mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { receipt: { receiptId: 'distill-receipt:batch-1' } }, duration: 5, blocked: false,
-    });
-    db.insertHookFallback({
-      id: 'hook-fallback-1', projectRoot: '/project', sessionId: 'session-facts',
-      requestType: 'post-tool-use', tool: 'Read', reason: 'timeout', durationMs: 1_000,
-      attempts: 1, createdAt: 170,
-    });
-
-    db.reconcileSkillExecution('exec-facts', 'completed', 200, {
-      missedTools: [],
-      actualFailureCount: 0,
-      blockedCount: 99,
-      fallbackCount: 0,
-      fallbackReasons: ['stale_supplied_reason'],
-      evidenceContractOutcomes: [{ status: 'resolved' }],
-    });
-
-    expect(db.getSkillExecution('exec-facts')).toMatchObject({
-      missedMcpTools: ['react:context', 'react:domain'],
-      failedToolCalls: 1,
-      blockedToolCalls: 0,
-      fallbackCount: 2,
-      fallbackReasons: ['direct_tool_during_context', 'daemon_timeout'],
-      metadata: expect.objectContaining({
-        missedTools: ['react:context', 'react:domain'],
-        actualFailureCount: 1,
-        blockedCount: 0,
-        fallbackCount: 2,
-        fallbackReasons: ['direct_tool_during_context', 'daemon_timeout'],
-        memoryReceiptIds: ['memory-receipt:host-commit'],
-        distillReceiptIds: ['distill-receipt:batch-1'],
-        evidenceContractOutcomes: [{ status: 'resolved' }],
-      }),
-    });
-  });
-
-  it('unions evidence metadata across retries without allowing stale counters', () => {
-    db.ensureSession({ id: 'session-evidence-retry', projectRoot: '/project', startedAt: 100 });
-    db.insertSkillExecution({
-      executionId: 'exec-evidence-retry',
-      sessionId: 'session-evidence-retry',
-      skillName: 'devflow:context',
-      startedAt: 100,
-      status: 'running',
-    });
-    db.insertToolCallEvent({
-      eventId: 'event-context', executionId: 'exec-evidence-retry',
-      sessionId: 'session-evidence-retry', timestamp: 120,
-      toolName: 'get_project_context', toolType: 'mcp', isMcpTool: true,
-      mcpToolName: 'get_project_context', mcpEnforced: true, mcpFallback: false,
-      input: {}, output: { files: ['src/App.tsx'] }, duration: 10, blocked: false,
-    });
-    const degradation = {
-      obligationId: 'obligation-1', contractId: 'contract-1', reason: 'bounded_fail_open',
-      degradedAt: 150, attempt: 2,
-    };
-    const outcome = {
-      obligationId: 'obligation-1', contractId: 'contract-1', status: 'degraded',
-      completedAt: 150, attempt: 2, reason: 'bounded_fail_open',
-    };
-
-    db.reconcileSkillExecution('exec-evidence-retry', 'completed', 200, {
-      evidenceDegradations: [degradation],
-      evidenceContractOutcomes: [outcome],
-      pendingEvidenceContractIds: ['contract-pending'],
-    });
-    db.reconcileSkillExecution('exec-evidence-retry', 'completed', 220, {
-      evidenceDegradations: [],
-      evidenceContractOutcomes: [
-        { attempt: 2, completedAt: 150, reason: 'bounded_fail_open', status: 'degraded',
-          contractId: 'contract-1', obligationId: 'obligation-1' },
-      ],
-      pendingEvidenceContractIds: [],
-      missedTools: ['stale'],
-      actualFailureCount: 99,
-    });
-
-    expect(db.getSkillExecution('exec-evidence-retry')?.metadata).toMatchObject({
-      evidenceDegradations: [degradation],
-      evidenceContractOutcomes: [outcome],
-      pendingEvidenceContractIds: ['contract-pending'],
-      missedTools: [],
-      actualFailureCount: 0,
-    });
-  });
-
-  it('aggregates an empty findings collection as an empty result', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_empty_findings',
-      sessionId: 'session_empty_findings',
-      skillName: 'devflow:react',
-      startedAt: 1_000,
-      status: 'running',
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_empty_findings',
-      executionId: 'exec_empty_findings',
-      sessionId: 'session_empty_findings',
-      timestamp: 2_000,
-      toolName: 'react_review_hooks',
-      toolType: 'mcp',
-      isMcpTool: true,
-      mcpToolName: 'react_review_hooks',
-      mcpEnforced: true,
-      mcpFallback: false,
-      input: { query: 'review hooks' },
-      output: { findings: [] },
-      duration: 25,
-      blocked: false,
-    });
-
-    expect(db.aggregatePendingToolMetrics()).toBe(1);
-    expect(db.getToolMetrics('session_empty_findings')).toEqual([
-      expect.objectContaining({ status: 'empty', result_count: 0 }),
-    ]);
-  });
-
-  it.each([
-    ['success false', { success: false }],
-    ['degraded data', { success: true, data: { degraded: true } }],
-  ])('aggregates %s as degraded', (_caseName, output) => {
-    const suffix = output.success === false ? 'success_false' : 'data_degraded';
-    const executionId = `exec_${suffix}`;
-    const sessionId = `session_${suffix}`;
-    db.insertSkillExecution({
-      executionId,
-      sessionId,
-      skillName: 'devflow:react',
-      startedAt: 1_000,
-      status: 'running',
-    });
-    db.insertToolCallEvent({
-      eventId: `evt_${suffix}`,
-      executionId,
-      sessionId,
-      timestamp: 2_000,
-      toolName: 'react_audit_performance',
-      toolType: 'mcp',
-      isMcpTool: true,
-      mcpToolName: 'react_audit_performance',
-      mcpEnforced: true,
-      mcpFallback: false,
-      input: {},
-      output,
-      duration: 25,
-      blocked: false,
-    });
-
-    expect(db.aggregatePendingToolMetrics()).toBe(1);
-    expect(db.getToolMetrics(sessionId)).toEqual([
-      expect.objectContaining({ status: 'degraded' }),
-    ]);
-  });
-
-  it('reconciles execution duration from wall-clock start to finish', () => {
-    db.insertSkillExecution({
-      executionId: 'exec_wall_clock',
-      skillName: 'devflow:react',
-      startedAt: 1_000,
-      status: 'running',
-    });
-    db.insertToolCallEvent({
-      eventId: 'evt_wall_clock',
-      executionId: 'exec_wall_clock',
-      timestamp: 4_000,
-      toolName: 'react_review_hooks',
-      toolType: 'mcp',
-      isMcpTool: true,
-      mcpToolName: 'react_review_hooks',
-      mcpEnforced: true,
-      mcpFallback: false,
-      input: {},
-      output: { findings: [] },
-      duration: 100,
-      blocked: false,
-    });
-
-    db.reconcileSkillExecution('exec_wall_clock', 'completed', 11_000);
-
-    expect(db.getSkillExecution('exec_wall_clock')).toEqual(
-      expect.objectContaining({
-        status: 'completed',
-        finishedAt: 11_000,
-        totalDuration: 10_000,
-      }),
-    );
-  });
-
-  it('reconciles every running execution owned by a closing session', () => {
-    for (const executionId of ['exec_implicit_a', 'exec_implicit_b']) {
-      db.insertSkillExecution({
-        executionId,
-        sessionId: 'session-closing',
-        skillName: 'devflow:implicit',
-        startedAt: 1_000,
-        status: 'running',
-      });
-    }
-    db.insertSkillExecution({
-      executionId: 'exec_other_session',
-      sessionId: 'session-other',
-      skillName: 'devflow:implicit',
-      startedAt: 1_000,
-      status: 'running',
-    });
-
-    const reconciled = db.reconcileRunningSkillExecutionsForSession(
-      'session-closing',
-      5_000,
-      { closureReason: 'session_finalize' },
-    );
-
-    expect(reconciled.map(execution => execution.executionId)).toEqual([
-      'exec_implicit_a',
-      'exec_implicit_b',
-    ]);
-    expect(reconciled.every(execution => execution.status === 'completed')).toBe(true);
-    expect(db.getSkillExecution('exec_other_session')).toMatchObject({ status: 'running' });
-  });
-});