@remnic/core 9.22.0 → 9.22.2

package/dist/intent.d.ts

@@ -1,4 +1,4 @@
-import { ai as MemoryIntent, R as RecallPlanMode } from './types-GBQZuT7l.js';
+import { ai as MemoryIntent, R as RecallPlanMode } from './types-Bbs0qz6b.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/lcm/engine.d.ts

@@ -2,7 +2,7 @@ import { LcmStructuredRecallMatch } from './archive.js';
 import { SummarizeFn } from './summarizer.js';
 import { LcmRecallWithTraceResult } from './recall.js';
 import { LcmObserveMessage } from './queue.js';
-import { P as PluginConfig } from '../types-GBQZuT7l.js';
+import { P as PluginConfig } from '../types-Bbs0qz6b.js';
 import 'better-sqlite3';
 import '../message-parts/index.js';
 import './dag.js';

package/dist/lcm/engine.js

@@ -1,13 +1,13 @@
 import {
   LcmEngine,
   extractLcmConfig
-} from "../chunk-GF22HWS2.js";
+} from "../chunk-2PHX3I5C.js";
+import "../chunk-PBGWYM3H.js";
+import "../chunk-LTAVSOZW.js";
 import "../chunk-7N4KAIGN.js";
 import "../chunk-TPDBFYEG.js";
 import "../chunk-UXPUUL3G.js";
 import "../chunk-DDA47TES.js";
-import "../chunk-PBGWYM3H.js";
-import "../chunk-LTAVSOZW.js";
 import "../chunk-4RA3C3EV.js";
 import "../chunk-AQEJKOKI.js";
 import "../chunk-RL6NEVXT.js";

package/dist/lcm/index.d.ts

@@ -7,7 +7,7 @@ export { registerLcmTools } from './tools.js';
 export { ensureLcmStateDir, openLcmDatabase } from './schema.js';
 import './queue.js';
 import '../message-parts/index.js';
-import '../types-GBQZuT7l.js';
+import '../types-Bbs0qz6b.js';
 import '../bounded-jsonl-state.js';
 import '../types-continuity.js';
 import 'better-sqlite3';

package/dist/lcm/index.js

@@ -1,8 +1,18 @@
 import "../chunk-VDC6RZI4.js";
+import {
+  registerLcmTools
+} from "../chunk-UWK5OXUJ.js";
 import {
   LcmEngine,
   extractLcmConfig
-} from "../chunk-GF22HWS2.js";
+} from "../chunk-2PHX3I5C.js";
+import {
+  LcmSummarizer
+} from "../chunk-PBGWYM3H.js";
+import {
+  LcmArchive,
+  estimateTokens
+} from "../chunk-LTAVSOZW.js";
 import {
   LcmDag
 } from "../chunk-7N4KAIGN.js";
@@ -15,16 +25,6 @@ import {
   ensureLcmStateDir,
   openLcmDatabase
 } from "../chunk-DDA47TES.js";
-import {
-  LcmSummarizer
-} from "../chunk-PBGWYM3H.js";
-import {
-  registerLcmTools
-} from "../chunk-UWK5OXUJ.js";
-import {
-  LcmArchive,
-  estimateTokens
-} from "../chunk-LTAVSOZW.js";
 import "../chunk-4RA3C3EV.js";
 import "../chunk-AQEJKOKI.js";
 import {

package/dist/lcm/tools.d.ts

@@ -6,7 +6,7 @@ import './summarizer.js';
 import './dag.js';
 import './recall.js';
 import './queue.js';
-import '../types-GBQZuT7l.js';
+import '../types-Bbs0qz6b.js';
 import '../bounded-jsonl-state.js';
 import '../types-continuity.js';
 

package/dist/lifecycle.d.ts

@@ -1,4 +1,4 @@
-import { X as LifecycleState, w as MemoryCategory, M as MemoryFile, o as MemoryFrontmatter } from './types-GBQZuT7l.js';
+import { W as LifecycleState, w as MemoryCategory, M as MemoryFile, o as MemoryFrontmatter } from './types-Bbs0qz6b.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/live-connectors-runner.d.ts

@@ -1,5 +1,5 @@
 import { L as LiveConnector, C as ConnectorConfig, a as ConnectorDocument } from './framework-CNDn2164.js';
-import { L as LiveConnectorsConfig } from './types-GBQZuT7l.js';
+import { L as LiveConnectorsConfig } from './types-Bbs0qz6b.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/local-llm.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig } from './types-GBQZuT7l.js';
+import { P as PluginConfig } from './types-Bbs0qz6b.js';
 import { ModelRegistry } from './model-registry.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';

package/dist/local-model-endpoint.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig } from './types-GBQZuT7l.js';
+import { P as PluginConfig } from './types-Bbs0qz6b.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/maintenance/memory-governance.d.ts

@@ -1,4 +1,4 @@
-import { x as MemoryStatus, M as MemoryFile } from '../types-GBQZuT7l.js';
+import { x as MemoryStatus, M as MemoryFile } from '../types-Bbs0qz6b.js';
 import '../message-parts/index.js';
 import '../bounded-jsonl-state.js';
 import '../types-continuity.js';

package/dist/maintenance/memory-governance.js

@@ -7,16 +7,17 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "../chunk-BRT7KEXU.js";
-import "../chunk-QMGIQUBG.js";
-import "../chunk-UHVXE24Y.js";
+} from "../chunk-6TWXQ4E2.js";
+import "../chunk-TBBDFYXW.js";
+import "../chunk-XWPFZX6S.js";
 import "../chunk-2QMKMVHH.js";
+import "../chunk-UHVXE24Y.js";
 import "../chunk-DEBHXHJR.js";
 import "../chunk-DNHVPZOD.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-J6A3CX5N.js";
 import "../chunk-HKF5VASQ.js";
-import "../chunk-6NZ7U4R4.js";
+import "../chunk-SCOT5DTA.js";
 import "../chunk-XKGPIWGI.js";
 import "../chunk-EGGE52UU.js";
 import "../chunk-GCASGYIO.js";
@@ -25,8 +26,8 @@ import "../chunk-ILGC6JH6.js";
 import "../chunk-SCU65EZI.js";
 import "../chunk-3CSX3ETE.js";
 import "../chunk-RL6NEVXT.js";
-import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
+import "../chunk-DM2T26WE.js";
 import "../chunk-JYIJNNN3.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-CGASUJVP.js";
@@ -57,7 +58,6 @@ import "../chunk-JUC24CTX.js";
 import "../chunk-P7FMDTKL.js";
 import "../chunk-6MKAMLQL.js";
 import "../chunk-JAKIDQB2.js";
-import "../chunk-TBBDFYXW.js";
 import "../chunk-RDQGLJRR.js";
 import "../chunk-FF4KLI5W.js";
 import "../chunk-AIK5W3IW.js";

package/dist/maintenance/rebuild-memory-lifecycle-ledger.d.ts

@@ -1,5 +1,5 @@
-import { S as StorageManager } from '../storage-BKhHHnRo.js';
-import { z as MemoryLifecycleEvent } from '../types-GBQZuT7l.js';
+import { S as StorageManager } from '../storage-XGawwqXE.js';
+import { z as MemoryLifecycleEvent } from '../types-Bbs0qz6b.js';
 import { HeldFileLockOptions } from '../utils/serialize-mutations.js';
 import '../page-versioning.js';
 import '../consolidation-operator.js';

package/dist/maintenance/rebuild-memory-lifecycle-ledger.js

@@ -2,18 +2,18 @@ import {
   backupExistingLedger,
   boundLifecycleEventsToByteCap,
   rebuildMemoryLifecycleLedger
-} from "../chunk-55FDQYPS.js";
+} from "../chunk-ES5IHQ6M.js";
 import "../chunk-KJTKLXTH.js";
 import "../chunk-R6YJI3HE.js";
-import "../chunk-QMGIQUBG.js";
-import "../chunk-UHVXE24Y.js";
+import "../chunk-XWPFZX6S.js";
 import "../chunk-2QMKMVHH.js";
+import "../chunk-UHVXE24Y.js";
 import "../chunk-DEBHXHJR.js";
 import "../chunk-DNHVPZOD.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-J6A3CX5N.js";
 import "../chunk-HKF5VASQ.js";
-import "../chunk-6NZ7U4R4.js";
+import "../chunk-SCOT5DTA.js";
 import "../chunk-XKGPIWGI.js";
 import "../chunk-EGGE52UU.js";
 import "../chunk-GCASGYIO.js";
@@ -22,8 +22,8 @@ import "../chunk-ILGC6JH6.js";
 import "../chunk-SCU65EZI.js";
 import "../chunk-3CSX3ETE.js";
 import "../chunk-RL6NEVXT.js";
-import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
+import "../chunk-DM2T26WE.js";
 import "../chunk-JYIJNNN3.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-CGASUJVP.js";

package/dist/maintenance/rebuild-memory-projection.d.ts

@@ -1,5 +1,5 @@
-import { S as StorageManager } from '../storage-BKhHHnRo.js';
-import '../types-GBQZuT7l.js';
+import { S as StorageManager } from '../storage-XGawwqXE.js';
+import '../types-Bbs0qz6b.js';
 import '../message-parts/index.js';
 import '../bounded-jsonl-state.js';
 import '../types-continuity.js';

package/dist/maintenance/rebuild-memory-projection.js

@@ -3,20 +3,21 @@ import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "../chunk-TTKWTT72.js";
+} from "../chunk-3ZW6ZQO6.js";
 import "../chunk-KJTKLXTH.js";
 import "../chunk-2DQ2XREU.js";
 import "../chunk-R6YJI3HE.js";
-import "../chunk-BRT7KEXU.js";
-import "../chunk-QMGIQUBG.js";
-import "../chunk-UHVXE24Y.js";
+import "../chunk-6TWXQ4E2.js";
+import "../chunk-TBBDFYXW.js";
+import "../chunk-XWPFZX6S.js";
 import "../chunk-2QMKMVHH.js";
+import "../chunk-UHVXE24Y.js";
 import "../chunk-DEBHXHJR.js";
 import "../chunk-DNHVPZOD.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-J6A3CX5N.js";
 import "../chunk-HKF5VASQ.js";
-import "../chunk-6NZ7U4R4.js";
+import "../chunk-SCOT5DTA.js";
 import "../chunk-XKGPIWGI.js";
 import "../chunk-EGGE52UU.js";
 import "../chunk-GCASGYIO.js";
@@ -25,8 +26,8 @@ import "../chunk-ILGC6JH6.js";
 import "../chunk-SCU65EZI.js";
 import "../chunk-3CSX3ETE.js";
 import "../chunk-RL6NEVXT.js";
-import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
+import "../chunk-DM2T26WE.js";
 import "../chunk-JYIJNNN3.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-CGASUJVP.js";
@@ -57,7 +58,6 @@ import "../chunk-JUC24CTX.js";
 import "../chunk-P7FMDTKL.js";
 import "../chunk-6MKAMLQL.js";
 import "../chunk-JAKIDQB2.js";
-import "../chunk-TBBDFYXW.js";
 import "../chunk-RDQGLJRR.js";
 import "../chunk-FF4KLI5W.js";
 import "../chunk-AIK5W3IW.js";

package/dist/maintenance-C98njYb8.d.ts

@@ -0,0 +1,366 @@
+import { au as ActivitySnapshot, av as ActivityConfig, aw as ActivitySourceConfig, ax as ActivitySourceClient, P as PluginConfig } from './types-Bbs0qz6b.js';
+import { SearchBackend } from './search/port.js';
+import { S as StorageManager } from './storage-XGawwqXE.js';
+import { N as NamespaceCatalog } from './catalog-BFTVo2Ez.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;
+    close(): void;
+}
+
+/**
+ * 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>;
+}
+/**
+ * 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 consolidationInFlight;
+    private qmdMaintenanceTimer;
+    private qmdMaintenancePending;
+    private qmdMaintenanceInFlight;
+    private lastQmdEmbedAtMs;
+    private lastQmdEmbedAtMsByNamespace;
+    private lifecycleCompactionInFlight;
+    private lastLifecycleCompactionAtMs;
+    private lifecycleLedgerMaxBytes;
+    private readonly projectionRebuild;
+    private readonly activityRegistrar;
+    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 { ActivityStore as A, MaintenanceScheduler as M, type ActivitySyncRunSummary as a, type ActivitySourceRunItem as b, type ActivitySyncRunOptions as c, activityDatabasePath as d, applyActivitySchema as e, ensureActivityStateDir as f, runActivitySyncOnce as g, type MaintenanceSchedulerDeps as h, openActivityDatabase as o, resolveActivitySyncDates as r };