@devflow-tools/database 0.15.0 → 0.16.2

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.16.2](https://github.com/shilongfeicool/dev-flow/compare/v0.16.1...v0.16.2) (2026-07-22)
+
+
+### Bug Fixes
+
+* harden Claude plugin lifecycle ([992e74f](https://github.com/shilongfeicool/dev-flow/commit/992e74ff0a37cdb5132736eba3926be7639ac806))
+
+
+
+
+
+# [0.16.0](https://github.com/shilongfeicool/dev-flow/compare/v0.15.0...v0.16.0) (2026-07-22)
+
+
+### Bug Fixes
+
+* **batch2:** close final telemetry and migration races ([7340608](https://github.com/shilongfeicool/dev-flow/commit/7340608419e6cb476ed44662728f1dfe8466f4c9))
+
+
+### Features
+
+* **batch4:** audit mcp surface health ([1b60d74](https://github.com/shilongfeicool/dev-flow/commit/1b60d74c8da23964743a82097244f585532871cb))
+* **batch4:** consolidate hook lifecycle state ([803b221](https://github.com/shilongfeicool/dev-flow/commit/803b2219d5d73f3ce322f572ba625bb321f3b126))
+* **batch4:** establish benchmark baseline pipeline ([8741192](https://github.com/shilongfeicool/dev-flow/commit/8741192f96280962160619fcdb0c47bf94315862))
+* **batch4:** persist enforcer governance ([2ecf668](https://github.com/shilongfeicool/dev-flow/commit/2ecf668fb0493a1a649c4d16cc17f021d6f70031))
+* **batch4:** wire workflow failure attribution ([682d12b](https://github.com/shilongfeicool/dev-flow/commit/682d12ba715d4003af33ad38610b5655f1b49d8a))
+* **telemetry:** make global sqlite the primary writer ([751eb5b](https://github.com/shilongfeicool/dev-flow/commit/751eb5b48889220991af5016b5fe3e4d176f4770))
+
+
+
+
+
 # [0.15.0](https://github.com/shilongfeicool/dev-flow/compare/v0.14.4...v0.15.0) (2026-07-16)
 
 **Note:** Version bump only for package @devflow-tools/database

package/__tests__/database.failure-category.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DevFlowDatabase } from "../src/database.js";
+
+describe("tool failure categories", () => {
+  let root: string;
+  let database: DevFlowDatabase;
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "devflow-failure-category-"));
+    database = new DevFlowDatabase(root);
+  });
+
+  afterEach(() => {
+    database.close();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("persists and returns failure_category", () => {
+    database.insertToolCallEvent({
+      eventId: "event-1",
+      executionId: "execution-1",
+      sessionId: "session-1",
+      timestamp: Date.now(),
+      toolName: "Bash",
+      toolType: "direct",
+      isMcpTool: false,
+      mcpEnforced: false,
+      mcpFallback: false,
+      input: { command: "false" },
+      duration: 1,
+      error: "exit 1",
+      blocked: false,
+      failureCategory: "tool_error",
+    });
+
+    expect(database.listToolCallEvents("execution-1")[0])
+      .toMatchObject({ failureCategory: "tool_error", error: "exit 1" });
+    expect(database.listToolCallEventsBySession("session-1")[0])
+      .toMatchObject({ failureCategory: "tool_error" });
+  });
+});

package/__tests__/database.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { DevFlowDatabase } from '../src/database';
 import { rmSync, existsSync } from 'fs';
 import { join } from 'path';
+import type { BenchmarkSuiteReport } from '@devflow-tools/sdk';
 
 describe('DevFlowDatabase', () => {
   const testDir = join(process.cwd(), '.devflow-test');
@@ -144,4 +145,33 @@ describe('DevFlowDatabase', () => {
     expect(retrieved).toBeDefined();
     expect(retrieved?.totalRuns).toBe(10);
   });
+
+  it('should persist and list canonical benchmark reports', () => {
+    const report = {
+      runId: 'benchmark:test',
+      suiteId: 'default',
+      suiteName: 'Default',
+      suiteVersion: '1',
+      projectRoot: testDir,
+      commit: null,
+      createdAt: Date.now(),
+      rounds: 1,
+      status: 'completed',
+      tasks: [],
+      summary: {
+        baseline: { avgTokensUsed: 10, avgFilesTouched: 2, avgCorrectnessScore: 0.5, avgDurationMs: 5 },
+        devflow: { avgTokensUsed: 5, avgFilesTouched: 1, avgCorrectnessScore: 1, avgDurationMs: 4 },
+        delta: { tokenReductionRate: 0.5, fileReductionRate: 0.5, correctnessLift: 0.5, timeSavedRate: 0.2 },
+      },
+      regressions: [],
+    } satisfies BenchmarkSuiteReport;
+
+    db.insertBenchmarkReport(report);
+
+    expect(db.getBenchmarkReport<BenchmarkSuiteReport>(report.runId)).toEqual(report);
+    expect(db.getLatestBenchmarkReport<BenchmarkSuiteReport>('default')).toEqual(report);
+    expect(db.listBenchmarkReports()).toEqual([
+      expect.objectContaining({ runId: report.runId, suiteId: 'default' }),
+    ]);
+  });
 });

package/__tests__/node-sqlite.test.ts

@@ -46,6 +46,14 @@ describe('NodeSqliteDatabase', () => {
     expect(rows).toHaveLength(2);
   });
 
+  it('normalizes boolean bind parameters for node:sqlite', () => {
+    db.exec('CREATE TABLE test (success INTEGER NOT NULL)');
+    db.prepare('INSERT INTO test (success) VALUES (?)').run(true);
+
+    expect(db.prepare('SELECT success FROM test WHERE success = ?').get(true))
+      .toMatchObject({ success: 1 });
+  });
+
   it('should support transactions', () => {
     db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
 

package/dist/database.d.ts

@@ -1,7 +1,97 @@
+export interface BenchmarkReportRecord {
+    runId: string;
+    suiteId: string;
+    suiteVersion: string;
+    projectRoot: string;
+    commit: string | null;
+    createdAt: number;
+    status: 'completed';
+    tasks: unknown[];
+}
+export interface BenchmarkReportMetaRecord {
+    runId: string;
+    suiteId: string;
+    suiteVersion: string;
+    projectRoot: string;
+    commit: string | null;
+    taskCount: number;
+    createdAt: number;
+    status: 'completed';
+}
+export interface FeedbackRecord {
+    id: string;
+    projectRoot: string;
+    query: string;
+    rating: 'hit' | 'partial' | 'miss';
+    taskType?: string;
+    contextMode?: 'general' | 'task';
+    runId?: string;
+    tokenCount?: number;
+    createdAt: number;
+}
+export interface TelemetryFailureRecord {
+    id: string;
+    operation: string;
+    payload: unknown;
+    error: string;
+    createdAt: number;
+    resolvedAt?: number;
+}
+export interface GovernanceRuleRecord {
+    id: string;
+    name: string;
+    gate: 1 | 2 | 3 | 4;
+    level: 'constitutional' | 'project' | 'session';
+    condition: Record<string, unknown>;
+    action: 'deny' | 'warn' | 'allow';
+    message: string;
+    enabled: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface GovernanceAuditRecord {
+    seq: number;
+    ts: number;
+    tool: string;
+    argsHash: string;
+    decision: 'allow' | 'deny' | 'warn';
+    ruleId: string | null;
+    sessionId: string;
+    prevHash: string;
+    signature: string;
+}
+export interface HookReceiptRecord {
+    projectRoot: string;
+    lastMcpCall?: number;
+    bypassCount?: number;
+    updatedAt: number;
+}
+export interface ContextReceiptRecord {
+    projectRoot: string;
+    sessionId: string;
+    executionId: string;
+    contextHash: string;
+    issuedAt: number;
+    expiresAt: number;
+}
+export interface MemoryDistillCheckpointRecord {
+    id: string;
+    projectRoot: string;
+    sessionId?: string;
+    trigger: 'pre_compact' | 'session_end';
+    pendingEvents: number;
+    releasedLeases: number;
+    createdAt: number;
+}
+export declare function getGlobalDevFlowDbPath(home?: string): string;
+export declare function openGlobalDevFlowDatabase(home?: string, options?: {
+    busyTimeoutMs?: number;
+}): DevFlowDatabase;
 export declare class DevFlowDatabase {
     private db;
     constructor(projectRoot: string, opts?: {
         dbPath?: string;
+        busyTimeoutMs?: number;
     });
     private initializeSchema;
     insertRun(run: any): void;
@@ -23,6 +113,12 @@ export declare class DevFlowDatabase {
         label?: string;
         startedAt: number;
     }): void;
+    ensureSession(params: {
+        id: string;
+        projectRoot: string;
+        label?: string;
+        startedAt?: number;
+    }): void;
     getSession(id: string): any | null;
     listSessions(limit: number, offset: number, projectRoot?: string): any[];
     closeSession(id: string, finishedAt?: number): void;
@@ -48,6 +144,7 @@ export declare class DevFlowDatabase {
         mcpToolCalls?: number;
         directToolCalls?: number;
         subagentCount?: number;
+        metadata?: Record<string, unknown>;
     }): void;
     listSkillExecutions(limit: number, skillName?: string): any[];
     insertToolCallEvent(params: {
@@ -71,13 +168,18 @@ export declare class DevFlowDatabase {
         blocked: boolean;
         blockReason?: string;
         workflowRunId?: string;
-    }): void;
+        failureCategory?: string;
+        tokensUsed?: number;
+        toolUseId?: string;
+    }): boolean;
     listToolCallEvents(executionId: string): any[];
     updateToolCallEvent(eventId: string, updates: {
         output?: string;
         error?: string;
         duration?: number;
-    }): void;
+    }): boolean;
+    markToolCallBlocked(eventId: string, reason: string): boolean;
+    reconcileSkillExecution(executionId: string, status: 'completed' | 'failed', finishedAt?: number, metadata?: Record<string, unknown>): void;
     getMcpCompliance(): {
         overall: number;
         bySkill: Record<string, number>;
@@ -101,6 +203,24 @@ export declare class DevFlowDatabase {
     }): void;
     getToolMetrics(sessionId?: string, toolName?: string, limit?: number, offset?: number): any[];
     getToolMetricsSummary(days?: number): any[];
+    aggregatePendingToolMetrics(limit?: number): number;
+    insertFeedback(feedback: FeedbackRecord): void;
+    listFeedback(projectRoot?: string, limit?: number): FeedbackRecord[];
+    getFeedbackSummary(projectRoot?: string): {
+        total: number;
+        hits: number;
+        partials: number;
+        misses: number;
+        hitRate: number;
+    };
+    insertTelemetryFailure(failure: TelemetryFailureRecord): void;
+    resolveTelemetryFailure(id: string, resolvedAt?: number): void;
+    listTelemetryFailures(options?: {
+        unresolvedOnly?: boolean;
+        limit?: number;
+    }): TelemetryFailureRecord[];
+    countTelemetryFailures(unresolvedOnly?: boolean): number;
+    trimTelemetryFailures(maxRows?: number): number;
     insertAccuracyQuery(q: {
         id: string;
         sessionId: string;
@@ -121,6 +241,27 @@ export declare class DevFlowDatabase {
         note?: string;
     }): void;
     getAccuracyStats(engine?: string, since?: number): any;
+    insertBenchmarkReport<T extends BenchmarkReportRecord>(report: T): void;
+    getBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(runId: string): T | null;
+    getLatestBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(suiteId?: string): T | null;
+    listBenchmarkReports(limit?: number): BenchmarkReportMetaRecord[];
+    listGovernanceRules(includeDisabled?: boolean): GovernanceRuleRecord[];
+    getGovernanceRule(id: string): GovernanceRuleRecord | null;
+    upsertGovernanceRule(rule: GovernanceRuleRecord): GovernanceRuleRecord;
+    deleteGovernanceRule(id: string): boolean;
+    listGovernanceAudit(limit?: number, offset?: number): {
+        items: GovernanceAuditRecord[];
+        total: number;
+    };
+    getHookReceipt(projectRoot: string): HookReceiptRecord | null;
+    updateHookReceipt(projectRoot: string, updater: (current: HookReceiptRecord | null) => Omit<HookReceiptRecord, 'projectRoot' | 'updatedAt'>): HookReceiptRecord;
+    deleteHookReceipt(projectRoot: string): boolean;
+    upsertContextReceipt(receipt: ContextReceiptRecord): void;
+    getContextReceipt(projectRoot: string, sessionId: string, executionId: string): ContextReceiptRecord | null;
+    deleteContextReceipt(projectRoot: string, sessionId: string, executionId?: string): number;
+    purgeExpiredContextReceipts(now?: number): number;
+    recordMemoryDistillCheckpoint(checkpoint: MemoryDistillCheckpointRecord): void;
+    listMemoryDistillCheckpoints(projectRoot: string, limit?: number): MemoryDistillCheckpointRecord[];
     all(sql: string, ...params: unknown[]): unknown[];
     get(sql: string, ...params: unknown[]): unknown;
     close(): void;