@devflow-tools/database 0.16.11 → 0.16.13

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.16.13](https://github.com/shilongfeicool/dev-flow/compare/v0.16.12...v0.16.13) (2026-07-26)
+
+
+### Features
+
+* add retrieval quality control plane ([743bd12](https://github.com/shilongfeicool/dev-flow/commit/743bd12daa18ceec611dc82674b20b015d110f0c))
+
+
+
+
+
+## [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',

package/dist/database.d.ts

@@ -1,4 +1,5 @@
 import type { EnqueueWorkInput, LeaseWorkInput, RequestSessionClosureInput, SessionClosureRecord, WorkError, WorkItemRecord, WorkQueueHealth } from './work-queue';
+import { type SessionObligationRecord, type SessionObligationState } from './obligation-ledger';
 export interface BenchmarkReportRecord {
     runId: string;
     suiteId: string;
@@ -74,6 +75,22 @@ export interface ContextReceiptRecord {
     contextHash: string;
     issuedAt: number;
     expiresAt: number;
+    selectedFiles?: string[];
+    memoryIds?: string[];
+    canonicalNextAction?: string;
+    requestId?: string;
+}
+export interface ContextSelectionEventRecord {
+    id: string;
+    projectRoot: string;
+    sessionId: string;
+    executionId: string;
+    requestId?: string;
+    selectionType: 'code' | 'action';
+    candidateId: string;
+    toolName: string;
+    toolUseId?: string;
+    selectedAt: number;
 }
 export interface MemoryDistillCheckpointRecord {
     id: string;
@@ -82,6 +99,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';
@@ -168,6 +186,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;
@@ -184,6 +203,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;
@@ -214,6 +234,7 @@ export declare class DevFlowDatabase {
     updateToolCallEvent(eventId: string, updates: {
         output?: string;
         error?: string;
+        failureCategory?: string;
         duration?: number;
     }): boolean;
     markToolCallBlocked(eventId: string, reason: string): boolean;
@@ -311,20 +332,43 @@ export declare class DevFlowDatabase {
     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;
+    private countSessionLifecyclePending;
     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;
+    getActiveContextReceipt(projectRoot: string, sessionId: string, executionId?: string, now?: number): ContextReceiptRecord | null;
+    recordContextSelectionEvent(event: ContextSelectionEventRecord): boolean;
+    listContextSelectionEvents(options: {
+        projectRoot: string;
+        sessionId?: string;
+        executionId?: string;
+        requestId?: string;
+    }): ContextSelectionEventRecord[];
     deleteContextReceipt(projectRoot: string, sessionId: string, executionId?: string): number;
     purgeExpiredContextReceipts(now?: number): number;
     beginMemoryTurn(input: Omit<MemoryTurnRecord, 'status' | 'memoryIds'>): MemoryTurnRecord;
+    upsertSessionObligation(record: SessionObligationRecord): SessionObligationRecord;
+    getSessionObligation(projectRoot: string, sessionId: string, obligationId: string): SessionObligationRecord | null;
+    listSessionObligations(projectRoot: string, sessionId: string, states?: SessionObligationState[]): SessionObligationRecord[];
+    resolveSessionObligation(input: {
+        projectRoot: string;
+        sessionId: string;
+        obligationId: string;
+        state: 'satisfied' | 'degraded' | 'cancelled';
+        receiptId?: string;
+        reason?: string;
+        resolvedAt?: number;
+    }): SessionObligationRecord;
+    countOpenSessionObligations(projectRoot: string, sessionId: string): number;
     getMemoryTurn(turnId: string): MemoryTurnRecord | null;
     getPendingMemoryTurn(projectRoot: string, sessionId: string): MemoryTurnRecord | null;
     commitMemoryTurn(input: {
@@ -342,7 +386,9 @@ export declare class DevFlowDatabase {
         decidedAt?: number;
     }): MemoryTurnRecord;
     markMemoryTurnStopPrompted(turnId: string, promptedAt?: number): boolean;
+    private ensureMemoryObligation;
     listMemoryTurns(projectRoot: string, sessionId?: string, limit?: number): MemoryTurnRecord[];
+    listSessionMemoryTurnsForReconciliation(projectRoot: string, sessionId: string): MemoryTurnRecord[];
     insertHookFallback(record: HookFallbackRecord): boolean;
     listHookFallbacks(filter?: {
         projectRoot?: string;