sealkeep 0.9.0 → 0.11.0

package/dist/src/daemon.d.ts

@@ -1,5 +1,31 @@
 import { ArchiveQueue } from "./queue.js";
+import { type ReclaimOperations } from "./retention.js";
+import { drainQueue } from "./worker.js";
+import { uploadAndOffloadPending } from "./heartbeat.js";
+import { startTranscriptWatcher } from "./watcher.js";
 import { type NotifyOptions } from "./notify.js";
+import type { BackgroundIndexBuild } from "./index-background.js";
+import { drainAutomaticAgentContextRequests } from "./agent-context.js";
+import type { ContextDrainStarter } from "./context-background.js";
+import { reconcileTeamHistoryBackfill } from "./team-backfill.js";
+import { type DaemonProcessIdentityLookup } from "./daemon-lease.js";
+import type { reconcileCloudTeamAccess } from "./team-presence.js";
+export type DaemonIndexing = {
+    contentIndexNeedsPolicyUpgrade(dataDir: string): Promise<boolean>;
+    buildContentIndex(dataDir: string, phrase: string, options: {
+        sync: boolean;
+        signal?: AbortSignal;
+        scheduling?: {
+            lanes?: number;
+            cpuTarget?: number;
+            maxRssBytes?: number;
+            backgroundTransferBytesPerSecond?: number;
+        };
+    }): Promise<{
+        indexedNow: number;
+        skipped: number;
+    }>;
+};
 export type DaemonOptions = {
     phrase: string;
     intervalMs?: number;
@@ -7,23 +33,90 @@ export type DaemonOptions = {
     watch?: boolean;
     upload?: boolean;
     reclaim?: boolean;
+    /** Native services follow the persisted machine toggle without requiring a process restart. */
+    reclaimFromSettings?: boolean;
     queue?: ArchiveQueue;
-    /** Pause archiving when the disk has less free space than this. Reclamation still runs. */
+    /** Below this free-space floor, seal through the bounded cloud-streaming path instead of building another local archive. */
     diskPressureFreeBytes?: number;
     /** Passed to the per-job check; see DrainOptions.reserveBytes. */
     reserveBytes?: number;
     /** How often to re-walk the transcript roots as a safety net. */
     rescanEveryMs?: number;
+    /** Independent bounded upload cadence. Defaults to at most 30 seconds. */
+    uploadEveryMs?: number;
+    /** Stop an upload lane that moves no local or remote bytes for this long. */
+    uploadIdleMs?: number;
     onTick?: (result: TickResult) => void;
     /** Desktop notifications. Omit to follow the environment; false to stay silent. */
     notifications?: boolean;
     notify?: NotifyOptions;
     now?: () => number;
+    /** Dependency seam for deterministic migration/concurrency rehearsals. */
+    indexing?: DaemonIndexing;
+    /** Owned historical-index child seam; production uses startBackgroundIndexBuild. */
+    startIndexBuild?: (dataDir: string, phrase: string, options: {
+        sync: boolean;
+        idleMs?: number;
+        stopGraceMs?: number;
+        lanes?: number;
+        cpuTarget?: number;
+        onWorkerExit?: (worker: {
+            pid: number;
+            processIdentity: string;
+        }) => Promise<void>;
+        signerAuthorized?: boolean;
+    }) => BackgroundIndexBuild;
+    /** Historical-index retry backoff. Production defaults to 30s..30m; tests may shorten it. */
+    indexRetryBaseMs?: number;
+    indexRetryMaxMs?: number;
+    /** Cancel a seal that makes no source/storage progress for this long. */
+    sealIdleMs?: number;
+    /** Cancel a historical index child that reports no useful progress for this long. */
+    indexIdleMs?: number;
+    /** Upper bound for joining cancelled owned work during shutdown. */
+    closeGraceMs?: number;
+    /** Dependency seam for exercising upload ordering without real credentials. */
+    uploadPending?: typeof uploadAndOffloadPending;
+    /** Dependency seam for deterministic unattended-reclaim boundary tests. */
+    retentionOperations?: ReclaimOperations;
+    /** Dependency seam for holding a seal open while testing independent lanes. */
+    drain?: typeof drainQueue;
+    /** Dependency seam for proving a slow startup discovery cannot hold an existing queue. */
+    startWatcher?: typeof startTranscriptWatcher;
+    /** Independent cadence for durable hook-context requests. */
+    contextEveryMs?: number;
+    /** One recall attempt is terminated after this long without useful CPU/byte progress. */
+    contextAttemptTimeoutMs?: number;
+    /** Absolute ceiling even for a continuously progressing malformed index. */
+    contextAbsoluteTimeoutMs?: number;
+    /** Timed-out work is deferred so one bad request cannot starve newer slots. */
+    contextRetryMs?: number;
+    /** Legacy dependency seam for cheap coalescing/single-flight tests. */
+    contextRequests?: typeof drainAutomaticAgentContextRequests;
+    /** Owned-process seam for deterministic timeout/cancellation tests. */
+    startContextDrain?: ContextDrainStarter;
+    /** Independent durable old-history sharing lane (dependency seam for tests). */
+    teamBackfill?: typeof reconcileTeamHistoryBackfill;
+    /** How quickly a new folder/member binding starts sharing prior history. */
+    teamBackfillEveryMs?: number;
+    /** Stop a team-history job that makes no file or network progress. */
+    teamBackfillIdleMs?: number;
+    /** Bounded serial microbatch; does not increase upload concurrency. */
+    teamBackfillBatchSize?: number;
+    /** Yield between jobs once this wall-time budget is reached. */
+    teamBackfillBatchMs?: number;
+    /** Independent access lane dependency/cadence seams. */
+    teamAccess?: typeof reconcileCloudTeamAccess;
+    teamAccessEveryMs?: number;
+    /** Process-generation seam for worker-election tests. Production probes the kernel. */
+    processIdentityLookup?: DaemonProcessIdentityLookup;
 };
 export type TickResult = {
     at: string;
     paused: boolean;
     archived: number;
+    /** Archives made searchable this tick. */
+    indexed: number;
     failed: number;
     uploaded: number;
     uploadErrors: number;