@devflow-tools/database 0.16.10 → 0.16.11

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

@@ -360,4 +360,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;
@@ -217,6 +218,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 +302,21 @@ 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;
+    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;