om-memory-system 3.5.0-next.34 → 3.5.0

package/dist/importer/model-selection.js

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { CONFIG } from "../config.js";
 import { buildBoundedSummaryPrompt } from "../core/capture-context.js";
-import { buildCaptureSystemPrompt, captureSummaryToolSchema, parseCaptureSummary, } from "../core/extraction.js";
+import { httpStatusError } from "../core/capture-retry-policy.js";
+import { buildCaptureSystemPrompt, captureSummaryToolSchema, normalizeStopReason, parseCaptureSummary, } from "../core/extraction.js";
 import { AIProviderFactory } from "../services/ai/ai-provider-factory.js";
+import { toolCallFailureReason } from "../services/ai/providers/base-provider.js";
 import { buildMemoryProviderConfig } from "../services/ai/provider-config.js";
 import { resolveSecretValue } from "../services/secret-resolver.js";
 /** Merge import-only model settings without changing the saved omms config. */
@@ -51,7 +53,15 @@ export function selectImportModel(flags) {
             };
             const result = await provider.executeToolCall(system, buildBoundedSummaryPrompt(request.context, system, tool), tool, `history-capture-${randomUUID()}`);
             if (!result.success || !result.data) {
-                throw new Error("History capture model call failed");
+                if (request.diagnostics) {
+                    // Only an HTTP error or a request with no reply is worth a later retry.
+                    request.diagnostics.failureReason = toolCallFailureReason(result, normalizeStopReason(result.stopReason) === "length");
+                    request.diagnostics.httpStatus = result.httpStatus;
+                    request.diagnostics.retryAfterMs = result.retryAfterMs;
+                }
+                if (result.httpStatus === undefined)
+                    throw new Error("History capture model call failed");
+                throw httpStatusError("History capture model call failed", result.httpStatus, result.retryAfterMs);
             }
             const raw = typeof result.data === "string" ? result.data : JSON.stringify(result.data);
             const parsed = parseCaptureSummary(raw);

package/dist/index.js

@@ -215,7 +215,10 @@ export const OmmsPlugin = async (ctx) => {
     // Web imports, Health, and Settings served by this process can list and use OpenCode's models.
     // Awaited so the web server never serves those routes before the registry is filled.
     await import("./adapters/opencode/backfill-startup.js")
-        .then(({ registerOpencodeImportModels }) => registerOpencodeImportModels())
+        .then(({ registerOpencodeImportModels, registerOpencodeCaptureRetryDrain }) => {
+        registerOpencodeImportModels();
+        registerOpencodeCaptureRetryDrain(autoCaptureHost, directory);
+    })
         .catch(() => { });
     (async () => {
         let connected = [];
@@ -590,6 +593,17 @@ export const OmmsPlugin = async (ctx) => {
         },
         event: async (input) => {
             const event = input.event;
+            if (event.type === "session.created") {
+                if (!isConfigured() || !CONFIG.autoCaptureEnabled)
+                    return;
+                const sessionID = event.properties?.info?.id ?? event.properties?.sessionID;
+                // OMMS's own structured-output sessions must not start a retry pass.
+                if (sessionID && (await isInternalCaptureSession(ctx.client, sessionID)))
+                    return;
+                const { startCaptureRetryDrain } = await import("./services/capture-retry-drain.js");
+                startCaptureRetryDrain("opencode");
+                return;
+            }
             if (event.type === "session.idle") {
                 if (!isConfigured() || !CONFIG.autoCaptureEnabled)
                     return;

package/dist/services/ai/providers/anthropic-messages.js

@@ -1,8 +1,9 @@
-import { applySafeExtraParams, BaseAIProvider, describeValidationError, } from "./base-provider.js";
+import { applySafeExtraParams, BaseAIProvider, describeValidationError, isTransportError, } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { ToolSchemaConverter } from "../tools/tool-schema.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
+import { parseRetryAfter } from "../../../core/capture-retry-policy.js";
 /**
  * Base implementation for providers that speak the Anthropic Messages API
  * (Anthropic itself plus Anthropic-compatible gateways such as MiniMax).
@@ -124,6 +125,8 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                         stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
+                        httpStatus: response.status,
+                        retryAfterMs: parseRetryAfter(response.headers?.get?.("retry-after")),
                         iterations,
                     };
                 }
@@ -195,6 +198,7 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                     return {
                         stopReason,
                         success: false,
+                        transportError: true,
                         error: `${this.timeoutLabel()} (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
@@ -203,6 +207,7 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                     stopReason,
                     success: false,
                     error: String(error),
+                    transportError: isTransportError(error),
                     iterations,
                 };
             }

package/dist/services/ai/providers/base-provider.d.ts

@@ -5,6 +5,12 @@ export interface ToolCallResult {
     iterations?: number;
     /** The provider's last reported stop reason, e.g. a length limit. */
     stopReason?: string;
+    /** The HTTP status of a failed reply, so capture can tell whether a retry may help. */
+    httpStatus?: number;
+    /** The wait a failed reply asked for in its `Retry-After` header. */
+    retryAfterMs?: number;
+    /** True when the request got no reply at all: a timeout or a network failure. */
+    transportError?: boolean;
 }
 export interface ProviderConfig {
     model: string;
@@ -16,6 +22,17 @@ export interface ProviderConfig {
     memoryTemperature?: number | false;
     extraParams?: Record<string, unknown>;
 }
+/**
+ * True for a request that never got a reply: an abort by timeout, or the
+ * `TypeError` that `fetch` throws for a network failure.
+ */
+export declare function isTransportError(error: unknown): boolean;
+/**
+ * The capture reason code for a failed tool call. Only an HTTP error or a
+ * request with no reply is a call error; any other failure means the model
+ * answered with something unusable, which a retry does not fix.
+ */
+export declare function toolCallFailureReason(result: ToolCallResult, lengthStop: boolean): "truncated" | "call-error" | "schema-mismatch";
 /**
  * A validation error message that is safe to log and return. A JSON
  * `SyntaxError` message quotes the start of the model's reply, which can carry

package/dist/services/ai/providers/base-provider.js

@@ -1,3 +1,22 @@
+/**
+ * True for a request that never got a reply: an abort by timeout, or the
+ * `TypeError` that `fetch` throws for a network failure.
+ */
+export function isTransportError(error) {
+    return error instanceof Error && (error.name === "AbortError" || error instanceof TypeError);
+}
+/**
+ * The capture reason code for a failed tool call. Only an HTTP error or a
+ * request with no reply is a call error; any other failure means the model
+ * answered with something unusable, which a retry does not fix.
+ */
+export function toolCallFailureReason(result, lengthStop) {
+    if (lengthStop)
+        return "truncated";
+    if (result.httpStatus !== undefined || result.transportError)
+        return "call-error";
+    return "schema-mismatch";
+}
 /**
  * A validation error message that is safe to log and return. A JSON
  * `SyntaxError` message quotes the start of the model's reply, which can carry

package/dist/services/ai/providers/google-gemini.js

@@ -1,7 +1,8 @@
-import { BaseAIProvider, describeValidationError } from "./base-provider.js";
+import { BaseAIProvider, describeValidationError, isTransportError, } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
+import { parseRetryAfter } from "../../../core/capture-retry-policy.js";
 /**
  * Google Gemini Provider
  * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
@@ -157,6 +158,8 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                         stopReason,
                         success: false,
                         error: `Gemini API error: ${response.status} - ${errorText}`,
+                        httpStatus: response.status,
+                        retryAfterMs: parseRetryAfter(response.headers?.get?.("retry-after")),
                         iterations,
                     };
                 }
@@ -229,7 +232,13 @@ export class GoogleGeminiProvider extends BaseAIProvider {
             }
             catch (error) {
                 clearTimeout(timeout);
-                return { stopReason, success: false, error: String(error), iterations };
+                return {
+                    stopReason,
+                    success: false,
+                    error: String(error),
+                    transportError: isTransportError(error),
+                    iterations,
+                };
             }
         }
         return {

package/dist/services/ai/providers/openai-chat-completion.js

@@ -1,6 +1,7 @@
-import { BaseAIProvider, applySafeExtraParams, describeValidationError, } from "./base-provider.js";
+import { BaseAIProvider, applySafeExtraParams, describeValidationError, isTransportError, } from "./base-provider.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
+import { parseRetryAfter } from "../../../core/capture-retry-policy.js";
 function isErrorResponseBody(data) {
     return (typeof data === "object" &&
         data !== null &&
@@ -223,6 +224,8 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                         stopReason,
                         success: false,
                         error: errorMessage,
+                        httpStatus: response.status,
+                        retryAfterMs: parseRetryAfter(response.headers?.get?.("retry-after")),
                         iterations,
                     };
                 }
@@ -378,6 +381,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                     return {
                         stopReason,
                         success: false,
+                        transportError: true,
                         error: `API request timeout (${iterationTimeout}ms)`,
                         iterations,
                     };
@@ -386,6 +390,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                     stopReason,
                     success: false,
                     error: String(error),
+                    transportError: isTransportError(error),
                     iterations,
                 };
             }

package/dist/services/ai/providers/openai-responses.js

@@ -1,7 +1,8 @@
-import { BaseAIProvider, applySafeExtraParams } from "./base-provider.js";
+import { BaseAIProvider, applySafeExtraParams, isTransportError, } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { ToolSchemaConverter } from "../tools/tool-schema.js";
 import { log } from "../../logger.js";
+import { parseRetryAfter } from "../../../core/capture-retry-policy.js";
 export class OpenAIResponsesProvider extends BaseAIProvider {
     aiSessionManager;
     constructor(config, aiSessionManager) {
@@ -72,6 +73,8 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                         stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
+                        httpStatus: response.status,
+                        retryAfterMs: parseRetryAfter(response.headers?.get?.("retry-after")),
                         iterations,
                     };
                 }
@@ -110,6 +113,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                     return {
                         stopReason,
                         success: false,
+                        transportError: true,
                         error: `API request timeout (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
@@ -118,6 +122,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                     stopReason,
                     success: false,
                     error: String(error),
+                    transportError: isTransportError(error),
                     iterations,
                 };
             }

package/dist/services/auto-capture.d.ts

@@ -1,3 +1,9 @@
+import { type CaptureResult, type CaptureWorkUnit } from "../core/capture.js";
 import type { AutoCaptureHost } from "../core/host.js";
+import { type CaptureRetryDrainResult } from "./capture-retry-drain.js";
 export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";
 export declare function performAutoCapture(host: AutoCaptureHost, sessionID: string, directory: string): Promise<void>;
+/** A retried OpenCode turn updates its prompt row the same way a live capture does. */
+export declare function settleOpencodeRetriedPrompt(unit: CaptureWorkUnit, result: CaptureResult): Promise<void>;
+/** Retry OpenCode's queued turns with its current capture model choice. */
+export declare function drainOpencodeCaptureRetries(host: AutoCaptureHost, directory: string): Promise<CaptureRetryDrainResult>;

package/dist/services/auto-capture.js

@@ -1,9 +1,10 @@
-import { CONFIG } from "../config.js";
+import { CONFIG, refreshConfigIfChanged } from "../config.js";
 import { captureConversation } from "../core/capture.js";
+import { quickRetryDelayMs } from "../core/capture-retry-policy.js";
+import { drainCaptureRetries, queueFailedCapture, startCaptureRetryDrain, } from "./capture-retry-drain.js";
 import { log } from "./logger.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
 export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";
-const RETRY_BASE_DELAY_MS = 2000;
 let isCaptureRunning = false;
 async function notifySafely(host, notification) {
     try {
@@ -33,6 +34,7 @@ export async function performAutoCapture(host, sessionID, directory) {
 async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
     let claimedPromptId = null;
     let attempt = prompt.capture_attempts || 0;
+    let workUnit = null;
     try {
         if (!(await userPromptManager.claimPrompt(prompt.id)))
             return;
@@ -45,7 +47,7 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
                     return;
                 if (conversation.textResponses.length === 0 && conversation.toolCalls.length === 0)
                     return;
-                const captureResult = await captureConversation({
+                workUnit = {
                     host: host.host,
                     hostSessionId: sessionID,
                     sourceType: "live-capture",
@@ -58,7 +60,8 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
                         modelId: prompt.modelId,
                     },
                     ...conversation,
-                }, host);
+                };
+                const captureResult = await captureConversation(workUnit, host);
                 if (captureResult.status === "skipped") {
                     log("Auto-capture skipped", {
                         promptId: prompt.id,
@@ -78,6 +81,8 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
                     memoryId: captureResult.memoryId,
                     host: host.host,
                 });
+                // The capture model answers again, so earlier failed turns may go through now.
+                startCaptureRetryDrain("opencode");
                 if (CONFIG.showAutoCaptureToasts) {
                     await notifySafely(host, {
                         title: "Memory Captured",
@@ -93,7 +98,7 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
                 await userPromptManager.recordFailedAttempt(prompt.id);
                 if (attempt < maxRetries) {
                     log(`Auto-capture warning (attempt ${attempt}/${maxRetries})`, { error: errMsg });
-                    await new Promise((resolve) => setTimeout(resolve, RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1)));
+                    await new Promise((resolve) => setTimeout(resolve, quickRetryDelayMs(attempt)));
                 }
                 else {
                     throw error;
@@ -104,6 +109,9 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
     catch (error) {
         const errMsg = error instanceof Error ? error.message : String(error);
         log(`Auto-capture final error after ${attempt} attempts`, { error: errMsg });
+        // Only after the quick retries fail; the queue decides whether a retry can help.
+        if (workUnit)
+            await queueFailedCapture(workUnit, error, CONFIG);
         if (CONFIG.showErrorToasts) {
             const shortReason = errMsg.length > 100 ? errMsg.substring(0, 100) + "..." : errMsg;
             await notifySafely(host, {
@@ -125,3 +133,26 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
         }
     }
 }
+/** A retried OpenCode turn updates its prompt row the same way a live capture does. */
+export async function settleOpencodeRetriedPrompt(unit, result) {
+    if (!unit.promptId)
+        return;
+    if (result.status === "skipped") {
+        await userPromptManager.deletePrompt(unit.promptId);
+        return;
+    }
+    await userPromptManager.linkMemoryToPrompt(unit.promptId, result.memoryId);
+    await userPromptManager.markAsCaptured(unit.promptId);
+}
+/** Retry OpenCode's queued turns with its current capture model choice. */
+export function drainOpencodeCaptureRetries(host, directory) {
+    // A retention change in the config file applies from this pass on.
+    refreshConfigIfChanged(directory);
+    return drainCaptureRetries({
+        host: "opencode",
+        provider: host,
+        config: CONFIG,
+        isReady: () => host.isCaptureReady(),
+        onSettled: settleOpencodeRetriedPrompt,
+    });
+}

package/dist/services/capture-retry-drain.d.ts

@@ -0,0 +1,48 @@
+import { type CaptureResult, type CaptureWorkUnit } from "../core/capture.js";
+import { type CaptureFailureInfo } from "../core/capture-retry-policy.js";
+import type { CaptureSummaryProvider } from "../core/host.js";
+import type { MemoryHost } from "../types/index.js";
+import { type CaptureRetryConfig } from "./capture-retry-queue.js";
+export interface CaptureRetryDrainOptions {
+    host: MemoryHost;
+    provider: CaptureSummaryProvider;
+    config: CaptureRetryConfig;
+    now?: () => number;
+    /** False skips the pass, e.g. while the embedding model is not ready. */
+    isReady?: () => boolean;
+    /** Runs after a retry saves or skips, so a host can update its own records. */
+    onSettled?: (unit: CaptureWorkUnit, result: CaptureResult) => Promise<void>;
+}
+export interface CaptureRetryDrainResult {
+    status: "done" | "running" | "off" | "not-ready" | "error";
+    captured: number;
+    skipped: number;
+    dropped: number;
+    /** True when the pass stopped at a failure a retry can fix. */
+    stopped: boolean;
+}
+/** What a thrown capture error says about the failure. */
+export declare function captureFailureOf(error: unknown): CaptureFailureInfo;
+/**
+ * Queue a turn whose live capture failed, when a retry can fix the failure.
+ * Never throws: a queue error must not change the live capture outcome.
+ */
+export declare function queueFailedCapture(unit: CaptureWorkUnit, error: unknown, config: CaptureRetryConfig): Promise<boolean>;
+/**
+ * Retry this host's due turns, oldest first, one at a time. Deletes a turn
+ * when its retry saves, skips or fails for good, and stops at the first
+ * failure a retry can fix. One pass runs per host in each process.
+ */
+export declare function drainCaptureRetries(options: CaptureRetryDrainOptions): Promise<CaptureRetryDrainResult>;
+type HostDrain = () => Promise<CaptureRetryDrainResult>;
+/** A host registers its drain in its own process, so shared code never imports an adapter. */
+export declare function registerCaptureRetryDrain(host: MemoryHost, drain: HostDrain | null): void;
+/** Start the host's registered drain in the background, if this process has one. */
+export declare function startCaptureRetryDrain(host: MemoryHost): void;
+export type RetryNowResult = "started" | "scheduled" | "running";
+/**
+ * Make every queued turn of one host due now. Starts a pass when this process
+ * runs that host; otherwise the turns retry at the host's next session start.
+ */
+export declare function requestCaptureRetryNow(host: MemoryHost, config: CaptureRetryConfig): Promise<RetryNowResult>;
+export {};

package/dist/services/capture-retry-drain.js

@@ -0,0 +1,142 @@
+import { CaptureAttemptError, captureConversation, } from "../core/capture.js";
+import { classifyCaptureFailure, errorHttpStatus, errorRetryAfterMs, } from "../core/capture-retry-policy.js";
+import { claimCaptureRetry, deleteCaptureRetry, enqueueCaptureRetry, isCaptureRetryEnabled, listDueCaptureRetries, makeCaptureRetriesDue, pruneCaptureRetries, rescheduleCaptureRetry, } from "./capture-retry-queue.js";
+import { log } from "./logger.js";
+function errorCode(error) {
+    if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+        return error.code;
+    }
+    return error instanceof Error ? error.name : "unknown";
+}
+/** What a thrown capture error says about the failure. */
+export function captureFailureOf(error) {
+    if (error instanceof CaptureAttemptError)
+        return error.failure;
+    return {
+        reason: "call-error",
+        httpStatus: errorHttpStatus(error),
+        retryAfterMs: errorRetryAfterMs(error),
+    };
+}
+/**
+ * Queue a turn whose live capture failed, when a retry can fix the failure.
+ * Never throws: a queue error must not change the live capture outcome.
+ */
+export async function queueFailedCapture(unit, error, config) {
+    try {
+        const failure = captureFailureOf(error);
+        if (classifyCaptureFailure(failure) !== "retryable")
+            return false;
+        const result = await enqueueCaptureRetry(unit, failure, config);
+        if (result === "queued") {
+            log("Capture queued for retry", {
+                host: unit.host,
+                sessionID: unit.hostSessionId,
+                reason: failure.reason,
+                httpStatus: failure.httpStatus ?? null,
+            });
+        }
+        return result === "queued";
+    }
+    catch (queueError) {
+        log("Capture retry queue write failed", { code: errorCode(queueError) });
+        return false;
+    }
+}
+const running = new Set();
+/**
+ * Retry this host's due turns, oldest first, one at a time. Deletes a turn
+ * when its retry saves, skips or fails for good, and stops at the first
+ * failure a retry can fix. One pass runs per host in each process.
+ */
+export async function drainCaptureRetries(options) {
+    const result = {
+        status: "done",
+        captured: 0,
+        skipped: 0,
+        dropped: 0,
+        stopped: false,
+    };
+    const { host, config } = options;
+    const now = options.now ?? Date.now;
+    if (running.has(host))
+        return { ...result, status: "running" };
+    running.add(host);
+    try {
+        // Expired rows go first, so they are never retried. At 0 every row goes.
+        await pruneCaptureRetries(config, now());
+        if (!isCaptureRetryEnabled(config))
+            return { ...result, status: "off" };
+        if (options.isReady && !options.isReady())
+            return { ...result, status: "not-ready" };
+        for (const row of await listDueCaptureRetries(host, config, now())) {
+            if (!(await claimCaptureRetry(row.id, config, now())))
+                continue;
+            let outcome;
+            try {
+                outcome = await captureConversation(row.workUnit, options.provider);
+            }
+            catch (error) {
+                const failure = captureFailureOf(error);
+                if (classifyCaptureFailure(failure) === "retryable") {
+                    await rescheduleCaptureRetry(row, failure, config, now());
+                    result.stopped = true;
+                    break;
+                }
+                await deleteCaptureRetry(row.id, config);
+                result.dropped++;
+                continue;
+            }
+            await deleteCaptureRetry(row.id, config);
+            if (outcome.status === "captured")
+                result.captured++;
+            else
+                result.skipped++;
+            try {
+                await options.onSettled?.(row.workUnit, outcome);
+            }
+            catch (error) {
+                log("Capture retry follow-up failed", { host, code: errorCode(error) });
+            }
+        }
+        if (result.captured + result.skipped + result.dropped > 0 || result.stopped) {
+            log("Capture retry pass finished", { host, ...result });
+        }
+        return result;
+    }
+    catch (error) {
+        log("Capture retry pass failed", { host, code: errorCode(error) });
+        return { ...result, status: "error" };
+    }
+    finally {
+        running.delete(host);
+    }
+}
+const registeredDrains = new Map();
+/** A host registers its drain in its own process, so shared code never imports an adapter. */
+export function registerCaptureRetryDrain(host, drain) {
+    if (drain)
+        registeredDrains.set(host, drain);
+    else
+        registeredDrains.delete(host);
+}
+/** Start the host's registered drain in the background, if this process has one. */
+export function startCaptureRetryDrain(host) {
+    const drain = registeredDrains.get(host);
+    if (!drain)
+        return;
+    void drain().catch((error) => log("Capture retry pass failed", { host, code: errorCode(error) }));
+}
+/**
+ * Make every queued turn of one host due now. Starts a pass when this process
+ * runs that host; otherwise the turns retry at the host's next session start.
+ */
+export async function requestCaptureRetryNow(host, config) {
+    await makeCaptureRetriesDue(host, config);
+    if (running.has(host))
+        return "running";
+    if (!registeredDrains.has(host))
+        return "scheduled";
+    startCaptureRetryDrain(host);
+    return "started";
+}

package/dist/services/capture-retry-queue.d.ts

@@ -0,0 +1,57 @@
+import type { CaptureWorkUnit } from "../core/capture.js";
+import { type CaptureFailureInfo } from "../core/capture-retry-policy.js";
+import type { MemoryHost } from "../types/index.js";
+import { type CaptureDiagnosticsConfig } from "./capture-diagnostics.js";
+/**
+ * The config fields this module reads. Callers pass `CONFIG`, so tests that
+ * stub `../config.js` do not need the new key.
+ */
+export interface CaptureRetryConfig extends CaptureDiagnosticsConfig {
+    storagePath: string;
+    captureRetryRetentionHours?: number;
+}
+export interface QueuedCaptureRetry {
+    id: number;
+    host: MemoryHost;
+    sessionId: string;
+    turnId: string;
+    workUnit: CaptureWorkUnit;
+    createdAt: number;
+    attempts: number;
+}
+export type EnqueueResult = "queued" | "off" | "private" | "too-large" | "no-turn-id";
+export declare const DEFAULT_CAPTURE_RETRY_RETENTION_HOURS = 72;
+export declare const MAX_QUEUED_TURN_BYTES: number;
+export declare const MAX_QUEUE_BYTES: number;
+/** Whole hours from 0 to 720; a stub config without the key gets the default. */
+export declare function captureRetryRetentionHours(config: CaptureRetryConfig): number;
+export declare function isCaptureRetryEnabled(config: CaptureRetryConfig): boolean;
+/**
+ * Remove `<private>` text and redact secrets with the trace rules. Returns
+ * null for a turn with no text left, which must not be queued.
+ */
+export declare function cleanCaptureWorkUnit(unit: CaptureWorkUnit, config: CaptureRetryConfig): CaptureWorkUnit | null;
+/**
+ * Save a cleaned copy of a turn whose live capture failed with a retryable
+ * error. Queueing the same turn again updates its row.
+ */
+export declare function enqueueCaptureRetry(unit: CaptureWorkUnit, failure: CaptureFailureInfo, config: CaptureRetryConfig, now?: number): Promise<EnqueueResult>;
+/** This host's rows that are due, oldest first. */
+export declare function listDueCaptureRetries(host: MemoryHost, config: CaptureRetryConfig, now?: number): Promise<QueuedCaptureRetry[]>;
+/**
+ * Claim a row for one retry. Only one process can hold a live claim; a
+ * crashed process releases it when the lease runs out.
+ */
+export declare function claimCaptureRetry(id: number, config: CaptureRetryConfig, now?: number): Promise<boolean>;
+/** Record one more failed try, set the next try time and release the claim. */
+export declare function rescheduleCaptureRetry(row: Pick<QueuedCaptureRetry, "id" | "attempts">, failure: CaptureFailureInfo, config: CaptureRetryConfig, now?: number): Promise<void>;
+export declare function deleteCaptureRetry(id: number, config: CaptureRetryConfig): Promise<void>;
+/** Queued turns per host. */
+export declare function countCaptureRetries(config: CaptureRetryConfig): Promise<Record<MemoryHost, number>>;
+/** Make every row of one host due now. Returns the number of rows. */
+export declare function makeCaptureRetriesDue(host: MemoryHost, config: CaptureRetryConfig, now?: number): Promise<number>;
+/**
+ * Delete rows older than the retention. With retention 0 the queue is off,
+ * so every row goes.
+ */
+export declare function pruneCaptureRetries(config: CaptureRetryConfig, now?: number): Promise<number>;