@renseiai/agentfactory-server 0.8.0

package/dist/src/orphan-cleanup.js

@@ -0,0 +1,369 @@
+/**
+ * Orphan Cleanup Module
+ *
+ * Detects and handles orphaned sessions - sessions marked as running/claimed
+ * but whose worker is no longer active (heartbeat timeout).
+ *
+ * When a worker disconnects, the work is re-queued for another worker to resume.
+ * The Linear issue status is NOT rolled back - the issue remains in its current
+ * workflow state and the next worker will resume from where the previous one left off.
+ */
+import { createLogger } from './logger.js';
+import { getAllSessions, resetSessionForRequeue, } from './session-storage.js';
+import { listWorkers } from './worker-storage.js';
+import { releaseClaim, isSessionInQueue, } from './work-queue.js';
+import { dispatchWork, cleanupExpiredLocksWithPendingWork, cleanupStaleLocksWithIdleWorkers, isSessionParkedForIssue, getIssueLock, releaseIssueLock, } from './issue-lock.js';
+const log = createLogger('orphan-cleanup');
+// How long a session can be running without a valid worker before being considered orphaned
+const ORPHAN_THRESHOLD_MS = 120_000; // 2 minutes (worker TTL + buffer)
+/**
+ * Find sessions that are orphaned (running/claimed but worker is gone)
+ */
+export async function findOrphanedSessions() {
+    const [sessions, workers] = await Promise.all([
+        getAllSessions(),
+        listWorkers(),
+    ]);
+    // Build set of active worker IDs
+    const activeWorkerIds = new Set(workers
+        .filter((w) => w.status === 'active')
+        .map((w) => w.id));
+    const orphaned = [];
+    for (const session of sessions) {
+        // Only check running or claimed sessions
+        if (session.status !== 'running' && session.status !== 'claimed') {
+            continue;
+        }
+        // Grace period: skip sessions updated recently — prevents race when a worker
+        // re-registers with a new ID but hasn't transferred session ownership yet
+        const sessionAge = Date.now() - session.updatedAt;
+        if (sessionAge < ORPHAN_THRESHOLD_MS) {
+            log.debug('Session recently updated, skipping orphan check', {
+                sessionId: session.linearSessionId,
+                ageMs: sessionAge,
+            });
+            continue;
+        }
+        // If session has no worker assigned, it's orphaned
+        if (!session.workerId) {
+            log.debug('Session has no worker assigned', {
+                sessionId: session.linearSessionId,
+                status: session.status,
+            });
+            orphaned.push(session);
+            continue;
+        }
+        // If the assigned worker is no longer active, session is orphaned
+        if (!activeWorkerIds.has(session.workerId)) {
+            log.debug('Session worker is no longer active', {
+                sessionId: session.linearSessionId,
+                workerId: session.workerId,
+                status: session.status,
+            });
+            orphaned.push(session);
+            continue;
+        }
+    }
+    return orphaned;
+}
+// How long a pending session can exist without a queue entry before being considered a zombie
+const ZOMBIE_PENDING_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Find zombie pending sessions — sessions stuck in `pending` status
+ * that have no corresponding entry in the work queue or any issue-pending queue.
+ *
+ * These arise when:
+ * - claimWork() removes from queue, but claimSession() fails and requeue also fails
+ * - Issue lock expires but promotion fails silently
+ */
+export async function findZombiePendingSessions() {
+    const sessions = await getAllSessions();
+    const now = Date.now();
+    const zombies = [];
+    for (const session of sessions) {
+        if (session.status !== 'pending')
+            continue;
+        // Only consider sessions older than the threshold
+        const age = now - session.updatedAt;
+        if (age < ZOMBIE_PENDING_THRESHOLD_MS)
+            continue;
+        // Check if session is in the global work queue
+        const inQueue = await isSessionInQueue(session.linearSessionId);
+        if (inQueue)
+            continue;
+        // Check if session is parked in the issue-pending queue
+        const parked = await isSessionParkedForIssue(session.issueId, session.linearSessionId);
+        if (parked)
+            continue;
+        // Session is pending but not in any queue — it's a zombie
+        log.warn('Found zombie pending session', {
+            sessionId: session.linearSessionId,
+            issueIdentifier: session.issueIdentifier,
+            ageMinutes: Math.round(age / 60_000),
+        });
+        zombies.push(session);
+    }
+    return zombies;
+}
+/**
+ * Clean up orphaned sessions by re-queuing them
+ *
+ * @param callbacks - Optional callbacks for external integrations (e.g., posting Linear comments)
+ */
+export async function cleanupOrphanedSessions(callbacks) {
+    const result = {
+        checked: 0,
+        orphaned: 0,
+        requeued: 0,
+        failed: 0,
+        details: [],
+        worktreePathsToCleanup: [],
+    };
+    try {
+        const sessions = await getAllSessions();
+        result.checked = sessions.length;
+        const orphaned = await findOrphanedSessions();
+        result.orphaned = orphaned.length;
+        if (orphaned.length > 0) {
+            log.info('Found orphaned sessions', { count: orphaned.length });
+        }
+        for (const session of orphaned) {
+            try {
+                const issueIdentifier = session.issueIdentifier || session.issueId.slice(0, 8);
+                log.info('Re-queuing orphaned session', {
+                    sessionId: session.linearSessionId,
+                    issueIdentifier,
+                    previousWorker: session.workerId,
+                    previousStatus: session.status,
+                });
+                // Release any existing claim
+                await releaseClaim(session.linearSessionId);
+                // Release the issue lock if held by this orphaned session.
+                // Without this, dispatchWork() below would fail to acquire the lock
+                // (SET NX) and park the work instead — leaving it stuck until the
+                // lock's 2-hour TTL expires, since the session is reset to 'pending'
+                // which the stale-lock cleanup doesn't consider terminal.
+                const existingLock = await getIssueLock(session.issueId);
+                if (existingLock && existingLock.sessionId === session.linearSessionId) {
+                    log.info('Releasing issue lock held by orphaned session', {
+                        sessionId: session.linearSessionId,
+                        issueId: session.issueId,
+                    });
+                    await releaseIssueLock(session.issueId);
+                }
+                // Reset session for requeue (clears workerId so new worker can claim)
+                await resetSessionForRequeue(session.linearSessionId);
+                // Re-queue the work with higher priority
+                // IMPORTANT: Preserve workType to prevent incorrect status transitions
+                // NOTE: Do NOT preserve providerSessionId - the old session may be corrupted
+                // from the crash that caused the orphan. Starting fresh is safer.
+                const work = {
+                    sessionId: session.linearSessionId,
+                    issueId: session.issueId,
+                    issueIdentifier,
+                    priority: Math.max(1, (session.priority || 3) - 1), // Boost priority
+                    queuedAt: Date.now(),
+                    prompt: session.promptContext,
+                    // providerSessionId intentionally omitted - don't resume crashed sessions
+                    workType: session.workType,
+                    projectName: session.projectName,
+                };
+                const dispatchResult = await dispatchWork(work);
+                if (dispatchResult.dispatched || dispatchResult.parked) {
+                    result.requeued++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                        action: 'requeued',
+                        worktreePath: session.worktreePath,
+                    });
+                    // Track worktree path for cleanup on worker machines
+                    if (session.worktreePath) {
+                        result.worktreePathsToCleanup.push(session.worktreePath);
+                    }
+                    // Call external callback (e.g., post Linear comment)
+                    if (callbacks?.onOrphanRequeued) {
+                        try {
+                            await callbacks.onOrphanRequeued(session);
+                        }
+                        catch (err) {
+                            log.warn('onOrphanRequeued callback failed', { error: err });
+                        }
+                    }
+                }
+                else {
+                    result.failed++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                        action: 'failed',
+                        reason: 'Failed to queue work',
+                    });
+                }
+            }
+            catch (err) {
+                log.error('Failed to cleanup orphaned session', {
+                    sessionId: session.linearSessionId,
+                    error: err,
+                });
+                result.failed++;
+                result.details.push({
+                    sessionId: session.linearSessionId,
+                    issueIdentifier: session.issueIdentifier || 'unknown',
+                    action: 'failed',
+                    reason: err instanceof Error ? err.message : 'Unknown error',
+                });
+            }
+        }
+        // Check for zombie pending sessions (pending but not in any queue)
+        try {
+            const zombies = await findZombiePendingSessions();
+            if (zombies.length > 0) {
+                log.info('Found zombie pending sessions', { count: zombies.length });
+            }
+            for (const session of zombies) {
+                try {
+                    const issueIdentifier = session.issueIdentifier || session.issueId.slice(0, 8);
+                    log.info('Re-dispatching zombie pending session', {
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                    });
+                    // Release issue lock if held by this zombie session (same rationale as orphan cleanup)
+                    const existingLock = await getIssueLock(session.issueId);
+                    if (existingLock && existingLock.sessionId === session.linearSessionId) {
+                        log.info('Releasing issue lock held by zombie session', {
+                            sessionId: session.linearSessionId,
+                            issueId: session.issueId,
+                        });
+                        await releaseIssueLock(session.issueId);
+                    }
+                    const work = {
+                        sessionId: session.linearSessionId,
+                        issueId: session.issueId,
+                        issueIdentifier,
+                        priority: Math.max(1, (session.priority || 3) - 1),
+                        queuedAt: Date.now(),
+                        prompt: session.promptContext,
+                        workType: session.workType,
+                        projectName: session.projectName,
+                    };
+                    const dispatchResult = await dispatchWork(work);
+                    if (dispatchResult.dispatched || dispatchResult.parked) {
+                        result.requeued++;
+                        result.details.push({
+                            sessionId: session.linearSessionId,
+                            issueIdentifier,
+                            action: 'requeued',
+                            reason: 'Zombie pending session recovered',
+                        });
+                        // Call external callback
+                        if (callbacks?.onZombieRecovered) {
+                            try {
+                                await callbacks.onZombieRecovered(session);
+                            }
+                            catch (err) {
+                                log.warn('onZombieRecovered callback failed', { error: err });
+                            }
+                        }
+                    }
+                    else {
+                        result.failed++;
+                        result.details.push({
+                            sessionId: session.linearSessionId,
+                            issueIdentifier,
+                            action: 'failed',
+                            reason: 'Failed to re-dispatch zombie session',
+                        });
+                    }
+                }
+                catch (err) {
+                    log.error('Failed to recover zombie session', {
+                        sessionId: session.linearSessionId,
+                        error: err,
+                    });
+                    result.failed++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier: session.issueIdentifier || 'unknown',
+                        action: 'failed',
+                        reason: err instanceof Error ? err.message : 'Unknown error',
+                    });
+                }
+            }
+        }
+        catch (err) {
+            log.error('Failed to find zombie pending sessions', { error: err });
+        }
+        // Also check for expired issue locks with pending work
+        try {
+            const promoted = await cleanupExpiredLocksWithPendingWork();
+            if (promoted > 0) {
+                log.info('Promoted pending work from expired issue locks', { promoted });
+            }
+        }
+        catch (err) {
+            log.error('Failed to cleanup expired issue locks', { error: err });
+        }
+        // Check for stale locks held by completed sessions when workers have idle capacity.
+        // Only runs when workers are online — no point promoting if nobody can pick it up.
+        try {
+            const workers = await listWorkers();
+            const activeWorkers = workers.filter((w) => w.status === 'active');
+            const hasIdleWorkers = activeWorkers.length > 0 &&
+                activeWorkers.some((w) => w.activeCount < w.capacity);
+            if (hasIdleWorkers) {
+                const promoted = await cleanupStaleLocksWithIdleWorkers(hasIdleWorkers);
+                if (promoted > 0) {
+                    log.info('Promoted parked work from stale issue locks', { promoted });
+                }
+            }
+        }
+        catch (err) {
+            log.error('Failed to cleanup stale issue locks', { error: err });
+        }
+        log.info('Orphan cleanup completed', {
+            checked: result.checked,
+            orphaned: result.orphaned,
+            requeued: result.requeued,
+            failed: result.failed,
+            worktreePathsToCleanup: result.worktreePathsToCleanup.length,
+        });
+        // Log worktree cleanup info if any paths need attention
+        if (result.worktreePathsToCleanup.length > 0) {
+            log.info('Worktree cleanup needed on worker machines', {
+                paths: result.worktreePathsToCleanup,
+                note: 'Run cleanup-worktrees on each worker machine to remove orphaned worktrees',
+            });
+        }
+    }
+    catch (err) {
+        log.error('Orphan cleanup failed', { error: err });
+    }
+    return result;
+}
+/**
+ * Check if cleanup should run based on time since last cleanup
+ * Returns true if enough time has passed
+ */
+let lastCleanupTime = 0;
+const CLEANUP_INTERVAL_MS = 60_000; // Run at most once per minute
+export function shouldRunCleanup() {
+    const now = Date.now();
+    if (now - lastCleanupTime >= CLEANUP_INTERVAL_MS) {
+        lastCleanupTime = now;
+        return true;
+    }
+    return false;
+}
+/**
+ * Run cleanup if enough time has passed (debounced)
+ * Safe to call frequently - will only actually run periodically
+ *
+ * @param callbacks - Optional callbacks for external integrations
+ */
+export async function maybeCleanupOrphans(callbacks) {
+    if (!shouldRunCleanup()) {
+        return null;
+    }
+    return cleanupOrphanedSessions(callbacks);
+}

package/dist/src/pending-prompts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pending Prompts Module
+ *
+ * Stores follow-up prompts for running agent sessions.
+ * Workers poll for pending prompts and forward them to their running Claude processes.
+ */
+/**
+ * A pending prompt waiting to be delivered to a running agent
+ */
+export interface PendingPrompt {
+    id: string;
+    sessionId: string;
+    issueId: string;
+    prompt: string;
+    userId?: string;
+    userName?: string;
+    createdAt: number;
+}
+/**
+ * Store a pending prompt for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @param issueId - The Linear issue ID
+ * @param prompt - The prompt text from the user
+ * @param user - Optional user info
+ * @returns The created prompt or null if storage failed
+ */
+export declare function storePendingPrompt(sessionId: string, issueId: string, prompt: string, user?: {
+    id?: string;
+    name?: string;
+}): Promise<PendingPrompt | null>;
+/**
+ * Get all pending prompts for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @returns Array of pending prompts (oldest first)
+ */
+export declare function getPendingPrompts(sessionId: string): Promise<PendingPrompt[]>;
+/**
+ * Get the count of pending prompts for a session
+ */
+export declare function getPendingPromptCount(sessionId: string): Promise<number>;
+/**
+ * Claim and remove a pending prompt by ID
+ * Returns the prompt if found and removed, null otherwise
+ *
+ * @param sessionId - The Linear session ID
+ * @param promptId - The prompt ID to claim
+ * @returns The claimed prompt or null
+ */
+export declare function claimPendingPrompt(sessionId: string, promptId: string): Promise<PendingPrompt | null>;
+/**
+ * Pop the oldest pending prompt for a session (claim and remove atomically)
+ *
+ * @param sessionId - The Linear session ID
+ * @returns The oldest pending prompt or null if none
+ */
+export declare function popPendingPrompt(sessionId: string): Promise<PendingPrompt | null>;
+/**
+ * Clear all pending prompts for a session
+ * Called when session completes or is stopped
+ *
+ * @param sessionId - The Linear session ID
+ * @returns true if cleared successfully
+ */
+export declare function clearPendingPrompts(sessionId: string): Promise<boolean>;
+//# sourceMappingURL=pending-prompts.d.ts.map

package/dist/src/pending-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-prompts.d.ts","sourceRoot":"","sources":["../../src/pending-prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiBH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACpC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAiC/B;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAanF;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY9E;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAwB/B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAkBvF;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAc7E"}

package/dist/src/pending-prompts.js

@@ -0,0 +1,176 @@
+/**
+ * Pending Prompts Module
+ *
+ * Stores follow-up prompts for running agent sessions.
+ * Workers poll for pending prompts and forward them to their running Claude processes.
+ */
+import { redisRPush, redisLRange, redisLRem, redisLLen, redisDel, isRedisConfigured, } from './redis.js';
+import { createLogger } from './logger.js';
+const log = createLogger('pending-prompts');
+// Redis key prefix for pending prompts per session
+const PENDING_PROMPTS_PREFIX = 'session:prompts:';
+/**
+ * Build the Redis key for a session's pending prompts
+ */
+function buildPromptsKey(sessionId) {
+    return `${PENDING_PROMPTS_PREFIX}${sessionId}`;
+}
+/**
+ * Generate a unique prompt ID
+ */
+function generatePromptId() {
+    return `prm_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * Store a pending prompt for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @param issueId - The Linear issue ID
+ * @param prompt - The prompt text from the user
+ * @param user - Optional user info
+ * @returns The created prompt or null if storage failed
+ */
+export async function storePendingPrompt(sessionId, issueId, prompt, user) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot store pending prompt');
+        return null;
+    }
+    try {
+        const pendingPrompt = {
+            id: generatePromptId(),
+            sessionId,
+            issueId,
+            prompt,
+            userId: user?.id,
+            userName: user?.name,
+            createdAt: Date.now(),
+        };
+        const key = buildPromptsKey(sessionId);
+        const serialized = JSON.stringify(pendingPrompt);
+        await redisRPush(key, serialized);
+        log.info('Pending prompt stored', {
+            promptId: pendingPrompt.id,
+            sessionId,
+            issueId,
+            promptLength: prompt.length,
+        });
+        return pendingPrompt;
+    }
+    catch (error) {
+        log.error('Failed to store pending prompt', { error, sessionId, issueId });
+        return null;
+    }
+}
+/**
+ * Get all pending prompts for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @returns Array of pending prompts (oldest first)
+ */
+export async function getPendingPrompts(sessionId) {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        const items = await redisLRange(key, 0, -1);
+        return items.map((item) => JSON.parse(item));
+    }
+    catch (error) {
+        log.error('Failed to get pending prompts', { error, sessionId });
+        return [];
+    }
+}
+/**
+ * Get the count of pending prompts for a session
+ */
+export async function getPendingPromptCount(sessionId) {
+    if (!isRedisConfigured()) {
+        return 0;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        return await redisLLen(key);
+    }
+    catch (error) {
+        log.error('Failed to get pending prompt count', { error, sessionId });
+        return 0;
+    }
+}
+/**
+ * Claim and remove a pending prompt by ID
+ * Returns the prompt if found and removed, null otherwise
+ *
+ * @param sessionId - The Linear session ID
+ * @param promptId - The prompt ID to claim
+ * @returns The claimed prompt or null
+ */
+export async function claimPendingPrompt(sessionId, promptId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        const items = await redisLRange(key, 0, -1);
+        for (const item of items) {
+            const prompt = JSON.parse(item);
+            if (prompt.id === promptId) {
+                // Remove this specific item from the list
+                await redisLRem(key, 1, item);
+                log.info('Pending prompt claimed', { promptId, sessionId });
+                return prompt;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        log.error('Failed to claim pending prompt', { error, sessionId, promptId });
+        return null;
+    }
+}
+/**
+ * Pop the oldest pending prompt for a session (claim and remove atomically)
+ *
+ * @param sessionId - The Linear session ID
+ * @returns The oldest pending prompt or null if none
+ */
+export async function popPendingPrompt(sessionId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const prompts = await getPendingPrompts(sessionId);
+        if (prompts.length === 0) {
+            return null;
+        }
+        const oldest = prompts[0];
+        const claimed = await claimPendingPrompt(sessionId, oldest.id);
+        return claimed;
+    }
+    catch (error) {
+        log.error('Failed to pop pending prompt', { error, sessionId });
+        return null;
+    }
+}
+/**
+ * Clear all pending prompts for a session
+ * Called when session completes or is stopped
+ *
+ * @param sessionId - The Linear session ID
+ * @returns true if cleared successfully
+ */
+export async function clearPendingPrompts(sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        await redisDel(key);
+        log.info('Pending prompts cleared', { sessionId });
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to clear pending prompts', { error, sessionId });
+        return false;
+    }
+}

package/dist/src/processing-state-storage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Redis-backed Processing State Storage
+ *
+ * Implements the `ProcessingStateStorage` interface from `@renseiai/agentfactory`
+ * using Redis for persistence. Used by the top-of-funnel governor to track
+ * which processing phases (research, backlog-creation) have been completed
+ * for each issue.
+ *
+ * Key format: `governor:processing:{issueId}:{phase}`
+ * TTL: 30 days (matches workflow state TTL)
+ */
+import type { ProcessingStateStorage, ProcessingPhase, ProcessingRecord } from '@renseiai/agentfactory';
+/**
+ * Redis-backed implementation of `ProcessingStateStorage`.
+ *
+ * Each phase completion is stored as an independent key so that phases
+ * can be checked and cleared independently without affecting each other.
+ */
+export declare class RedisProcessingStateStorage implements ProcessingStateStorage {
+    /**
+     * Check whether a given phase has already been completed for an issue.
+     */
+    isPhaseCompleted(issueId: string, phase: ProcessingPhase): Promise<boolean>;
+    /**
+     * Mark a phase as completed for an issue.
+     * Stores a `ProcessingRecord` JSON object with a 30-day TTL.
+     */
+    markPhaseCompleted(issueId: string, phase: ProcessingPhase, sessionId?: string): Promise<void>;
+    /**
+     * Clear a phase completion record for an issue.
+     */
+    clearPhase(issueId: string, phase: ProcessingPhase): Promise<void>;
+    /**
+     * Retrieve the processing record for a phase, if it exists.
+     */
+    getPhaseRecord(issueId: string, phase: ProcessingPhase): Promise<ProcessingRecord | null>;
+}
+//# sourceMappingURL=processing-state-storage.d.ts.map

package/dist/src/processing-state-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing-state-storage.d.ts","sourceRoot":"","sources":["../../src/processing-state-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,wBAAwB,CAAA;AAgB/B;;;;;GAKG;AACH,qBAAa,2BAA4B,YAAW,sBAAsB;IACxE;;OAEG;IACG,gBAAgB,CACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,OAAO,CAAC;IAInB;;;OAGG;IACG,kBAAkB,CACtB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;IAUhB;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,IAAI,CAAC;IAIhB;;OAEG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;CAGpC"}