@devflow-tools/database 0.16.10 → 0.16.12

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.16.12](https://github.com/shilongfeicool/dev-flow/compare/v0.16.11...v0.16.12) (2026-07-26)
+
+
+### Bug Fixes
+
+* **database:** support Node 24 sqlite result types ([40efed3](https://github.com/shilongfeicool/dev-flow/commit/40efed3d8c629990f5e29324b3aba673c16a091b))
+* **memory:** make embedding model resilient ([e24fd08](https://github.com/shilongfeicool/dev-flow/commit/e24fd086b09d0327e5a69c118f02501caffcf280))
+* **runtime:** close final reliability gaps ([86edd2b](https://github.com/shilongfeicool/dev-flow/commit/86edd2b49acf3559c9e66643ca913fc3a9728731))
+* **runtime:** harden session reconciliation retries ([fc38e56](https://github.com/shilongfeicool/dev-flow/commit/fc38e561450540adecf7883666453f22fa4a9271))
+* **runtime:** preserve reconciliation retry state ([2cec7fe](https://github.com/shilongfeicool/dev-flow/commit/2cec7fe5156a7ab48fbf19c7a427cbca71e7de09))
+* **runtime:** reconcile session lifecycle telemetry ([87b2f7c](https://github.com/shilongfeicool/dev-flow/commit/87b2f7c0c04a572ab396d0da1cc13eada7779691))
+
+
+
+
+
 ## [0.16.10](https://github.com/shilongfeicool/dev-flow/compare/v0.16.9...v0.16.10) (2026-07-24)
 
 

package/__tests__/database.memory-turn-receipts.test.ts

@@ -68,4 +68,31 @@ describe('DevFlowDatabase memory turn receipts', () => {
       stopPromptedAt: 350,
     });
   });
+
+  it('lists every session turn in stable ascending order for reconciliation', () => {
+    for (let index = 0; index < 125; index += 1) {
+      database.beginMemoryTurn({
+        turnId: `turn:${String(index).padStart(3, '0')}`,
+        projectRoot: '/project',
+        sessionId: 'long-session',
+        promptHash: `hash-${index}`,
+        eventId: `event-${index}`,
+        createdAt: 1_000 + index,
+      });
+    }
+    database.beginMemoryTurn({
+      turnId: 'turn:other',
+      projectRoot: '/project',
+      sessionId: 'other-session',
+      promptHash: 'other',
+      eventId: 'event-other',
+      createdAt: 1,
+    });
+
+    const turns = database.listSessionMemoryTurnsForReconciliation('/project', 'long-session');
+    expect(turns).toHaveLength(125);
+    expect(turns[0]?.turnId).toBe('turn:000');
+    expect(turns.at(-1)?.turnId).toBe('turn:124');
+    expect(turns.every((turn, index) => turn.createdAt === 1_000 + index)).toBe(true);
+  });
 });

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

@@ -242,7 +242,14 @@ describe('DevFlowDatabase - Skill Executions', () => {
       attempts: 1, createdAt: 170,
     });
 
-    db.reconcileSkillExecution('exec-facts', 'completed', 200);
+    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'],
@@ -251,14 +258,68 @@ describe('DevFlowDatabase - Skill Executions', () => {
       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',
@@ -360,4 +421,36 @@ describe('DevFlowDatabase - Skill Executions', () => {
       }),
     );
   });
+
+  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' });
+  });
 });

package/__tests__/database.work-queue.test.ts

@@ -0,0 +1,240 @@
+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 durable work queue', () => {
+  let directory: string;
+  let database: DevFlowDatabase;
+  const projectRoot = '/project';
+
+  beforeEach(() => {
+    directory = mkdtempSync(join(tmpdir(), 'devflow-work-queue-'));
+    database = new DevFlowDatabase(directory);
+  });
+
+  afterEach(() => {
+    database.close();
+    rmSync(directory, { recursive: true, force: true });
+  });
+
+  it('returns the existing item for an idempotency conflict without resetting completed work', () => {
+    const first = database.enqueueWork({
+      idempotencyKey: 'memory:session-1:turn-1',
+      kind: 'memory.explicit_commit',
+      projectRoot,
+      sessionId: 'session-1',
+      turnId: 'turn-1',
+      payload: { text: 'remember this' },
+      nextAttemptAt: 10,
+    });
+    const [leased] = database.leaseWork({
+      projectRoot,
+      owner: 'worker-a',
+      limit: 1,
+      leaseMs: 100,
+      now: 10,
+    });
+    expect(leased?.id).toBe(first.id);
+    expect(database.completeWork(first.id, 'worker-a', 20)).toBe(true);
+
+    const duplicate = database.enqueueWork({
+      idempotencyKey: 'memory:session-1:turn-1',
+      kind: 'telemetry.reconcile',
+      projectRoot: '/different-project',
+      payload: { replacement: true },
+      maxAttempts: 1,
+      nextAttemptAt: 999,
+    });
+
+    expect(duplicate).toMatchObject({
+      id: first.id,
+      kind: 'memory.explicit_commit',
+      projectRoot,
+      payload: { text: 'remember this' },
+      state: 'completed',
+      attempts: 1,
+      maxAttempts: 5,
+      completedAt: 20,
+    });
+    expect(database.all('SELECT id FROM devflow_work_items')).toHaveLength(1);
+  });
+
+  it('leases atomically across database connections and requires the lease owner to complete', () => {
+    database.enqueueWork({
+      idempotencyKey: 'session:finalize:1',
+      kind: 'session.finalize',
+      projectRoot,
+      payload: { sessionId: 'session-1' },
+      nextAttemptAt: 100,
+    });
+    const secondConnection = new DevFlowDatabase(directory);
+    try {
+      const firstLease = database.leaseWork({
+        projectRoot,
+        owner: 'worker-a',
+        kinds: ['session.finalize'],
+        limit: 1,
+        leaseMs: 1_000,
+        now: 100,
+      });
+      const competingLease = secondConnection.leaseWork({
+        projectRoot,
+        owner: 'worker-b',
+        limit: 1,
+        leaseMs: 1_000,
+        now: 100,
+      });
+
+      expect(firstLease).toHaveLength(1);
+      expect(firstLease[0]).toMatchObject({
+        state: 'leased',
+        attempts: 1,
+        leaseOwner: 'worker-a',
+        leaseExpiresAt: 1_100,
+      });
+      expect(competingLease).toEqual([]);
+      expect(secondConnection.completeWork(firstLease[0]!.id, 'worker-b', 200)).toBe(false);
+      expect(database.completeWork(firstLease[0]!.id, 'worker-a', 200)).toBe(true);
+      expect(database.completeWork(firstLease[0]!.id, 'worker-a', 201)).toBe(false);
+    } finally {
+      secondConnection.close();
+    }
+  });
+
+  it('applies owner and state predicates to retries and dead letters', () => {
+    const item = database.enqueueWork({
+      idempotencyKey: 'telemetry:reconcile:1',
+      kind: 'telemetry.reconcile',
+      projectRoot,
+      payload: {},
+      nextAttemptAt: 50,
+    });
+    database.leaseWork({
+      projectRoot,
+      owner: 'worker-a',
+      limit: 1,
+      leaseMs: 100,
+      now: 50,
+    });
+
+    expect(database.retryWork(
+      item.id,
+      'worker-b',
+      { category: 'temporary', message: 'try again' },
+      75,
+    )).toBe(false);
+    expect(database.retryWork(
+      item.id,
+      'worker-a',
+      { category: 'temporary', message: 'try again' },
+      75,
+    )).toBe(true);
+    expect(database.getWorkQueueHealth(projectRoot, 75)).toMatchObject({
+      queueDepth: 1,
+      failed: 1,
+      deadLetters: 0,
+    });
+
+    const [retried] = database.leaseWork({
+      projectRoot,
+      owner: 'worker-b',
+      limit: 1,
+      leaseMs: 100,
+      now: 75,
+    });
+    expect(retried).toMatchObject({ attempts: 2, errorCategory: 'temporary' });
+    expect(database.deadLetterWork(
+      item.id,
+      'worker-a',
+      { category: 'invalid_schema', message: 'payload is invalid' },
+    )).toBe(false);
+    expect(database.deadLetterWork(
+      item.id,
+      'worker-b',
+      { category: 'invalid_schema', message: 'payload is invalid' },
+    )).toBe(true);
+    expect(database.deadLetterWork(
+      item.id,
+      'worker-b',
+      { category: 'invalid_schema', message: 'payload is invalid' },
+    )).toBe(false);
+    expect(database.getWorkQueueHealth(projectRoot, 80)).toMatchObject({
+      queueDepth: 0,
+      deadLetters: 1,
+    });
+  });
+
+  it('recovers expired leases and dead-letters exhausted work', () => {
+    database.enqueueWork({
+      idempotencyKey: 'memory:distill:retryable',
+      kind: 'memory.turn_distill',
+      projectRoot,
+      payload: {},
+      maxAttempts: 2,
+      nextAttemptAt: 100,
+    });
+    database.enqueueWork({
+      idempotencyKey: 'memory:vector:exhausted',
+      kind: 'memory.vector_backfill',
+      projectRoot,
+      payload: {},
+      maxAttempts: 1,
+      nextAttemptAt: 100,
+    });
+    database.leaseWork({
+      projectRoot,
+      owner: 'worker-a',
+      limit: 2,
+      leaseMs: 10,
+      now: 100,
+    });
+
+    expect(database.getWorkQueueHealth(projectRoot, 110)).toMatchObject({
+      queueDepth: 2,
+      leased: 2,
+      expiredLeases: 2,
+    });
+    expect(database.recoverExpiredWork(projectRoot, 110)).toBe(2);
+    expect(database.getWorkQueueHealth(projectRoot, 110)).toMatchObject({
+      queueDepth: 1,
+      leased: 0,
+      failed: 1,
+      expiredLeases: 0,
+      deadLetters: 1,
+    });
+
+    const recovered = database.leaseWork({
+      projectRoot,
+      owner: 'worker-b',
+      limit: 2,
+      leaseMs: 20,
+      now: 110,
+    });
+    expect(recovered).toHaveLength(1);
+    expect(recovered[0]).toMatchObject({
+      idempotencyKey: 'memory:distill:retryable',
+      state: 'leased',
+      attempts: 2,
+      leaseOwner: 'worker-b',
+      errorCategory: 'lease_expired',
+    });
+
+    const revived = database.enqueueWork({
+      idempotencyKey: 'memory:vector:exhausted',
+      kind: 'memory.vector_backfill',
+      projectRoot,
+      payload: {},
+      maxAttempts: 20,
+      nextAttemptAt: 120,
+    });
+    expect(revived).toMatchObject({
+      state: 'failed',
+      attempts: 1,
+      maxAttempts: 20,
+      nextAttemptAt: 120,
+      errorCategory: undefined,
+    });
+  });
+});

package/dist/database.d.ts

@@ -1,3 +1,4 @@
+import type { EnqueueWorkInput, LeaseWorkInput, RequestSessionClosureInput, SessionClosureRecord, WorkError, WorkItemRecord, WorkQueueHealth } from './work-queue';
 export interface BenchmarkReportRecord {
     runId: string;
     suiteId: string;
@@ -81,6 +82,7 @@ export interface MemoryDistillCheckpointRecord {
     trigger: 'pre_compact' | 'session_end';
     pendingEvents: number;
     releasedLeases: number;
+    details?: Record<string, unknown>;
     createdAt: number;
 }
 export type MemoryTurnStatus = 'pending' | 'committed' | 'skipped';
@@ -167,6 +169,7 @@ export declare class DevFlowDatabase {
         availableMcpTools?: string[];
     }): void;
     getSkillExecution(executionId: string): any | null;
+    getLatestSkillExecutionForSession(sessionId: string): any | null;
     updateSkillExecution(executionId: string, updates: {
         status?: string;
         finishedAt?: number;
@@ -183,6 +186,7 @@ export declare class DevFlowDatabase {
         subagentCount?: number;
         metadata?: Record<string, unknown>;
     }): void;
+    mergeSkillExecutionMetadata(executionId: string, incoming: Record<string, unknown>): Record<string, unknown> | null;
     listSkillExecutions(limit: number, skillName?: string): any[];
     insertToolCallEvent(params: {
         eventId: string;
@@ -217,6 +221,7 @@ export declare class DevFlowDatabase {
     }): boolean;
     markToolCallBlocked(eventId: string, reason: string): boolean;
     reconcileSkillExecution(executionId: string, status: 'completed' | 'failed', finishedAt?: number, metadata?: Record<string, unknown>): void;
+    reconcileRunningSkillExecutionsForSession(sessionId: string, finishedAt?: number, metadata?: Record<string, unknown>): any[];
     getExecutionObligationCompliance(executionId: string): {
         rate: number;
         applicable: number;
@@ -300,6 +305,22 @@ export declare class DevFlowDatabase {
         items: GovernanceAuditRecord[];
         total: number;
     };
+    enqueueWork(input: EnqueueWorkInput): WorkItemRecord;
+    getWorkByIdempotencyKey(idempotencyKey: string): WorkItemRecord | null;
+    requestSessionClosure(input: RequestSessionClosureInput): SessionClosureRecord;
+    getSessionClosure(projectRoot: string, sessionId: string): SessionClosureRecord | null;
+    completeSessionClosure(projectRoot: string, sessionId: string, excludingWorkItemId?: string, closedAt?: number): SessionClosureRecord;
+    listSessionClosures(projectRoot: string, limit?: number): SessionClosureRecord[];
+    leaseWork(input: LeaseWorkInput): WorkItemRecord[];
+    completeWork(id: string, owner: string, now?: number): boolean;
+    retryWork(id: string, owner: string, error: WorkError, nextAttemptAt: number): boolean;
+    deferWork(id: string, owner: string, error: WorkError, nextAttemptAt: number): boolean;
+    deadLetterWork(id: string, owner: string, error: WorkError): boolean;
+    recoverExpiredWork(projectRoot: string, now?: number): number;
+    getWorkQueueHealth(projectRoot: string, now?: number): WorkQueueHealth;
+    private mapWorkItem;
+    private mapSessionClosure;
+    private refreshClosedSessionClosure;
     getHookReceipt(projectRoot: string): HookReceiptRecord | null;
     updateHookReceipt(projectRoot: string, updater: (current: HookReceiptRecord | null) => Omit<HookReceiptRecord, 'projectRoot' | 'updatedAt'>): HookReceiptRecord;
     deleteHookReceipt(projectRoot: string): boolean;
@@ -326,6 +347,7 @@ export declare class DevFlowDatabase {
     }): MemoryTurnRecord;
     markMemoryTurnStopPrompted(turnId: string, promptedAt?: number): boolean;
     listMemoryTurns(projectRoot: string, sessionId?: string, limit?: number): MemoryTurnRecord[];
+    listSessionMemoryTurnsForReconciliation(projectRoot: string, sessionId: string): MemoryTurnRecord[];
     insertHookFallback(record: HookFallbackRecord): boolean;
     listHookFallbacks(filter?: {
         projectRoot?: string;