@remnic/core 9.69.56 → 9.69.57

package/dist/maintenance-CLBIvVxg.d.ts

@@ -1,749 +0,0 @@
-import { a9 as ActivitySnapshot, aW as ActivityTimelineAnalysisConfig, P as PluginConfig, aX as ActivityConfig, aY as ActivitySourceConfig, aZ as ActivitySourceClient } from './types-Du6VdoAg.js';
-import { SearchBackend } from './search/port.js';
-import { S as StorageManager } from './storage-CMm-3aD3.js';
-import { a as NamespaceCatalog } from './catalog-BuMyYPUn.js';
-import { NamespaceSearchRouter } from './namespaces/search.js';
-import { BetterSqlite3Database } from './runtime/better-sqlite.js';
-
-/**
- * Screen-activity SQLite store (issue #1899).
- *
- * Durable, capture-machine-agnostic store for on-screen text snapshots plus a
- * per-machine sync cursor. Mirrors the LCM store conventions
- * (packages/remnic-core/src/lcm/schema.ts): WAL, a `<name>_meta` schema-version
- * row, `CREATE TABLE IF NOT EXISTS`, and an FTS5 virtual table created
- * separately. better-sqlite3 is synchronous.
- *
- * Snapshots dedup on `(machine, content_hash)` so a re-sync is idempotent, and
- * day queries use half-open [start, end) UTC bounds (AGENTS.md §23).
- */
-
-declare function activityDatabasePath(memoryDir: string): string;
-declare function ensureActivityStateDir(memoryDir: string): Promise<void>;
-declare function openActivityDatabase(memoryDir: string): BetterSqlite3Database;
-/** Apply the activity schema on an already-open handle (test/in-memory use). */
-declare function applyActivitySchema(db: BetterSqlite3Database): void;
-declare class ActivityStore {
-    private readonly db;
-    constructor(db: BetterSqlite3Database);
-    static open(memoryDir: string): ActivityStore;
-    /**
-     * Insert a snapshot, idempotent on (machine, captured_at_utc, content_hash):
-     * the same screen content recurring at a *different* time is kept; only an
-     * exact re-ingestion of the same capture dedups. Returns `inserted: false`
-     * for a duplicate. The FTS row is written only on a real insert (atomically),
-     * so it never drifts from the base table.
-     */
-    insertSnapshot(snapshot: ActivitySnapshot): {
-        inserted: boolean;
-        id: number;
-    };
-    /** Snapshots whose capture instant is in the half-open [start, end) window. */
-    listSnapshotsForDay(machine: string | null, startUtcInclusive: string, endUtcExclusive: string): ActivitySnapshot[];
-    getCursor(machine: string): string | null;
-    setCursor(machine: string, cursor: string | null, updatedAtUtc?: string): void;
-    /** Full-text search over snapshot text/app/window/url; newest first. */
-    searchSnapshots(query: string, limit: number): ActivitySnapshot[];
-    /** Retention: drop snapshots captured strictly before `cutoffUtc`. */
-    pruneOlderThan(cutoffUtc: string): number;
-    /**
-     * First and last stored capture instants (canonical UTC strings), or null
-     * when no snapshots exist. Backs the unbounded timeline search window.
-     */
-    snapshotCaptureExtent(): {
-        firstUtc: string;
-        lastUtc: string;
-    } | null;
-    close(): void;
-}
-
-/**
- * Typed failure classification for timeline analysis (issue #2050).
- *
- * Unknown kinds fail closed with a TypeError. Pure: no I/O, no clock, no randomness.
- */
-declare const ANALYSIS_FAILURE_KINDS: readonly ["provider_unavailable", "timeout", "aborted", "rate_limited", "malformed_json", "invalid_schema", "partial_output", "invalid_config"];
-type AnalysisFailureKind = (typeof ANALYSIS_FAILURE_KINDS)[number];
-interface AnalysisFailure {
-    kind: AnalysisFailureKind;
-    /** True only when retrying the same request could plausibly succeed. */
-    retryable: boolean;
-    /** True when the deterministic cards must be preserved unchanged. */
-    preservesDeterministic: true;
-}
-/** True when the value is one of the known failure kinds. */
-declare function isAnalysisFailureKind(value: unknown): value is AnalysisFailureKind;
-/** Classify a failure kind. Unknown kinds throw; there is no permissive default. */
-declare function classifyAnalysisFailure(kind: string): AnalysisFailure;
-
-/**
- * Timeline-card layer over the #1899 activity store (issue #2049).
- *
- * A card is a deterministic, replayable *derived view*: it references snapshot
- * evidence by store row id and content identity, never copying or re-storing
- * it. All intervals are half-open [start, end) UTC; day bucketing reuses the
- * DST-aware `activityDayWindow` from the digest layer, so timeline days and
- * digests always agree on day bounds.
- */
-/** Reference to one stored observation (subset of ActivitySnapshot; no text). */
-interface TimelineObservation {
-    /** Store row id of the referenced snapshot. */
-    id: number;
-    machine: string;
-    /** UTC ISO-8601 capture instant. */
-    capturedAtUtc: string;
-    app: string;
-    windowTitle: string;
-    /** Browser tab URL, when the frontmost window is a known browser. */
-    browserUrl?: string;
-    /** Content hash of the referenced snapshot (identity, not re-stored text). */
-    contentHash: string;
-}
-/** User-declared pause, half-open [startUtc, endUtc) in UTC. Not idle. */
-interface TimelinePause {
-    startUtc: string;
-    endUtc: string;
-    /** Free-form reason, kept verbatim on the derived pause card. */
-    reason?: string;
-}
-/** One category definition in the registry. */
-interface TimelineCategory {
-    /** Stable ID (`system.*` is the reserved namespace). */
-    id: string;
-    name: string;
-    /** Hex color, `#RRGGBB`. */
-    color: string;
-    description: string;
-    /** Presentation order; equal orders tie-break by id. */
-    order: number;
-    /** Reserved system category (idle / pause / unknown). */
-    system?: boolean;
-    /** Marks the reserved idle category. */
-    idle?: boolean;
-}
-type TimelineCardKind = "activity" | "idle" | "pause";
-/** Provenance stamped on a card when a manual correction was applied. */
-interface TimelineManualEdit {
-    categoryId?: string;
-    title?: string;
-    editedAtUtc: string;
-}
-/** A persisted manual correction; keyed by stable card id, survives rebuilds. */
-interface TimelineCorrection {
-    cardId: string;
-    categoryId?: string;
-    title?: string;
-    editedAtUtc: string;
-}
-/** Stable first/last evidence identity keys bracketing a card's sources. */
-interface TimelineEvidenceRange {
-    firstKey: string;
-    lastKey: string;
-}
-interface TimelineCard {
-    /** Stable content-derived id (never array position or wall-clock). */
-    id: string;
-    kind: TimelineCardKind;
-    title: string;
-    summary: string;
-    categoryId: string;
-    /** Classification confidence; manual corrections set it to 1. */
-    confidence: number;
-    /** Half-open [startUtc, endUtc) UTC bounds. */
-    startUtc: string;
-    endUtc: string;
-    /** Local day key (YYYY-MM-DD) this card belongs to. */
-    dayKey: string;
-    timezone: string;
-    /** Track the card was built on; null for machine-less pause cards. */
-    machine: string | null;
-    /** Store row ids of the source snapshots (empty for idle/pause). */
-    evidenceIds: number[];
-    /** First/last evidence identity keys (null for idle/pause). */
-    evidenceRange: TimelineEvidenceRange | null;
-    /** Present only when a manual correction was applied. */
-    manualEdit?: TimelineManualEdit;
-}
-/** One replayable local day of cards. */
-interface TimelineDay {
-    formatVersion: number;
-    date: string;
-    timezone: string;
-    startUtc: string;
-    endUtc: string;
-    cards: TimelineCard[];
-}
-
-/**
- * Optional evidence-bound AI analysis over deterministic timeline cards
- * (issue #2050). Provider calls arrive through the injected `complete`
- * function; hosts build it from the local/remote seams in analysis-provider.js
- * and the parsed `activity.timeline.analysis` config. Failures leave the
- * cards unchanged and carry a typed failure kind. Disabled makes zero
- * provider calls.
- */
-
-declare const TIMELINE_ANALYSIS_PROMPT_VERSION = 1;
-declare const TIMELINE_ANALYSIS_BATCH_SIZE = 40;
-declare const TIMELINE_ANALYSIS_BATCH_OVERLAP = 2;
-declare const TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS = 15000;
-declare class TimelineAnalysisConfigError extends Error {
-    readonly name = "TimelineAnalysisConfigError";
-    readonly code: "invalid_config";
-    constructor(message: string);
-}
-type TimelineAnalysisStatus = "ok" | "disabled" | "provider_failed" | "invalid_output";
-interface TimelineAnalysisCompleteInput {
-    prompt: string;
-    provider: string;
-    model: string;
-    signal: AbortSignal;
-}
-type TimelineAnalysisComplete = (input: TimelineAnalysisCompleteInput) => Promise<string>;
-interface TimelineAnalysisInput {
-    enabled: boolean;
-    cards: readonly TimelineCard[];
-    observations: readonly TimelineObservation[];
-    provider?: string;
-    model?: string;
-    complete?: TimelineAnalysisComplete;
-    timeoutMs?: number;
-    date?: string;
-    timezone?: string;
-    categories?: readonly TimelineCategory[];
-    preferences?: readonly string[];
-    priorEdits?: readonly TimelineCorrection[];
-    signal?: AbortSignal;
-}
-interface TimelineAnalysisResult {
-    status: TimelineAnalysisStatus;
-    cards: TimelineCard[];
-    provider?: string;
-    model?: string;
-    promptVersion?: number;
-    /** Typed failure detail; present only when status is a failure. */
-    failure?: AnalysisFailure;
-}
-declare function buildTimelineAnalysisPrompt(input: {
-    date?: string;
-    timezone?: string;
-    cards: readonly TimelineCard[];
-    observations: readonly TimelineObservation[];
-    categories: readonly TimelineCategory[];
-    preferences?: readonly string[];
-    priorEdits?: readonly TimelineCorrection[];
-}): string;
-/** Analyze one day of cards. Failures return the input cards unchanged. */
-declare function analyzeTimelineCards(input: TimelineAnalysisInput): Promise<TimelineAnalysisResult>;
-
-/**
- * Provider-neutral completion adapter for timeline analysis (issue #2050).
- *
- * Routes the analysis prompt through the existing LLM contracts — the local
- * client (`provider: "local"`) or the gateway fallback client pinned to the
- * ONE explicitly configured remote provider/model. An invalid or missing
- * explicit provider surfaces as a typed failure; there is no chain fallback,
- * so a bad config can never silently answer from a different provider.
- *
- * Structural seams (not concrete classes) so hosts and tests inject fakes.
- * Never logs prompt or response content.
- */
-
-/** Structural slice of LocalLlmClient.chatCompletion (local seam). */
-interface TimelineAnalysisLocalLlm {
-    chatCompletion(messages: Array<{
-        role: "system" | "user";
-        content: string;
-    }>, options: {
-        temperature?: number;
-        maxTokens?: number;
-        responseFormat?: {
-            type: string;
-        };
-        signal?: AbortSignal;
-        operation?: string;
-        redactProviderErrors?: boolean;
-        model?: string;
-        failureDiag?: {
-            lastError?: unknown;
-        };
-    }): Promise<{
-        content: string;
-    } | null>;
-}
-/** Structural slice of FallbackLlmClient.chatCompletion (remote seam). */
-interface TimelineAnalysisRemoteLlm {
-    chatCompletion(messages: Array<{
-        role: "system" | "user" | "assistant";
-        content: string;
-    }>, options: {
-        temperature?: number;
-        maxTokens?: number;
-        signal?: AbortSignal;
-        modelChain?: {
-            primary?: string;
-            fallbacks?: string[];
-        };
-        includeDefaultModelFallback?: boolean;
-        redactProviderErrors?: boolean;
-        failureDiag?: {
-            lastError?: unknown;
-        };
-    }): Promise<{
-        content: string;
-    } | null>;
-}
-/** Marker base for provider errors the analysis run classifies by kind. */
-declare class TimelineAnalysisProviderError extends Error {
-    readonly kind: AnalysisFailureKind;
-    readonly name = "TimelineAnalysisProviderError";
-    constructor(kind: AnalysisFailureKind, message: string);
-}
-/** The provider id that routes to the local LLM client. */
-declare const TIMELINE_ANALYSIS_LOCAL_PROVIDER_ID = "local";
-/**
- * Map a thrown provider error onto the typed failure kinds. Name- and
- * status-based only: the message is matched, never logged, so provider error
- * text cannot become a log line.
- */
-declare function classifyAnalysisProviderError(error: unknown): AnalysisFailureKind;
-/**
- * Build the `complete` function `analyzeTimelineCards` calls, from the local
- * and remote client seams. Selection is by the explicit provider id carried
- * on each call: `"local"` uses the local client; anything else is a remote
- * provider id pinned as the single-model chain (no default-chain fallback is
- * ever appended).
- */
-declare function timelineAnalysisCompleteFromClients(input: {
-    localLlm: TimelineAnalysisLocalLlm | null;
-    remoteLlm: TimelineAnalysisRemoteLlm | null;
-}): TimelineAnalysisComplete;
-
-/**
- * Analysis run metadata (issue #2050).
- *
- * Pure builder for the provider/model/prompt-version record attached to
- * stored analysis results and telemetry.
- *
- * The no-content guarantee is enforced by SHAPE, not by length: each field
- * must match an identifier/version syntax, so prose cannot be stored as a
- * "model name". A 200-character single-line string is happily prose
- * ("Summarize this user\u0027s activity"), which is why a length cap alone was
- * not the boundary this record needs. Errors never echo a rejected value,
- * so a mis-passed prompt cannot reach logs through the failure path either.
- */
-interface AnalysisRunMetadata {
-    provider: string;
-    model: string;
-    promptVersion: string;
-    /** Observation ids the run consumed, for evidence tracing. */
-    observationCount: number;
-}
-declare const ANALYSIS_METADATA_MAX_FIELD_LENGTH = 120;
-/** True when value is an identifier-safe provider/model/promptVersion string. */
-declare const isAnalysisIdentifier: (value: string) => boolean;
-declare function buildAnalysisRunMetadata(input: {
-    provider: string;
-    model: string;
-    promptVersion: string;
-    observationCount: number;
-}): AnalysisRunMetadata;
-
-declare const TIMELINE_DAY_FORMAT_VERSION = 1;
-declare const TIMELINE_DAY_DIR: string;
-interface TimelineAnalysisClients {
-    localLlm?: TimelineAnalysisLocalLlm | null;
-    remoteLlm?: TimelineAnalysisRemoteLlm | null;
-}
-interface RegenerateTimelineDayInput {
-    date: string;
-    timezone: string;
-    memoryDir: string;
-    store: {
-        listSnapshotsForDay: (machine: string | null, startUtc: string, endUtc: string) => ActivitySnapshot[];
-    };
-    timelineEnabled: boolean;
-    analysis: ActivityTimelineAnalysisConfig;
-    deps?: TimelineAnalysisClients;
-    pluginConfig?: PluginConfig;
-    signal?: AbortSignal;
-    corrections?: readonly TimelineCorrection[];
-}
-/**
- * Persisted day status. "pending" is the prewrite marker for an enabled run
- * whose analysis has not completed: a crash after the deterministic prewrite
- * must not read as terminal on the next run.
- */
-type PersistedTimelineDayStatus = TimelineAnalysisStatus | "pending" | "timeline_disabled";
-interface PersistedTimelineDay {
-    formatVersion: number;
-    date: string;
-    timezone: string;
-    sourceHash: string;
-    status: PersistedTimelineDayStatus;
-    cards: TimelineCard[];
-    metadata?: AnalysisRunMetadata;
-    failure?: AnalysisFailure;
-}
-interface RegenerateTimelineDayResult {
-    status: PersistedTimelineDayStatus;
-    cards: TimelineCard[];
-    path: string;
-    written: boolean;
-    analyzed: boolean;
-    metadata?: AnalysisRunMetadata;
-    failure?: AnalysisFailure;
-}
-declare function timelineDayPath(memoryDir: string, date: string): string;
-declare function snapshotToObservation(snapshot: ActivitySnapshot): TimelineObservation | null;
-/** Local calendar days covering [fromMs, toMs), oldest first. Capped at 3660 days. */
-declare function localDatesForUtcRange(fromMs: number, toMs: number, timezone: string): string[];
-/** Persisted local days already on disk (YYYY-MM-DD), regardless of store state. */
-declare function listPersistedTimelineDates(memoryDir: string): string[];
-/**
- * Local days a CLI window must load. Bounded windows keep the explicit
- * from/to span; a window with a single bound loads the local day containing
- * that instant (never today). An unbounded search loads every day the
- * snapshot store or a persisted day file covers (plus today), so historical
- * cards enter the search pool instead of only the current day.
- */
-declare function resolveTimelineLoadDates(input: {
-    window: {
-        from?: string;
-        to?: string;
-    };
-    timezone: string;
-    today: string;
-    store: {
-        snapshotCaptureExtent(): {
-            firstUtc: string;
-            lastUtc: string;
-        } | null;
-    };
-    persistedDates: readonly string[];
-}): string[];
-declare function timelineAnalysisClientsFromConfig(config: PluginConfig): TimelineAnalysisClients;
-/** Build, optionally analyze once, and persist one local day of timeline cards. */
-declare function regenerateTimelineDay(input: RegenerateTimelineDayInput): Promise<RegenerateTimelineDayResult>;
-
-/**
- * Host-agnostic activity sync runner (issue #1900).
- *
- * Bridges parsed `config.activity` to the durable sync pipeline: the parser
- * (config.ts) validates settings but never contacts a daemon, and
- * `syncActivitySource` (pipeline.ts) syncs one source for one day. This runner
- * is the missing middle — it instantiates one `ActivityHttpSourceClient` per
- * configured source from the parsed config and drives a sync across the
- * `syncDays` local-day window, but ONLY when the feature is enabled.
- *
- * The feature is master default-off: source config alone never starts a sync.
- * When `config.enabled` is false the runner opens no store, builds no client,
- * and makes no HTTP call or write — it returns a disabled summary. This mirrors
- * `runLiveConnectorsOnce`'s disabled-vs-result reporting so a host scheduler
- * (CLI, cron) can trigger it through the runtime with no OpenClaw imports.
- *
- * Cursor semantics are delegated wholesale to `syncActivitySource`: the
- * per-machine cursor advances only after every page and the digest are durable,
- * so a runtime failure (or an aborted stop) leaves the cursor unadvanced and a
- * restart resumes from the persisted position. A per-source failure is captured
- * as an error item and never aborts the other sources or the host flow.
- */
-
-type ActivityNow = Date | (() => Date);
-/** One configured source's aggregate result across the synced day window. */
-interface ActivitySourceRunItem {
-    machineLabel: string;
-    /** True when at least one day synced durably (no error). */
-    ran: boolean;
-    fetched: number;
-    inserted: number;
-    duplicates: number;
-    digestsWritten: number;
-    /** Persisted cursor after the run; unadvanced from prior on failure. */
-    cursor: string | null;
-    /** Set when the source failed; distinguishes a fault from an empty page. */
-    error?: string;
-    /**
-     * Set when a durable day synced but its post-digest search reindex failed.
-     * The rows/digest/cursor are committed; the index is stale until the next
-     * refresh, so this is a signal (not a sync failure) for the scheduler.
-     */
-    reindexError?: string;
-}
-interface ActivitySyncRunSummary {
-    ranAt: string;
-    /** False means the feature is off: no client built, no HTTP, no write. */
-    enabled: boolean;
-    ranCount: number;
-    errorCount: number;
-    /** Sources whose durable sync succeeded but whose search reindex failed. */
-    reindexErrorCount: number;
-    totalInserted: number;
-    results: ActivitySourceRunItem[];
-    /**
-     * Local dates (YYYY-MM-DD, in the sync timezone) that gained new snapshots
-     * this run — a backfill/rolling window can touch several. Meetings rebuild
-     * uses this so a change to an OLDER day rebuilds that day, not just today.
-     */
-    touchedDates: string[];
-}
-interface ActivitySyncRunOptions {
-    config: ActivityConfig;
-    memoryDir: string;
-    /** Injectable store; opened from memoryDir when omitted (and closed here). */
-    store?: ActivityStore;
-    /** Clock injection for deterministic day-window resolution in tests. */
-    now?: ActivityNow;
-    /** Abort a run in flight (stop); an aborted source leaves its cursor intact. */
-    signal?: AbortSignal;
-    /** Injectable client factory; builds an ActivityHttpSourceClient by default. */
-    createSourceClient?: (source: ActivitySourceConfig) => ActivitySourceClient;
-    /**
-     * Search-index refresh forwarded to each source sync as `afterWrites`, run
-     * after a digest is (re)written so it becomes discoverable (rule 31).
-     * Host wires the core index seam (SearchBackend.update); best-effort.
-     */
-    reindexSearch?: (signal?: AbortSignal) => Promise<void>;
-    /** Full plugin config so regenerate can construct local/remote LLM clients. */
-    pluginConfig?: PluginConfig;
-    /** Injected analysis clients; tests and hosts that already own them. */
-    analysisDeps?: TimelineAnalysisClients;
-}
-/**
- * The local-day window to sync, oldest first: today back `syncDays` calendar
- * days in the configured timezone. Walking by calendar days (not fixed 24h
- * intervals) keeps the window correct across DST transitions.
- */
-declare function resolveActivitySyncDates(syncDays: number, timezone: string, now: Date): string[];
-/**
- * Run one activity sync pass across every configured source. Disabled config
- * short-circuits before any store/client/HTTP work; an enabled config syncs
- * each source across the `syncDays` window and isolates per-source faults.
- */
-declare function runActivitySyncOnce(options: ActivitySyncRunOptions): Promise<ActivitySyncRunSummary>;
-
-/**
- * Maintenance scheduler — extracted from the orchestrator (issue #1526 PR1).
- *
- * Owns the WHEN of memory maintenance:
- *   - cron auto-registration (writes jobs.json entries the OpenClaw cron
- *     daemon picks up)
- *   - debounced + singleflight QMD index maintenance (re-index + embed
- *     after writes)
- *   - consolidation scheduling trigger (count + interval gated)
- *
- * Does NOT own the WHAT — the actual job runners (runSemanticConsolidation,
- * runPatternReinforcement, runDeepSleepGovernanceNow, runConsolidation)
- * remain on the orchestrator because they need the full LLM + extraction
- * dependency surface. The scheduler invokes consolidation through a
- * callback so the orchestrator stays the source of truth for that work.
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator keeps thin delegating methods so existing tests that stub
- * `orchestrator.requestQmdMaintenance` etc. continue to work.
- */
-
-/** Dependencies injected by the orchestrator. All stable references. */
-interface MaintenanceSchedulerDeps {
-    config: PluginConfig;
-    /** Live accessor — the orchestrator can reassign its qmd backend after
-     *  construction (e.g. swap to NoopSearchBackend when the collection is
-     *  missing), and the scheduler must always observe the current backend. */
-    getQmd: () => SearchBackend;
-    namespaceSearchRouter: NamespaceSearchRouter;
-    namespaceCatalog: NamespaceCatalog;
-    /**
-     * Root storage (secure-store configured). Threaded so lifecycle-ledger
-     * auto-compaction (#1910) rebuilds through the live secure context: encrypted
-     * memories stay decryptable and the rewritten ledger stays encrypted at rest.
-     * Omitted in focused tests, where compaction falls back to a fresh plaintext
-     * StorageManager (the CLI-equivalent path).
-     */
-    getStorage?: () => StorageManager;
-    /**
-     * Resolve a namespace's (secure-store aware) storage. Threaded so
-     * auto-compaction also bounds per-namespace lifecycle ledgers under
-     * `memoryDir/namespaces/<token>/state/`, not just the root state path
-     * (#1910). Consulted only when namespaces are enabled.
-     */
-    storageForNamespace?: (namespace: string) => Promise<StorageManager>;
-    /**
-     * Tail step (issue #1900): observe a durable activity sync tick so the
-     * meetings builder can rebuild the affected day(s). Optional; omitted by
-     * hosts that do not build meetings.
-     */
-    onActivitySynced?: (summary: ActivitySyncRunSummary) => void;
-}
-/**
- * Schedules and debounces memory maintenance work. Owns the cadence +
- * singleflight state that previously lived as private orchestrator fields.
- *
- * The orchestrator constructs one instance in its constructor and delegates
- * the public scheduling entrypoints to it. Job execution stays on the
- * orchestrator (LLM-heavy) and is invoked through callbacks.
- */
-declare class MaintenanceScheduler {
-    private readonly deps;
-    private nonZeroExtractionsSinceConsolidation;
-    private lastConsolidationRunAtMs;
-    private consolidationRunPromise;
-    private disposed;
-    private qmdMaintenanceTimer;
-    private qmdMaintenancePending;
-    private qmdMaintenanceInFlight;
-    private lastQmdEmbedAtMs;
-    private lastQmdEmbedAtMsByNamespace;
-    private lifecycleCompactionInFlight;
-    private lastLifecycleCompactionAtMs;
-    private lifecycleLedgerMaxBytes;
-    private readonly projectionRebuild;
-    private readonly activityRegistrar;
-    private locationAutoSync;
-    constructor(deps: MaintenanceSchedulerDeps);
-    /**
-     * Register every cron job the daemon should run, gated by its config flag.
-     * Each registration is independent and non-fatal — a failure in one does
-     * not block the others (mirrors the orchestrator's prior sequential try/
-     * catch behavior exactly).
-     *
-     * Returns when all eligible registrations have completed so callers that
-     * `await deferredReady` can rely on jobs.json being current.
-     */
-    autoRegisterCrons(signal: AbortSignal): Promise<void>;
-    autoRegisterDaySummaryCron(): Promise<void>;
-    autoRegisterNightlyGovernanceCron(): Promise<void>;
-    autoRegisterProceduralMiningCron(): Promise<void>;
-    autoRegisterContradictionScanCron(): Promise<void>;
-    autoRegisterPatternReinforcementCron(): Promise<void>;
-    autoRegisterGraphEdgeDecayCron(): Promise<void>;
-    /**
-     * Maybe trigger a background consolidation pass after an extraction.
-     * Counted + interval gated so a burst of extractions does not fan into a
-     * burst of consolidation passes. The consolidation runner itself is
-     * passed in as a callback because it lives on the orchestrator (LLM +
-     * storage dependency surface) and is not owned by this module.
-     */
-    maybeScheduleConsolidation(nonZeroExtraction: boolean, runConsolidation: () => Promise<unknown>): void;
-    /** Whether a background consolidation pass is currently running. Exposed so
-     *  the orchestrator's waitForConsolidationIdle can poll idle state without
-     *  owning the cadence state (issue #1526 PR1). */
-    isConsolidationInFlight(): boolean;
-    /** Whether a debounced QMD maintenance pass is armed and waiting for the
-     *  debounce timer. Exposed so drain/teardown diagnostics (e.g. the bench
-     *  adapter) can observe scheduler idle state after the #1526 PR1 extraction
-     *  moved this flag off the orchestrator. */
-    isQmdMaintenancePending(): boolean;
-    /** Whether a QMD maintenance pass is currently running (singleflight guard).
-     *  Exposed for drain/teardown diagnostics (see isQmdMaintenancePending). */
-    isQmdMaintenanceInFlight(): boolean;
-    /** Internal: queue a debounced QMD maintenance pass. */
-    private requestQmdMaintenance;
-    /**
-     * Public entrypoint for tool-driven QMD maintenance requests.
-     * Routes through existing debounced/singleflight maintenance controls.
-     */
-    requestQmdMaintenanceForTool(reason: string): void;
-    /** Internal: run a single QMD maintenance pass under singleflight guard. */
-    runQmdMaintenance(): Promise<void>;
-    /**
-     * Size-gated, throttled, single-flighted auto-compaction of the lifecycle
-     * ledger (issue #1910). Compacts the root ledger AND every namespace ledger
-     * (`memoryDir/namespaces/<token>/state/`) when namespaces are enabled, each
-     * through the existing `rebuildMemoryLifecycleLedger` so the
-     * archive-then-atomic-write discipline is reused verbatim. `0` disables.
-     *
-     * Before compacting, drain EVERY target's durable pending-append spill (the
-     * root ledger AND each namespace ledger) so a lifecycle event that spilled
-     * while a prior long rewrite held the lock is folded back into its ledger and
-     * cannot be silently lost (issue #2033). Draining is independent of both the
-     * compaction threshold and the min-interval throttle: targets are enumerated
-     * through the same safe (symlink/containment-checked) resolver and every
-     * eligible queue is drained BEFORE any throttle return, so a namespace spill
-     * created after the previous pass never waits out the whole interval.
-     * Encrypted-store safety is preserved — a keyed target drains through its
-     * secure StorageManager, a filesystem-fallback target only through a plaintext
-     * context that refuses encrypted ledgers/spills. Work stays bounded: one
-     * target enumeration plus a bounded per-queue drain.
-     *
-     * The min-interval throttle timestamp advances ONLY after real, fully
-     * successful compaction work: a failed OR deferred target leaves the throttle
-     * un-advanced so it stays eligible on the next maintenance pass, while
-     * `lifecycleCompactionInFlight` still prevents overlapping runs. A "deferred"
-     * target is oversized but could not be compacted because its encrypted ledger
-     * has no unlocked secure store — arming the throttle for it would suppress the
-     * retry of that still-oversized ledger for the whole interval (#2033).
-     *
-     * The min-interval throttle is bypassed for one case: an encrypted ledger
-     * already at/over the whole-file decrypt cap is unreadable, so it must be
-     * clamped on the next pass rather than wait out the interval. Ordinary
-     * below-cap (or plaintext) targets stay throttled (#2033).
-     */
-    private maybeCompactMemoryLifecycleLedger;
-    /**
-     * True when any lifecycle target's ledger is encrypted at rest AND its
-     * on-disk size is at/over the whole-file decrypt cap. Such a ledger is already
-     * unreadable (the secure reader refuses at/over the cap), so it must reach the
-     * bounded compaction path on the next maintenance pass regardless of the
-     * global min-interval throttle — otherwise the throttle could keep an
-     * unreadable ledger un-clamped for a whole interval (#2033). Ordinary
-     * below-cap or plaintext targets never match, so the throttle still governs
-     * them. A stat/probe failure yields "no forced target" and is left to the
-     * normal compaction path, which classifies it as failed and retries.
-     */
-    private hasOverCapEncryptedLifecycleLedger;
-    /**
-     * Drain one compaction target's durable pending spill. A catalog-backed
-     * target folds through its secure StorageManager; a filesystem-fallback
-     * target (no storage) folds through a path-scoped plaintext context that
-     * refuses encrypted ledgers/spills so a keyless drain never downgrades an
-     * encrypted ledger (issue #2033).
-     */
-    private drainPendingForTarget;
-    /** Drain a target's durable pending lifecycle-append spill into its ledger
-     *  (issue #2033); non-fatal and a fast no-op when nothing is pending. */
-    private drainPendingLifecycleAppends;
-    /**
-     * Drain a filesystem-fallback target's pending lifecycle-append spill when no
-     * secure StorageManager is available (catalog-disabled namespace; issue
-     * #2033). Uses the safe path-scoped PLAINTEXT context this fallback already
-     * operates in: a keyless drain can only fold plaintext spills into a plaintext
-     * ledger, so it refuses when the ledger or ANY spill is encrypted at rest,
-     * leaving those pending for a keyed (catalog-path) drain — exactly mirroring
-     * the fallback compaction's encrypted-ledger deferral. Non-fatal; a fast
-     * no-op when nothing is pending. The shared spill lister enforces the symlink/
-     * containment guard on every spill file it reads or deletes.
-     */
-    private drainPendingLifecycleAppendsForPath;
-    /**
-     * Enumerate the lifecycle ledgers to consider for compaction: the root
-     * (through the secure-configured root storage when available) plus every
-     * cataloged namespace ledger when namespaces are enabled. Deduplicated by
-     * resolved storage dir so a namespace that collapses onto the root is not
-     * compacted twice. Namespace resolution failures are non-fatal.
-     */
-    private resolveLifecycleCompactionTargets;
-    /**
-     * Compact one lifecycle ledger when it is at/over `threshold`. Returns
-     * `"skipped"` (absent or below threshold — nothing to do), `"compacted"`
-     * (rewritten and verified under the read/decrypt cap), `"failed"`
-     * (rebuild/probe threw, or the rewritten ledger is STILL over the cap — an
-     * ineffective compaction — non-fatal, retried next pass), or `"deferred"`
-     * (oversized but its encrypted ledger cannot be rewritten because no unlocked
-     * secure store is available — real work still pending, so the caller must NOT
-     * arm the throttle). #2033: a deferred/failed target is distinct from a genuine
-     * no-op so one namespace compacting cannot suppress retries for another, and
-     * an over-cap rewrite never arms the throttle.
-     */
-    private compactLifecycleLedgerTarget;
-    /** Build the namespace-aware maintenance plan for one job. */
-    private namespaceMaintenancePlan;
-    /**
-     * Clear any pending debounce timer and drain the activity sync scheduler.
-     * Called from the orchestrator's destroy() so a late tick does not fire on a
-     * torn-down instance and no in-flight activity tick keeps writing after
-     * teardown. Async: awaits the scheduler's abort+drain before resolving.
-     */
-    dispose(): Promise<void>;
-}
-
-export { regenerateTimelineDay as $, ActivityStore as A, type TimelineAnalysisClients as B, type TimelineAnalysisComplete as C, type TimelineAnalysisCompleteInput as D, TimelineAnalysisConfigError as E, type TimelineAnalysisInput as F, TimelineAnalysisProviderError as G, type TimelineAnalysisResult as H, type TimelineEvidenceRange as I, type TimelineManualEdit as J, activityDatabasePath as K, analyzeTimelineCards as L, MaintenanceScheduler as M, applyActivitySchema as N, buildAnalysisRunMetadata as O, type PersistedTimelineDay as P, buildTimelineAnalysisPrompt as Q, type RegenerateTimelineDayInput as R, classifyAnalysisFailure as S, type TimelineCategory as T, classifyAnalysisProviderError as U, ensureActivityStateDir as V, isAnalysisFailureKind as W, isAnalysisIdentifier as X, listPersistedTimelineDates as Y, localDatesForUtcRange as Z, openActivityDatabase as _, type ActivitySyncRunSummary as a, resolveActivitySyncDates as a0, resolveTimelineLoadDates as a1, runActivitySyncOnce as a2, snapshotToObservation as a3, timelineAnalysisClientsFromConfig as a4, timelineAnalysisCompleteFromClients as a5, timelineDayPath as a6, type MaintenanceSchedulerDeps as a7, type TimelineObservation as b, type TimelinePause as c, type TimelineDay as d, type TimelineCorrection as e, type TimelineCard as f, type TimelineCardKind as g, type TimelineAnalysisLocalLlm as h, type TimelineAnalysisRemoteLlm as i, type TimelineAnalysisStatus as j, type AnalysisFailure as k, type AnalysisRunMetadata as l, ANALYSIS_FAILURE_KINDS as m, ANALYSIS_METADATA_MAX_FIELD_LENGTH as n, type ActivitySourceRunItem as o, type ActivitySyncRunOptions as p, type AnalysisFailureKind as q, type PersistedTimelineDayStatus as r, type RegenerateTimelineDayResult as s, TIMELINE_ANALYSIS_BATCH_OVERLAP as t, TIMELINE_ANALYSIS_BATCH_SIZE as u, TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS as v, TIMELINE_ANALYSIS_LOCAL_PROVIDER_ID as w, TIMELINE_ANALYSIS_PROMPT_VERSION as x, TIMELINE_DAY_DIR as y, TIMELINE_DAY_FORMAT_VERSION as z };