@aitne/daemon 0.1.0

package/dist/observers/delegated-probe-observer.js

@@ -0,0 +1,237 @@
+import { evaluateProbe, } from "../core/integration-probe.js";
+import { readProbe, writeProbe, } from "../db/integration-probe-store.js";
+import { readIntegrations } from "../db/integrations-store.js";
+import { LiveProbeUnsupportedError, } from "../core/agent-core.js";
+import { createLogger } from "../logging.js";
+const logger = createLogger("delegated-probe-observer");
+/**
+ * Default stagger between consecutive per-backend probe subprocesses.
+ * Mirrors `McpAutoProbe`'s shape (smaller value here because we typically
+ * only have 1-3 distinct backends to walk per tick, not 10 MCP servers).
+ */
+const DEFAULT_STAGGER_MS = 250;
+/**
+ * DELEGATED-MODE-V2 §7.1 — periodic re-probe observer.
+ *
+ * Walks every `state.mode === "delegated"` integration once per
+ * `intervalMinutes`, batches them by `delegatedBackend`, and re-runs
+ * `core.probeTools()` per backend so the `integration_probes` cache stays
+ * fresh. Without this, `consultDelegatedConnectorHealth` (`§4.5`) is
+ * input-starved after the wizard's first probe — the §10 risk row "user
+ * signed out hours ago" never produces a DM.
+ *
+ * Batching: two integrations on the same `delegatedBackend` consume one
+ * subprocess call (the live tool list is namespace-filtered per
+ * integration by `evaluateProbe`). Per-integration calls would be N×
+ * cost for the current `{gmail, google_calendar}` registry where both
+ * default to the same backend.
+ *
+ * The probeTools prompts in `claude-code-core.ts` and `codex-core.ts` are
+ * hardcoded for Gmail + Google_Calendar by name. Adding a new delegated
+ * integration requires lockstep updates to both prompts AND the prefix /
+ * regex constants (see DELEGATED-MODE-V2 §7.1 "Adding a new delegated
+ * integration"); otherwise the new integration's `present` is
+ * permanently false regardless of actual sign-in state.
+ *
+ * Failure handling per group, not per tick: a backend whose CLI throws,
+ * times out, or returns `LiveProbeUnsupportedError` does not crash the
+ * tick or skip remaining groups. The probe row stays at its last value
+ * (preserves last-known-good).
+ */
+export class DelegatedProbeObserver {
+    options;
+    name = "delegated-probe";
+    timer = null;
+    tickRunning = false;
+    intervalMs;
+    staggerMs;
+    now;
+    sleep;
+    /**
+     * Latch keyed by `${integration}:${backend}` so each Gemini-style
+     * `LiveProbeUnsupportedError` logs at most once. Without this every
+     * tick would emit the same warn line indefinitely.
+     */
+    liveProbeUnsupportedLogged = new Set();
+    constructor(options) {
+        this.options = options;
+        this.intervalMs = options.intervalMinutes * 60_000;
+        this.staggerMs = options.staggerMs ?? DEFAULT_STAGGER_MS;
+        this.now = options.now ?? Date.now;
+        this.sleep =
+            options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    }
+    async start() {
+        if (this.intervalMs <= 0) {
+            logger.info("Delegated probe observer disabled (delegatedProbeIntervalMinutes <= 0) — skipping registration");
+            return;
+        }
+        // First tick is scheduled, not immediate: avoid racing with the
+        // wizard's initial live-probe flurry the user often runs right after
+        // delegating an integration.
+        this.timer = setInterval(() => void this.tick(), this.intervalMs);
+        logger.info({ intervalMs: this.intervalMs }, "Delegated probe observer started");
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        // In-flight tick is allowed to complete on its own. Each
+        // `probeTools()` carries its own per-backend subprocess timeout, so
+        // leaking the Promise here is bounded.
+    }
+    /**
+     * Runs one pass over delegated integrations grouped by backend.
+     * Exposed for tests; production callers let the interval timer drive
+     * it. Re-entrancy is guarded so a slow tick (Codex CLI startup × N
+     * backends) cannot overlap the next timer fire.
+     */
+    async tick() {
+        if (this.tickRunning) {
+            logger.debug("Delegated probe tick already running — skipping overlap");
+            return;
+        }
+        this.tickRunning = true;
+        try {
+            await this.runTick();
+        }
+        finally {
+            this.tickRunning = false;
+        }
+    }
+    async runTick() {
+        const groups = this.collectGroups();
+        if (groups.length === 0)
+            return;
+        const freshnessMs = this.intervalMs / 2;
+        const now = this.now();
+        let probedGroups = 0;
+        let skippedGroups = 0;
+        let firstStagger = true;
+        for (const group of groups) {
+            // Mixed-freshness in a group forces probe — cheaper to run one
+            // subprocess for the whole group than to partial-skip and hand the
+            // staler members an extra interval of staleness.
+            const allFresh = group.integrations.every((key) => {
+                const probedAt = group.probedAtMs.get(key);
+                return probedAt !== undefined && now - probedAt < freshnessMs;
+            });
+            if (allFresh) {
+                skippedGroups++;
+                continue;
+            }
+            const core = this.options.agentBackends.find((c) => c.backendId === group.backend);
+            if (!core) {
+                logger.warn({ backend: group.backend, integrations: group.integrations }, "No registered agent core for delegated backend — skipping group");
+                continue;
+            }
+            if (!firstStagger) {
+                await this.sleep(this.staggerMs);
+            }
+            firstStagger = false;
+            await this.probeGroup(core, group);
+            probedGroups++;
+        }
+        logger.info({
+            probedGroups,
+            skippedGroups,
+            totalGroups: groups.length,
+        }, "Delegated probe tick finished");
+    }
+    collectGroups() {
+        const integrations = readIntegrations(this.options.db);
+        const byBackend = new Map();
+        for (const [keyRaw, state] of Object.entries(integrations)) {
+            if (state.mode !== "delegated")
+                continue;
+            const backend = state.delegatedBackend;
+            // `integrationStateSchema.superRefine` enforces that delegated
+            // mode carries a backend, but the field is nullable+optional in
+            // the type — guard explicitly so TS narrows.
+            /* c8 ignore next -- registry-rollback / hand-edited-DB defense */
+            if (backend === null || backend === undefined)
+                continue;
+            const key = keyRaw;
+            let group = byBackend.get(backend);
+            if (!group) {
+                group = {
+                    backend,
+                    integrations: [],
+                    probedAtMs: new Map(),
+                    presentSnapshot: new Map(),
+                };
+                byBackend.set(backend, group);
+            }
+            group.integrations.push(key);
+            // Snapshot existing probe row up-front so transition logging
+            // compares against the pre-tick state, not the post-`writeProbe`
+            // state we're about to overwrite.
+            const existing = readProbe(this.options.db, key, backend);
+            if (existing) {
+                const probedAt = Date.parse(existing.probedAt);
+                if (!Number.isNaN(probedAt)) {
+                    group.probedAtMs.set(key, probedAt);
+                }
+                group.presentSnapshot.set(key, existing.present);
+            }
+        }
+        return [...byBackend.values()];
+    }
+    async probeGroup(core, group) {
+        let tools;
+        try {
+            tools = await core.probeTools();
+        }
+        catch (err) {
+            if (err instanceof LiveProbeUnsupportedError) {
+                // Log once per (integration, backend). Two ticks → one log line
+                // per pair. Gemini today; future backends that throw the same
+                // class fall through this path automatically.
+                for (const key of group.integrations) {
+                    const latch = `${key}:${group.backend}`;
+                    if (this.liveProbeUnsupportedLogged.has(latch))
+                        continue;
+                    this.liveProbeUnsupportedLogged.add(latch);
+                    logger.warn({
+                        integration: key,
+                        backend: group.backend,
+                        reason: err.reason,
+                    }, "Backend does not support live probe — delegated probe will stay stale until support lands");
+                }
+                return;
+            }
+            logger.warn({ backend: group.backend, integrations: group.integrations, err }, "probeTools threw — preserving last-known-good probe rows for this group");
+            return;
+        }
+        for (const key of group.integrations) {
+            let result;
+            try {
+                result = evaluateProbe({
+                    tools,
+                    integration: key,
+                    backend: group.backend,
+                });
+                writeProbe(this.options.db, result);
+            }
+            catch (err) {
+                // One bad row should not poison its siblings — typically a
+                // registry inconsistency for this specific integration. The
+                // sibling integrations on the same backend continue.
+                logger.error({ integration: key, backend: group.backend, err }, "evaluateProbe / writeProbe failed for delegated integration");
+                continue;
+            }
+            const previousPresent = group.presentSnapshot.get(key);
+            if (previousPresent !== undefined && previousPresent !== result.present) {
+                logger.info({
+                    integration: key,
+                    backend: group.backend,
+                    from: previousPresent,
+                    to: result.present,
+                    missingRequired: result.missingRequired,
+                }, "Delegated probe transition");
+            }
+        }
+    }
+}
+//# sourceMappingURL=delegated-probe-observer.js.map

package/dist/observers/delegated-probe-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegated-probe-observer.js","sourceRoot":"","sources":["../../src/observers/delegated-probe-observer.ts"],"names":[],"mappings":"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"}

package/dist/observers/delegated-sync-worker.d.ts

@@ -0,0 +1,375 @@
+import type Database from "better-sqlite3";
+import { type BackendId, type IntegrationKey } from "@aitne/shared";
+import type { TodayWriteLockManager } from "../core/today-write-lock.js";
+import type { DelegatedBackendInvoker } from "../services/delegated-backend-invoker.js";
+import type { Observer } from "./manager.js";
+export declare const DELEGATED_SYNC_OBSERVER_NAME = "delegated-sync";
+export declare const DELEGATED_SYNC_PROCESS_KEY = "integration_drift_sync";
+interface DelegatedSyncRuntimeConfig {
+    /**
+     * Seconds keyed by either:
+     *   - "google_calendar:primary:imminent" (canonical)
+     *   - "google_calendar.primary:imminent" (human-friendly)
+     *   - "primary:imminent" (integration-local, kept for backwards compat)
+     *
+     * The integration-local form was introduced when calendar was the only
+     * cadence; Phase 5 added gmail (`inbox:7d`) and notion (`recently_updated`)
+     * cadences. Their window keys are unique across integrations today, so
+     * the integration-local fallback still resolves unambiguously, but
+     * operators should prefer the canonical fully-qualified form
+     * (`<integration>:<windowKey>`) — a future cadence collision would
+     * silently take the first match.
+     */
+    intervals?: Record<string, number>;
+    /** Global floor in seconds. Per-cadence soft floors still apply. */
+    minIntervalSeconds?: number;
+    /**
+     * Per-cadence opt-in flag. Default false (cadence dormant) — see
+     * `docs/design/appendices/delegated-sync-opt-in.md`. Keys are canonical
+     * fully-qualified `<integration>:<windowKey>` only; the legacy alias
+     * forms accepted by `intervals` are intentionally NOT honoured here so
+     * a future cadence collision cannot silently flip the wrong toggle.
+     */
+    cadenceEnabled?: Record<string, boolean>;
+    /**
+     * Shared active-hours window applied to every cadence. Local-time hours
+     * in the daemon's `timezone`; `[startHour, endHour)`. When unset, defaults
+     * to `[4, 24)` to mirror the Hourly Check window.
+     */
+    activeStartHour?: number;
+    activeEndHour?: number;
+}
+export interface DelegatedSyncCadenceContext {
+    /** Window bounds derived from `buildWindow(now)`. */
+    windowMin: string;
+    windowMax: string;
+    /** `now` snapshot used for window construction; identical to the
+     *  `fetchedAt` posted to reconcile. */
+    now: Date;
+    /** Calendar id from worker options. Calendar cadences forward this; gmail
+     *  and notion ignore it. */
+    calendarId: string;
+    /** Operator-tunable cap. Phase 1 used a per-cadence `maxResults` field;
+     *  Phase 5 generalises it through the context object so a future cadence
+     *  can drop the cap (Gemini Calendar `maxResults` is silently ignored
+     *  upstream — the arg is a hint). */
+    maxResults: number;
+}
+export interface DelegatedSyncToolCall {
+    /** Fully-qualified tool name (`<connector.toolNamespace><bare>`). */
+    toolName: string;
+    /** Tool args as the connector expects them. */
+    toolArgs: unknown;
+}
+export interface DelegatedSyncCadenceDefinition {
+    integration: IntegrationKey;
+    windowKey: string;
+    /**
+     * Short human-readable label for dashboard rendering (e.g. "Imminent
+     * events"). Stored alongside the structural fields so the cadence
+     * catalog stays self-describing — the dashboard doesn't have to keep a
+     * separate id-to-label map in sync.
+     */
+    displayName: string;
+    /** One-sentence rationale for the cadence (dashboard tooltip text). */
+    description: string;
+    defaultIntervalSeconds: number;
+    softFloorSeconds: number;
+    maxResults: number;
+    buildWindow(now: Date): {
+        windowMin: string;
+        windowMax: string;
+    };
+    /**
+     * Resolve the connector tool name + args for this cadence on a given
+     * backend. Returning a structure rather than positional args keeps the
+     * worker's tick loop integration-agnostic — calendar passes calendarId,
+     * gmail passes a Gmail search query, notion passes a search query +
+     * `created_date_range` filter.
+     */
+    buildToolCall(backendId: BackendId, ctx: DelegatedSyncCadenceContext): DelegatedSyncToolCall;
+    /**
+     * Pluck the raw item array from the connector's `toolResult`. Connectors
+     * wrap items under different keys (`events` for calendar list, `messages`
+     * / `threads` for gmail, `results` / `pages` for notion); the cadence
+     * definition owns the key list so adding a new cadence does not require
+     * touching the worker.
+     */
+    extractItems(toolResult: unknown): unknown[];
+}
+export interface DelegatedSyncCadenceStatus {
+    integration: IntegrationKey;
+    windowKey: string;
+    /** Per-cadence opt-in flag. Default false — see appendix. */
+    enabled: boolean;
+    /** Static catalog metadata; surfaced for the dashboard rendering layer. */
+    displayName: string;
+    description: string;
+    defaultIntervalSeconds: number;
+    softFloorSeconds: number;
+    intervalSeconds: number;
+    effectiveIntervalSeconds: number;
+    circuitState: "ok" | "tripped";
+    failureCount: number;
+    lastAttemptAt: string | null;
+    lastSuccessAt: string | null;
+    lastCompletedAt: string | null;
+    lastError: string | null;
+    nextRunAt: string | null;
+}
+export interface DelegatedSyncActiveHours {
+    startHour: number;
+    endHour: number;
+}
+export interface DelegatedSyncStatus {
+    workerRunning: boolean;
+    lastSuccessAt: string | null;
+    circuitState: "ok" | "tripped";
+    /**
+     * Shared active-hours window applied to every cadence. Defaults to
+     * `{startHour: 4, endHour: 24}` when the operator has not customised it.
+     * Out-of-window ticks return early; cadences don't accrue failureCount.
+     */
+    activeHours: DelegatedSyncActiveHours;
+    /**
+     * Whether the worker's most recent (or impending) tick falls inside
+     * `activeHours`. The dashboard surfaces this so the user can see at a
+     * glance whether the cadences are dormant due to time-of-day.
+     */
+    withinActiveHours: boolean;
+    cadences: Record<string, DelegatedSyncCadenceStatus>;
+    /**
+     * Operator-supplied `runtime_state.delegatedSync.intervals` keys that did
+     * not resolve to any known cadence id (canonical / dotted / window-only
+     * form per `resolveIntervalSeconds`). Surfaced through `/api/health` so
+     * the dashboard can flag a typo like `gmail:imminent` (no such cadence)
+     * before it silently falls through to defaults. Empty list means every
+     * configured key matched a cadence.
+     */
+    unrecognizedIntervalKeys: string[];
+    /**
+     * Cadence ids whose effective interval exceeds the agent-write TTL × 1.5
+     * boundary documented in INTEGRATION-DRIFT-DETECTION-PLAN.md §17.11. An
+     * operator-tunable cadence longer than this risks the agent's own writes
+     * being mis-attributed `actor='user'` on the next reconcile because the
+     * `integration_writes` mark expires before the worker re-fetches. Reported
+     * here so the dashboard / health endpoint can surface the violation; the
+     * worker continues to honour the configured cadence.
+     */
+    ttlContractViolations: Array<{
+        cadenceId: string;
+        intervalSeconds: number;
+        ttlSeconds: number;
+    }>;
+}
+/**
+ * Structured result for the dashboard's Run Now button. The four error
+ * codes match the four reasons a one-shot run can fail before reaching
+ * the connector. Connector-level failures (timeout / auth) flow through
+ * the normal cadence-failure code path and are reported via the next
+ * `getStatus()` snapshot.
+ */
+export type DelegatedSyncRunCadenceResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: "unknown_cadence" | "tick_in_progress" | "integration_not_delegated" | "integration_disabled";
+};
+export interface DelegatedSyncWorkerOptions {
+    db: Database.Database;
+    invoker: DelegatedBackendInvoker;
+    calendarId: string;
+    timezone?: string;
+    todayWriteLock?: TodayWriteLockManager;
+    triggerRoadmapRefresh?: (source: string, options?: {
+        bypassDedup?: boolean;
+    }) => void;
+    tickIntervalSeconds?: number;
+    now?: () => Date;
+    cadences?: readonly DelegatedSyncCadenceDefinition[];
+}
+export declare function hasActiveDelegatedSyncIntegration(db: Database.Database, override?: {
+    key: IntegrationKey;
+    state: import("@aitne/shared").IntegrationState;
+}): boolean;
+export declare class DelegatedSyncWorker implements Observer {
+    private readonly options;
+    readonly name = "delegated-sync";
+    private timer;
+    private tickRunning;
+    private readonly tickIntervalSeconds;
+    private readonly now;
+    private readonly cadences;
+    private readonly states;
+    constructor(options: DelegatedSyncWorkerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    tick(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    getStatus(now?: Date): DelegatedSyncStatus;
+    /**
+     * Hourly-check-driven refresh: fires any cadence whose integration is in
+     * delegated mode but whose per-cadence opt-in flag (`cadenceEnabled[id]`)
+     * is NOT `true`. Cadences the operator opted in run on their own
+     * user-set interval via the regular tick loop and are intentionally
+     * skipped here so we don't spend tokens twice for the same partition.
+     *
+     * Why this exists: when every cadence is disabled (the post-Phase-9
+     * default), Gmail / Notion observations would otherwise dry up entirely
+     * — the delegated `routine.hourly_check` task flow's Step 0a / 0c rely
+     * on `mail:lifecycle` / `notion:<db>` rows the worker writes server-
+     * side, and the agent prompt is explicitly told NOT to call the
+     * gmail / notion `/reconcile` route directly (would poison the worker's
+     * 7 d partition with a narrow window). This method makes the hourly
+     * check itself the producer for those partitions when the user has not
+     * opted into a per-cadence schedule.
+     *
+     * Active-hours are NOT consulted: this method runs only because the
+     * hourly check itself fired, which already passed `hourlyCheckActive*`
+     * gating. The cadence-side `activeStartHour` / `activeEndHour` window
+     * applies only to the worker's own 60 s tick.
+     *
+     * Cadences run in parallel — they target independent integrations and
+     * connector subprocesses, so wall-clock latency is bounded by the
+     * slowest single cadence rather than the sum. Serialised through the
+     * `tickRunning` mutex so the regular timer tick or a dashboard Run-Now
+     * click landing simultaneously doesn't double-spawn the same connector.
+     * Failures are caught per-cadence inside `runCadence` (failureCount /
+     * circuit-breaker) and surfaced through the next `getStatus()` snapshot;
+     * this method does not throw.
+     */
+    runDisabledCadencesForHourlyCheck(): Promise<void>;
+    /**
+     * Run a single cadence on demand (dashboard "Run Now" button). Bypasses
+     * `cadenceEnabled`, `cadenceDue`, and active-hours gating — the user
+     * explicitly asked for one-shot execution. The integration master switch
+     * (`delegatedSyncEnabled === false`) is still honoured because that's a
+     * kill switch, not a schedule.
+     *
+     * Serialised through `tickRunning` so a Run-Now click during the 60 s
+     * scheduled tick window doesn't double-spawn the same connector
+     * subprocess. Returns a structured failure code rather than throwing so
+     * the dashboard can render the four known reasons cleanly.
+     */
+    runCadenceNow(cadenceIdInput: string): Promise<DelegatedSyncRunCadenceResult>;
+    private runTick;
+    private runCadence;
+    private getState;
+    private readRuntimeConfig;
+    private resolveIntervalSeconds;
+    /**
+     * Phase 7 (h): rebuild per-cadence `lastAttemptAt` / `lastSuccessAt` from
+     * the most recent `delegated_sync` row in `agent_actions` so a daemon
+     * restart shortly after a successful sync does not re-spawn a subprocess
+     * for that cadence. Idempotent — re-running on an already-warm states
+     * map only overwrites with same-or-newer timestamps. Failures during
+     * hydration log warn and leave the cadence's state empty (which falls
+     * back to "due immediately", matching the prior force-on-start
+     * behaviour).
+     */
+    private hydrateStateFromHistory;
+    /**
+     * Phase 7 (g) + (c): emit a single warn at start when the operator's
+     * `runtime_state.delegatedSync.intervals` includes typo'd keys or when a
+     * resolved cadence violates the TTL × 1.5 contract. Both checks fire
+     * once per `start()` to avoid log spam; they are also exposed via
+     * `getStatus()` so the dashboard can surface them on-screen.
+     */
+    private warnOnConfigViolations;
+}
+/**
+ * Per-cadence opt-in check (delegated-sync-opt-in.md). Defaults to `false`
+ * when the operator hasn't set the flag, which means a fresh
+ * `runtime_state.delegatedSync` row keeps every cadence dormant. Canonical
+ * fully-qualified IDs only — the legacy alias forms accepted by `intervals`
+ * are intentionally not honoured here so a future cadence collision cannot
+ * silently flip the wrong toggle.
+ */
+declare function isCadenceEnabled(def: DelegatedSyncCadenceDefinition, runtimeConfig: DelegatedSyncRuntimeConfig): boolean;
+/**
+ * Resolve the active-hours window from operator config, falling back to
+ * the Hourly-Check-aligned default. A malformed or out-of-range pair (e.g.
+ * `start >= end`, or numbers outside `[0,24]`) is treated as "use defaults"
+ * — the worker can't usefully interpret an inverted window, and falling
+ * back keeps cadences running rather than silently disabling them.
+ */
+export declare function resolveActiveHours(runtimeConfig: DelegatedSyncRuntimeConfig): DelegatedSyncActiveHours;
+/**
+ * `true` when `now` falls inside `[startHour, endHour)` in the daemon's
+ * configured timezone. `endHour=24` is exclusive — i.e. covers up to
+ * 23:59:59. Mirrors the semantics of Hourly Check's window so an operator
+ * who already understands one understands the other.
+ */
+export declare function isWithinActiveHours(now: Date, timezone: string | undefined, activeHours: DelegatedSyncActiveHours): boolean;
+/**
+ * Build the alias set a runtime-config key may take and check operator-
+ * supplied keys against it. Three accepted forms:
+ *   - canonical fully-qualified (`google_calendar:primary:24h`)
+ *   - dotted human-friendly (`google_calendar.primary:24h`)
+ *   - integration-local (`primary:24h` — only unambiguous when the window
+ *     key is unique across cadences, which the §8.2 default set respects)
+ *
+ * Returns the sorted list of operator keys that match none of the three
+ * forms for any registered cadence. Sorted for stable assertions and
+ * stable health-endpoint output.
+ */
+declare function collectUnrecognizedIntervalKeys(cadences: readonly DelegatedSyncCadenceDefinition[], runtimeConfig: DelegatedSyncRuntimeConfig): string[];
+/**
+ * `agent_actions` stores `started_at` / `completed_at` as SQLite datetime
+ * (`YYYY-MM-DD HH:MM:SS`). Hydration converts them back to ISO 8601 to
+ * match the in-memory `CadenceRuntimeState` format. Returns `null` for an
+ * unparseable value so a malformed historical row does not poison the
+ * runtime state map.
+ */
+declare function sqliteDatetimeToIso(value: unknown): string | null;
+/**
+ * Resolve the fully-qualified tool name for `(integration, backendId, bareTool)`.
+ * Throws when the descriptor lacks a connector for the requested backend —
+ * defensive against an integration mode change racing the worker tick (the
+ * caller has already confirmed `delegatedBackend` resolves; this is the
+ * second-line check the descriptor lookup performs anyway).
+ */
+declare function namespacedTool(integration: IntegrationKey, backendId: BackendId, bareTool: string): string;
+declare function calendarListBareTool(backendId: BackendId): string;
+declare function extractItemsByKeys(value: unknown, keys: readonly string[]): unknown[];
+/**
+ * Per-backend Gmail search tool call. Each Codex / Claude / Gemini Gmail
+ * connector exposes a slightly different search API; this maps the
+ * cadence's intent (`newer_than:7d`, capped to `maxResults`) onto the
+ * connector's actual parameter names. The tool name resolves through
+ * `INTEGRATION_DESCRIPTORS.gmail.backendConnectors[backendId].toolNamespace`
+ * so namespace drift in the descriptor stays the single source of truth.
+ */
+declare function gmailSearchToolCall(backendId: BackendId, ctx: DelegatedSyncCadenceContext): DelegatedSyncToolCall;
+/**
+ * Per-backend Notion search tool call. All three connectors accept the
+ * same shape (`query`, `filters.created_date_range.start_date`, page-size
+ * cap), but the bare tool name differs: Codex strips the `notion-` prefix
+ * (`_search` vs `notion-search`).
+ */
+declare function notionSearchToolCall(backendId: BackendId, ctx: DelegatedSyncCadenceContext): DelegatedSyncToolCall;
+declare function isoDate(iso: string): string;
+export declare const __delegatedSyncWorkerTestExports: {
+    calendarListBareTool: typeof calendarListBareTool;
+    namespacedTool: typeof namespacedTool;
+    extractItemsByKeys: typeof extractItemsByKeys;
+    gmailSearchToolCall: typeof gmailSearchToolCall;
+    notionSearchToolCall: typeof notionSearchToolCall;
+    isoDate: typeof isoDate;
+    collectUnrecognizedIntervalKeys: typeof collectUnrecognizedIntervalKeys;
+    sqliteDatetimeToIso: typeof sqliteDatetimeToIso;
+    isCadenceEnabled: typeof isCadenceEnabled;
+    TTL_CONTRACT_RATIO: number;
+    CALENDAR_ITEM_KEYS: readonly ["events", "items", "calendarEvents"];
+    GMAIL_ITEM_KEYS: readonly ["threads", "messages", "items"];
+    NOTION_ITEM_KEYS: readonly ["results", "pages", "items"];
+    CALENDAR_IMMINENT_CADENCE: DelegatedSyncCadenceDefinition;
+    CALENDAR_24H_CADENCE: DelegatedSyncCadenceDefinition;
+    GMAIL_INBOX_7D_CADENCE: DelegatedSyncCadenceDefinition;
+    NOTION_RECENTLY_UPDATED_CADENCE: DelegatedSyncCadenceDefinition;
+    DEFAULT_ACTIVE_START_HOUR: number;
+    DEFAULT_ACTIVE_END_HOUR: number;
+};
+export {};
+//# sourceMappingURL=delegated-sync-worker.d.ts.map

package/dist/observers/delegated-sync-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegated-sync-worker.d.ts","sourceRoot":"","sources":["../../src/observers/delegated-sync-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAML,KAAK,SAAS,EACd,KAAK,cAAc,EAEpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAYzE,OAAO,KAAK,EACV,uBAAuB,EAExB,MAAM,0CAA0C,CAAC;AAMlD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI7C,eAAO,MAAM,4BAA4B,mBAAmB,CAAC;AAC7D,eAAO,MAAM,0BAA0B,2BAA2B,CAAC;AA+DnE,UAAU,0BAA0B;IAClC;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB;2CACuC;IACvC,GAAG,EAAE,IAAI,CAAC;IACV;gCAC4B;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB;;;yCAGqC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,8BAA8B;IAC7C,WAAW,EAAE,cAAc,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,GAAG,EAAE,IAAI,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACjE;;;;;;OAMG;IACH,aAAa,CACX,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,2BAA2B,GAC/B,qBAAqB,CAAC;IACzB;;;;;;OAMG;IACH,YAAY,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,CAAC;CAC9C;AAUD,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,cAAc,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,CAAC;IACjC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC;IAC/B;;;;OAIG;IACH,WAAW,EAAE,wBAAwB,CAAC;IACtC;;;;OAIG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACrD;;;;;;;OAOG;IACH,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC;;;;;;;;OAQG;IACH,qBAAqB,EAAE,KAAK,CAAC;QAC3B,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,MAAM,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAED;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,GACrC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IACA,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EACD,iBAAiB,GACjB,kBAAkB,GAClB,2BAA2B,GAC3B,sBAAsB,CAAC;CAC5B,CAAC;AAEJ,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC;IACtB,OAAO,EAAE,uBAAuB,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IACtF,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,QAAQ,CAAC,EAAE,SAAS,8BAA8B,EAAE,CAAC;CACtD;AA0HD,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,QAAQ,CAAC,EAAE;IAAE,GAAG,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,OAAO,eAAe,EAAE,gBAAgB,CAAA;CAAE,GAClF,OAAO,CAST;AAED,qBAAa,mBAAoB,YAAW,QAAQ;IAUtC,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,QAAQ,CAAC,IAAI,oBAAgC;IAE7C,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;gBAEpC,OAAO,EAAE,0BAA0B;IAO1D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkCtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrB,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5D,SAAS,CAAC,GAAG,GAAE,IAAiB,GAAG,mBAAmB;IA+EtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACG,iCAAiC,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CxD;;;;;;;;;;;OAWG;IACG,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,6BAA6B,CAAC;YAiCrE,OAAO;YA6DP,UAAU;IAqJxB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,sBAAsB;IAkB9B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAyC/B;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;CAkC/B;AAMD;;;;;;;GAOG;AACH,iBAAS,gBAAgB,CACvB,GAAG,EAAE,8BAA8B,EACnC,aAAa,EAAE,0BAA0B,GACxC,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,0BAA0B,GACxC,wBAAwB,CAkB1B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,WAAW,EAAE,wBAAwB,GACpC,OAAO,CAGT;AAcD;;;;;;;;;;;GAWG;AACH,iBAAS,+BAA+B,CACtC,QAAQ,EAAE,SAAS,8BAA8B,EAAE,EACnD,aAAa,EAAE,0BAA0B,GACxC,MAAM,EAAE,CAaV;AAED;;;;;;GAMG;AACH,iBAAS,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAS1D;AAiED;;;;;;GAMG;AACH,iBAAS,cAAc,CACrB,WAAW,EAAE,cAAc,EAC3B,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,MAAM,GACf,MAAM,CAUR;AAED,iBAAS,oBAAoB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAM1D;AAeD,iBAAS,kBAAkB,CACzB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,OAAO,EAAE,CAQX;AAgCD;;;;;;;GAOG;AACH,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,2BAA2B,GAC/B,qBAAqB,CAyBvB;AAED;;;;;GAKG;AACH,iBAAS,oBAAoB,CAC3B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,2BAA2B,GAC/B,qBAAqB,CAmBvB;AAED,iBAAS,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAcpC;AAiHD,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;CAoB5C,CAAC"}