@renseiai/agentfactory-server 0.8.0

package/dist/src/worker-storage.js

@@ -0,0 +1,295 @@
+/**
+ * Worker Storage Module
+ *
+ * Manages worker registration and tracking in Redis.
+ * Workers register on startup, send periodic heartbeats,
+ * and deregister on shutdown.
+ */
+import crypto from 'crypto';
+import { redisSet, redisGet, redisDel, redisKeys, redisSAdd, redisSRem, redisSMembers, isRedisConfigured, } from './redis.js';
+const log = {
+    info: (msg, data) => console.log(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// Redis key constants
+const WORKER_PREFIX = 'work:worker:';
+const WORKER_SESSIONS_SUFFIX = ':sessions';
+// Default TTL for worker registration (300 seconds = 5 minutes)
+// Worker must send heartbeat within this time or be considered offline.
+// 120s was too tight — busy workers processing long agents can miss heartbeats,
+// causing Redis key expiry, 404s, and re-registration cascades.
+const WORKER_TTL = parseInt(process.env.WORKER_TTL ?? '300', 10);
+// Heartbeat timeout (180 seconds = 6 missed 30-second heartbeats)
+// Increased from 90s to match the higher WORKER_TTL and prevent spurious offline detection.
+const HEARTBEAT_TIMEOUT = parseInt(process.env.WORKER_HEARTBEAT_TIMEOUT ?? '180000', 10);
+// Configurable intervals (in milliseconds)
+const HEARTBEAT_INTERVAL = parseInt(process.env.WORKER_HEARTBEAT_INTERVAL ?? '30000', 10);
+const POLL_INTERVAL = parseInt(process.env.WORKER_POLL_INTERVAL ?? '5000', 10);
+/**
+ * Register a new worker
+ *
+ * @param hostname - Worker's hostname
+ * @param capacity - Maximum concurrent agents the worker can handle
+ * @param version - Optional worker software version
+ * @returns Worker ID and configuration
+ */
+export async function registerWorker(hostname, capacity, version, projects) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot register worker');
+        return null;
+    }
+    try {
+        const workerId = `wkr_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+        const now = Date.now();
+        const workerData = {
+            id: workerId,
+            hostname,
+            capacity,
+            activeCount: 0,
+            registeredAt: now,
+            lastHeartbeat: now,
+            status: 'active',
+            version,
+            projects: projects?.length ? projects : undefined,
+        };
+        const key = `${WORKER_PREFIX}${workerId}`;
+        await redisSet(key, workerData, WORKER_TTL);
+        log.info('Worker registered', {
+            workerId,
+            hostname,
+            capacity,
+            projects: projects?.length ? projects : 'all',
+        });
+        return {
+            workerId,
+            heartbeatInterval: HEARTBEAT_INTERVAL,
+            pollInterval: POLL_INTERVAL,
+        };
+    }
+    catch (error) {
+        log.error('Failed to register worker', { error, hostname });
+        return null;
+    }
+}
+/**
+ * Update worker heartbeat
+ *
+ * @param workerId - Worker ID
+ * @param activeCount - Current number of active agents
+ * @param load - Optional system load metrics
+ * @returns Heartbeat acknowledgment or null on failure
+ */
+export async function updateHeartbeat(workerId, activeCount, load) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const worker = await redisGet(key);
+        if (!worker) {
+            log.warn('Heartbeat for unknown worker', { workerId });
+            return null;
+        }
+        // Update worker data
+        const updatedWorker = {
+            ...worker,
+            activeCount,
+            lastHeartbeat: Date.now(),
+            status: 'active',
+        };
+        // Reset TTL on heartbeat
+        await redisSet(key, updatedWorker, WORKER_TTL);
+        // Get pending work count (import dynamically to avoid circular dep)
+        const { getQueueLength } = await import('./work-queue');
+        const pendingWorkCount = await getQueueLength();
+        return {
+            acknowledged: true,
+            serverTime: new Date().toISOString(),
+            pendingWorkCount,
+        };
+    }
+    catch (error) {
+        log.error('Failed to update heartbeat', { error, workerId });
+        return null;
+    }
+}
+/**
+ * Get worker by ID
+ */
+export async function getWorker(workerId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const worker = await redisGet(key);
+        if (!worker) {
+            return null;
+        }
+        // Get active sessions for this worker
+        const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+        const activeSessions = await redisSMembers(sessionsKey);
+        return {
+            ...worker,
+            activeSessions,
+        };
+    }
+    catch (error) {
+        log.error('Failed to get worker', { error, workerId });
+        return null;
+    }
+}
+/**
+ * Deregister a worker
+ *
+ * @param workerId - Worker ID to deregister
+ * @returns List of session IDs that need to be re-queued
+ */
+export async function deregisterWorker(workerId) {
+    if (!isRedisConfigured()) {
+        return { deregistered: false, unclaimedSessions: [] };
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+        // Get sessions that need to be re-queued
+        const unclaimedSessions = await redisSMembers(sessionsKey);
+        // Delete worker registration and sessions set
+        await redisDel(key);
+        await redisDel(sessionsKey);
+        log.info('Worker deregistered', {
+            workerId,
+            unclaimedSessions: unclaimedSessions.length,
+        });
+        return {
+            deregistered: true,
+            unclaimedSessions,
+        };
+    }
+    catch (error) {
+        log.error('Failed to deregister worker', { error, workerId });
+        return { deregistered: false, unclaimedSessions: [] };
+    }
+}
+/**
+ * List all registered workers
+ */
+export async function listWorkers() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const keys = await redisKeys(`${WORKER_PREFIX}*`);
+        // Filter out session keys
+        const workerKeys = keys.filter((k) => !k.endsWith(WORKER_SESSIONS_SUFFIX));
+        const workers = [];
+        for (const key of workerKeys) {
+            const worker = await redisGet(key);
+            if (worker) {
+                const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+                const activeSessions = await redisSMembers(sessionsKey);
+                // Check if worker is stale
+                const isStale = Date.now() - worker.lastHeartbeat > HEARTBEAT_TIMEOUT;
+                const status = isStale ? 'offline' : worker.status;
+                workers.push({
+                    ...worker,
+                    status,
+                    activeSessions,
+                });
+            }
+        }
+        return workers;
+    }
+    catch (error) {
+        log.error('Failed to list workers', { error });
+        return [];
+    }
+}
+/**
+ * Get workers that have missed heartbeats (stale workers)
+ */
+export async function getStaleWorkers() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const workers = await listWorkers();
+        return workers.filter((w) => w.status === 'offline');
+    }
+    catch (error) {
+        log.error('Failed to get stale workers', { error });
+        return [];
+    }
+}
+/**
+ * Add a session to a worker's active sessions
+ *
+ * @param workerId - Worker ID
+ * @param sessionId - Session ID being processed
+ */
+export async function addWorkerSession(workerId, sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const sessionsKey = `${WORKER_PREFIX}${workerId}${WORKER_SESSIONS_SUFFIX}`;
+        await redisSAdd(sessionsKey, sessionId);
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to add worker session', { error, workerId, sessionId });
+        return false;
+    }
+}
+/**
+ * Remove a session from a worker's active sessions
+ *
+ * @param workerId - Worker ID
+ * @param sessionId - Session ID to remove
+ */
+export async function removeWorkerSession(workerId, sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const sessionsKey = `${WORKER_PREFIX}${workerId}${WORKER_SESSIONS_SUFFIX}`;
+        await redisSRem(sessionsKey, sessionId);
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to remove worker session', { error, workerId, sessionId });
+        return false;
+    }
+}
+/**
+ * Get total capacity across all active workers.
+ *
+ * Accepts an optional pre-fetched workers list to avoid redundant Redis scans
+ * (callers like the stats handler already call listWorkers()).
+ *
+ * Uses activeSessions.length (authoritative Redis set) instead of the
+ * heartbeat-reported activeCount, which can be stale after re-registration
+ * or between heartbeat intervals.
+ */
+export async function getTotalCapacity(prefetchedWorkers) {
+    if (!isRedisConfigured()) {
+        return { totalCapacity: 0, totalActive: 0, availableCapacity: 0 };
+    }
+    try {
+        const workers = prefetchedWorkers ?? await listWorkers();
+        const activeWorkers = workers.filter((w) => w.status === 'active');
+        const totalCapacity = activeWorkers.reduce((sum, w) => sum + w.capacity, 0);
+        const totalActive = activeWorkers.reduce((sum, w) => sum + w.activeSessions.length, 0);
+        return {
+            totalCapacity,
+            totalActive,
+            availableCapacity: totalCapacity - totalActive,
+        };
+    }
+    catch (error) {
+        log.error('Failed to get total capacity', { error });
+        return { totalCapacity: 0, totalActive: 0, availableCapacity: 0 };
+    }
+}

package/dist/src/workflow-state-integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-state-integration.test.d.ts.map

package/dist/src/workflow-state-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-state-integration.test.d.ts","sourceRoot":"","sources":["../../src/workflow-state-integration.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow-state-integration.test.js

@@ -0,0 +1,342 @@
+/**
+ * Integration tests for the 4-cycle workflow state progression
+ * and escalate-human circuit breaker.
+ *
+ * Mocks Redis to test the full lifecycle:
+ *   Cycle 1 (normal) → Cycle 2 (context-enriched) → Cycle 3 (decompose) → Cycle 4 (escalate-human)
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// In-memory Redis store for testing
+const store = new Map();
+vi.mock('./redis.js', () => ({
+    redisSet: vi.fn(async (key, value, _ttl) => {
+        store.set(key, JSON.stringify(value));
+    }),
+    redisGet: vi.fn(async (key) => {
+        const val = store.get(key);
+        return val ? JSON.parse(val) : null;
+    }),
+    redisDel: vi.fn(async (key) => {
+        const existed = store.has(key) ? 1 : 0;
+        store.delete(key);
+        return existed;
+    }),
+    redisExists: vi.fn(async (key) => store.has(key)),
+}));
+import { computeStrategy, getWorkflowState, updateWorkflowState, recordPhaseAttempt, incrementCycleCount, appendFailureSummary, clearWorkflowState, extractFailureReason, getTotalSessionCount, MAX_TOTAL_SESSIONS, markAcceptanceCompleted, didAcceptanceJustComplete, clearAcceptanceCompleted, } from './agent-tracking.js';
+beforeEach(() => {
+    store.clear();
+});
+/**
+ * Simulate what the webhook-orchestrator onAgentComplete handler does
+ * when a QA/acceptance agent fails.
+ */
+async function simulateQAFailure(issueId, failureMessage) {
+    const state = await incrementCycleCount(issueId);
+    const failureReason = extractFailureReason(failureMessage);
+    const formattedFailure = `--- Cycle ${state.cycleCount}, qa (${new Date().toISOString()}) ---\n${failureReason}`;
+    await appendFailureSummary(issueId, formattedFailure);
+    return await getWorkflowState(issueId);
+}
+/**
+ * Simulate what the webhook-orchestrator onAgentComplete handler does
+ * when recording a phase attempt.
+ */
+async function simulatePhaseCompletion(issueId, phase, result, costUsd = 0.50) {
+    await recordPhaseAttempt(issueId, phase, {
+        attempt: 1,
+        sessionId: `session-${phase}-${Date.now()}`,
+        startedAt: Date.now(),
+        completedAt: Date.now(),
+        result,
+        costUsd,
+    });
+}
+describe('4-cycle workflow progression integration', () => {
+    const issueId = 'test-issue-001';
+    const issueIdentifier = 'TEST-42';
+    it('progresses through all 4 escalation tiers across full dev-QA-rejected cycles', async () => {
+        // Initialize workflow state (happens on first agent completion)
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // === Cycle 1: normal ===
+        // Development completes, QA fails
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        let state = await simulateQAFailure(issueId, '## QA Failed\n\nTests failed: TypeError in handleUserLogin — null check missing');
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(1);
+        expect(state.strategy).toBe('normal');
+        expect(state.failureSummary).toContain('TypeError in handleUserLogin');
+        // At cycle 1 (normal), strategy would provide retry context for development
+        expect(computeStrategy(1)).toBe('normal');
+        // === Cycle 2: context-enriched ===
+        // Refinement completes, development re-runs, QA fails again
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, '## QA Failed\n\nBuild passes but integration test for /api/users returns 500. Missing database migration.');
+        expect(state.cycleCount).toBe(2);
+        expect(state.strategy).toBe('context-enriched');
+        expect(state.failureSummary).toContain('Cycle 1');
+        expect(state.failureSummary).toContain('Cycle 2');
+        expect(state.failureSummary).toContain('database migration');
+        // At cycle 2 (context-enriched), refinement gets full failure history
+        expect(computeStrategy(2)).toBe('context-enriched');
+        // === Cycle 3: decompose ===
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, 'Failure Reason: The same /api/users endpoint still returns 500. Root cause is the missing foreign key constraint in the migration.');
+        expect(state.cycleCount).toBe(3);
+        expect(state.strategy).toBe('decompose');
+        expect(state.failureSummary).toContain('Cycle 3');
+        // At cycle 3 (decompose), refinement gets decomposition instructions
+        expect(computeStrategy(3)).toBe('decompose');
+        // === Cycle 4: escalate-human ===
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, 'Issues Found:\n1. API endpoint still broken\n2. Migration file has syntax error\n3. Schema mismatch between ORM and SQL');
+        expect(state.cycleCount).toBe(4);
+        expect(state.strategy).toBe('escalate-human');
+        expect(state.failureSummary).toContain('Cycle 4');
+        // At cycle 4+ (escalate-human), the loop should stop entirely
+        expect(computeStrategy(state.cycleCount)).toBe('escalate-human');
+        expect(computeStrategy(state.cycleCount + 1)).toBe('escalate-human');
+        // Verify all 4 phase records tracked for development and QA
+        expect(state.phases.development).toHaveLength(4);
+        expect(state.phases.qa).toHaveLength(4);
+        expect(state.phases.refinement).toHaveLength(3);
+    });
+    it('accumulates failure summaries across all cycles with correct formatting', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Simulate 4 failures with distinct messages
+        const failures = [
+            '## QA Failed\n\nNull pointer in UserService.getById',
+            'Failure Reason: Missing validation on email field causes 500',
+            'Issues Found:\n1. Race condition in session manager\n2. Stale cache returns wrong user',
+            '## QA Failed\n\nDatabase connection pool exhausted after 10 concurrent requests',
+        ];
+        for (const msg of failures) {
+            await simulateQAFailure(issueId, msg);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(4);
+        expect(state.strategy).toBe('escalate-human');
+        // All 4 cycle markers should be present
+        expect(state.failureSummary).toContain('Cycle 1');
+        expect(state.failureSummary).toContain('Cycle 2');
+        expect(state.failureSummary).toContain('Cycle 3');
+        expect(state.failureSummary).toContain('Cycle 4');
+        // Failure details from each cycle should be present
+        expect(state.failureSummary).toContain('Null pointer in UserService');
+        expect(state.failureSummary).toContain('Missing validation on email');
+        expect(state.failureSummary).toContain('Race condition in session manager');
+        expect(state.failureSummary).toContain('Database connection pool exhausted');
+    });
+    it('tracks per-phase attempt records and costs across cycles', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Cycle 1: dev → qa(fail)
+        await simulatePhaseCompletion(issueId, 'development', 'passed', 1.50);
+        await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.75);
+        await simulateQAFailure(issueId, 'Tests failed');
+        // Cycle 2: refinement → dev → qa(fail)
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed', 0.50);
+        await simulatePhaseCompletion(issueId, 'development', 'passed', 2.00);
+        await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.80);
+        await simulateQAFailure(issueId, 'Build failed');
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        // Check phase records exist
+        expect(state.phases.development).toHaveLength(2);
+        expect(state.phases.qa).toHaveLength(2);
+        expect(state.phases.refinement).toHaveLength(1);
+        expect(state.phases.acceptance).toHaveLength(0);
+        // Calculate total cost (simulates what the escalation comment builder does)
+        const allPhases = [
+            ...state.phases.development,
+            ...state.phases.qa,
+            ...state.phases.refinement,
+            ...state.phases.acceptance,
+        ];
+        const totalCost = allPhases.reduce((sum, p) => sum + (p.costUsd ?? 0), 0);
+        expect(totalCost).toBeCloseTo(5.55, 2);
+    });
+    it('clears workflow state on acceptance pass', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        await simulateQAFailure(issueId, 'Tests failed');
+        let state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(1);
+        // Acceptance pass clears everything
+        await clearWorkflowState(issueId);
+        state = await getWorkflowState(issueId);
+        expect(state).toBeNull();
+    });
+    it('strategy-based circuit breaker blocks at cycle 4+', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Progress to escalate-human (cycle 4)
+        for (let i = 0; i < 4; i++) {
+            await simulateQAFailure(issueId, `Failure in cycle ${i + 1}`);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state.strategy).toBe('escalate-human');
+        // Circuit breaker check: this is what issue-updated.ts does
+        const shouldBlock = state.strategy === 'escalate-human';
+        expect(shouldBlock).toBe(true);
+        // Verify further increments stay at escalate-human
+        await simulateQAFailure(issueId, 'Yet another failure');
+        const state2 = await getWorkflowState(issueId);
+        expect(state2.cycleCount).toBe(5);
+        expect(state2.strategy).toBe('escalate-human');
+    });
+});
+describe('escalate-human blocker creation data', () => {
+    const issueId = 'blocker-test-001';
+    const issueIdentifier = 'TEST-99';
+    it('provides correct data for blocker issue creation at cycle 4', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Simulate 4 cycles with realistic failures
+        const qaFailures = [
+            '## QA Failed\n\nUnit tests in packages/core fail with TypeError: Cannot read property of undefined',
+            'Failure Reason: Integration test for webhook handler times out after 30s',
+            'Issues Found:\n1. Missing mock for Redis in test setup\n2. Race condition in async handler',
+            '## QA Failed\n\nTypecheck fails: Property "strategy" does not exist on type "WorkflowState"',
+        ];
+        for (const msg of qaFailures) {
+            await simulatePhaseCompletion(issueId, 'development', 'passed', 1.00);
+            await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.50);
+            await simulateQAFailure(issueId, msg);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.strategy).toBe('escalate-human');
+        expect(state.cycleCount).toBe(4);
+        // Verify the data that would be used to create the blocker issue
+        const { cycleCount, failureSummary, phases } = state;
+        // Blocker title matches what issue-updated.ts generates
+        const blockerTitle = `Human review needed: ${issueIdentifier} failed ${cycleCount} automated cycles`;
+        expect(blockerTitle).toBe('Human review needed: TEST-99 failed 4 automated cycles');
+        // Blocker description includes failure summary
+        const blockerDescription = [
+            `This issue has failed **${cycleCount} automated dev-QA-rejected cycles** and requires human intervention.`,
+            '',
+            '### Failure History',
+            failureSummary ?? 'No failure details recorded.',
+            '',
+            '---',
+            `*Source issue: ${issueIdentifier}*`,
+        ].join('\n');
+        expect(blockerDescription).toContain('4 automated dev-QA-rejected cycles');
+        expect(blockerDescription).toContain('TypeError: Cannot read property');
+        expect(blockerDescription).toContain('Race condition in async handler');
+        expect(blockerDescription).toContain('Source issue: TEST-99');
+        // Escalation comment includes total cost
+        const allPhases = [
+            ...phases.development,
+            ...phases.qa,
+            ...phases.refinement,
+            ...phases.acceptance,
+        ];
+        const totalCost = allPhases.reduce((sum, p) => sum + (p.costUsd ?? 0), 0);
+        expect(totalCost).toBeCloseTo(6.00, 2); // 4 × (1.00 + 0.50)
+        const costLine = totalCost > 0 ? `\n**Total cost across all attempts:** $${totalCost.toFixed(2)}` : '';
+        expect(costLine).toContain('$6.00');
+        // Escalation comment content
+        const escalationComment = `## Circuit Breaker: Human Intervention Required\n\n` +
+            `This issue has gone through **${cycleCount} dev-QA-rejected cycles** without passing.\n` +
+            `The automated system is stopping further attempts.\n` +
+            costLine +
+            `\n\n### Failure History\n\n${failureSummary ?? 'No failure details recorded.'}\n\n` +
+            `### Recommended Actions\n` +
+            `1. Review the failure patterns above\n` +
+            `2. Consider if the acceptance criteria need clarification\n` +
+            `3. Investigate whether there's an architectural issue\n` +
+            `4. Manually fix or decompose the issue before re-enabling automation`;
+        expect(escalationComment).toContain('4 dev-QA-rejected cycles');
+        expect(escalationComment).toContain('$6.00');
+        expect(escalationComment).toContain('Cycle 1');
+        expect(escalationComment).toContain('Cycle 4');
+        expect(escalationComment).toContain('Recommended Actions');
+    });
+    it('verifies escalation strategy is deterministic and never regresses', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        const expectedProgression = [
+            { cycle: 1, strategy: 'normal' },
+            { cycle: 2, strategy: 'context-enriched' },
+            { cycle: 3, strategy: 'decompose' },
+            { cycle: 4, strategy: 'escalate-human' },
+            { cycle: 5, strategy: 'escalate-human' },
+            { cycle: 6, strategy: 'escalate-human' },
+        ];
+        for (const { cycle, strategy } of expectedProgression) {
+            const state = await incrementCycleCount(issueId);
+            expect(state.cycleCount).toBe(cycle);
+            expect(state.strategy).toBe(strategy);
+            // Verify computeStrategy matches what's stored
+            expect(computeStrategy(state.cycleCount)).toBe(state.strategy);
+        }
+    });
+});
+describe('getTotalSessionCount', () => {
+    const issueId = 'session-count-test-001';
+    const issueIdentifier = 'TEST-SC';
+    it('returns 0 for nonexistent issue', async () => {
+        const count = await getTotalSessionCount('nonexistent-issue-id');
+        expect(count).toBe(0);
+    });
+    it('correctly sums across all phases', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Add 2 development, 2 qa, 1 refinement, 1 acceptance
+        await recordPhaseAttempt(issueId, 'development', {
+            attempt: 1, sessionId: 'dev-1', startedAt: Date.now(), result: 'passed', costUsd: 1.0,
+        });
+        await recordPhaseAttempt(issueId, 'development', {
+            attempt: 2, sessionId: 'dev-2', startedAt: Date.now(), result: 'passed', costUsd: 1.0,
+        });
+        await recordPhaseAttempt(issueId, 'qa', {
+            attempt: 1, sessionId: 'qa-1', startedAt: Date.now(), result: 'failed', costUsd: 0.5,
+        });
+        await recordPhaseAttempt(issueId, 'qa', {
+            attempt: 2, sessionId: 'qa-2', startedAt: Date.now(), result: 'passed', costUsd: 0.5,
+        });
+        await recordPhaseAttempt(issueId, 'refinement', {
+            attempt: 1, sessionId: 'ref-1', startedAt: Date.now(), result: 'passed', costUsd: 0.3,
+        });
+        await recordPhaseAttempt(issueId, 'acceptance', {
+            attempt: 1, sessionId: 'acc-1', startedAt: Date.now(), result: 'passed', costUsd: 0.2,
+        });
+        const count = await getTotalSessionCount(issueId);
+        expect(count).toBe(6); // 2 + 2 + 1 + 1
+    });
+    it('returns count that would hit MAX_TOTAL_SESSIONS', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Add exactly MAX_TOTAL_SESSIONS phase records
+        for (let i = 0; i < MAX_TOTAL_SESSIONS; i++) {
+            const phase = i % 2 === 0 ? 'development' : 'qa';
+            await recordPhaseAttempt(issueId, phase, {
+                attempt: i + 1, sessionId: `session-${i}`, startedAt: Date.now(), result: 'passed',
+            });
+        }
+        const count = await getTotalSessionCount(issueId);
+        expect(count).toBe(MAX_TOTAL_SESSIONS);
+        expect(count >= MAX_TOTAL_SESSIONS).toBe(true);
+    });
+});
+describe('acceptance completion lock', () => {
+    const issueId = 'acceptance-lock-test-001';
+    it('returns false before marking, true after marking', async () => {
+        const beforeMark = await didAcceptanceJustComplete(issueId);
+        expect(beforeMark).toBe(false);
+        await markAcceptanceCompleted(issueId);
+        const afterMark = await didAcceptanceJustComplete(issueId);
+        expect(afterMark).toBe(true);
+    });
+    it('returns false after clearing', async () => {
+        await markAcceptanceCompleted(issueId);
+        expect(await didAcceptanceJustComplete(issueId)).toBe(true);
+        await clearAcceptanceCompleted(issueId);
+        expect(await didAcceptanceJustComplete(issueId)).toBe(false);
+    });
+});

package/dist/src/workflow-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-state.test.d.ts.map

package/dist/src/workflow-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-state.test.d.ts","sourceRoot":"","sources":["../../src/workflow-state.test.ts"],"names":[],"mappings":""}