@aitne/daemon 0.1.7 → 0.1.9

package/dist/observers/git-watcher.js

@@ -39,6 +39,7 @@ export class GitWatcher {
     onLifecycleObservation;
     repoEnvResolver;
     repoIntervals;
+    writeTracker;
     /** Per-row next-fire timestamp; `0` (or missing) means "due immediately". */
     nextFireAt = new Map();
     lastWebhookEventAt = 0;
@@ -60,6 +61,23 @@ export class GitWatcher {
         this.onLifecycleObservation = options.onLifecycleObservation ?? null;
         this.repoEnvResolver = options.repoEnvResolver ?? null;
         this.repoIntervals = options.repoIntervals ?? new Map();
+        this.writeTracker = options.writeTracker ?? null;
+    }
+    /**
+     * Resolve an observation's `actor` against the agent-commit tracker
+     * (C1). When the tracker has been notified that the daemon just
+     * committed `sha` to `repoPath`, the observation flips to
+     * `'agent'`; otherwise the historical fallback (`'user'` for local
+     * HEAD changes, `'unknown'` for remote-side events) is preserved so
+     * absence of the tracker is a strict no-op.
+     *
+     * Deletion-event sites pass no SHA — those keep the fallback
+     * verbatim.
+     */
+    resolveActor(repoPath, sha, fallback) {
+        if (!sha)
+            return fallback;
+        return this.writeTracker?.isAgentCommit(repoPath, sha) ? "agent" : fallback;
     }
     /**
      * Per-row scheduling gate (unified-repositories §5). Override is
@@ -118,11 +136,17 @@ export class GitWatcher {
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
         }
+        const interval = this.getCurrentInterval();
+        // Track the active interval so `maybeAdjustFrequency` doesn't re-restart on
+        // its next tick — without this, callers that go through `restartTimer`
+        // directly (e.g. `enableWebhookMode`) leave `lastUsedInterval` stale and
+        // cause one redundant restart per webhook transition.
+        this.lastUsedInterval = interval;
         this.pollTimer = setInterval(() => {
             void this.poll();
             // Check if we need to switch frequency
             this.maybeAdjustFrequency();
-        }, this.getCurrentInterval() * 1000);
+        }, interval * 1000);
     }
     lastUsedInterval = 0;
     maybeAdjustFrequency() {
@@ -224,7 +248,7 @@ export class GitWatcher {
                 source: `git:${repoPath}`,
                 ref: currentHash,
                 changeType: "modified",
-                actor: "user",
+                actor: this.resolveActor(repoPath, currentHash, "user"),
                 payload: {
                     repoPath,
                     commitHash: currentHash,
@@ -283,7 +307,7 @@ export class GitWatcher {
                     eventType: "git.branch.created",
                     ref: `branch_created:${branch}:${remoteHash}`,
                     changeType: "created",
-                    actor: "unknown",
+                    actor: this.resolveActor(repoPath, remoteHash, "unknown"),
                     payload: {
                         branch,
                         remoteHash,
@@ -317,7 +341,7 @@ export class GitWatcher {
                 eventType: "git.push.detected",
                 ref: `push:${branch}:${remoteHash}`,
                 changeType: "modified",
-                actor: "unknown",
+                actor: this.resolveActor(repoPath, remoteHash, "unknown"),
                 payload,
             });
             if (forcePushDetected) {
@@ -326,7 +350,7 @@ export class GitWatcher {
                     eventType: "git.push.force_pushed",
                     ref: `force_push:${branch}:${previousRemoteHash}->${remoteHash}`,
                     changeType: "modified",
-                    actor: "unknown",
+                    actor: this.resolveActor(repoPath, remoteHash, "unknown"),
                     payload,
                 });
             }
@@ -336,7 +360,7 @@ export class GitWatcher {
                     eventType: "git.merge_to_default",
                     ref: `merge_to_default:${branch}:${remoteHash}`,
                     changeType: "modified",
-                    actor: "unknown",
+                    actor: this.resolveActor(repoPath, remoteHash, "unknown"),
                     payload,
                 });
             }
@@ -344,6 +368,9 @@ export class GitWatcher {
         for (const [branch, previousRemoteHash] of previous.branches) {
             if (current.branches.has(branch))
                 continue;
+            // Branch deletion carries no SHA we can attribute back to a
+            // tracker mark — the previousRemoteHash describes what *was*
+            // deleted, not who deleted it. Stays "unknown" by design (C1).
             this.recordGitLifecycleObservation({
                 repoPath,
                 eventType: "git.branch.deleted",
@@ -367,7 +394,7 @@ export class GitWatcher {
                 eventType: "git.tag.created",
                 ref: `tag_created:${tag}:${tagHash}`,
                 changeType: "created",
-                actor: "unknown",
+                actor: this.resolveActor(repoPath, tagHash, "unknown"),
                 payload: {
                     tag,
                     tagHash,
@@ -378,6 +405,9 @@ export class GitWatcher {
         for (const [tag, previousTagHash] of previous.tags) {
             if (current.tags.has(tag))
                 continue;
+            // Tag deletion carries no SHA we can attribute back to a tracker
+            // mark — same reasoning as branch.deleted above. Stays "unknown"
+            // by design (C1).
             this.recordGitLifecycleObservation({
                 repoPath,
                 eventType: "git.tag.deleted",
@@ -452,7 +482,7 @@ export class GitWatcher {
                 eventType: "git.local_ahead.stale",
                 ref,
                 changeType: "modified",
-                actor: "user",
+                actor: this.resolveActor(repoPath, ahead.headHash, "user"),
                 payload: {
                     branch: ahead.branch,
                     upstreamRef: ahead.upstreamRef,
@@ -765,4 +795,3 @@ export function parseDefaultBranch(stdout) {
     }
     return null;
 }
-//# sourceMappingURL=git-watcher.js.map

package/dist/observers/github-poller-classifier.d.ts

@@ -98,4 +98,3 @@ export declare function parseGitHubRepoFullName(value: string): {
     repo: string;
     fullName: string;
 } | null;
-//# sourceMappingURL=github-poller-classifier.d.ts.map

package/dist/observers/github-poller-classifier.js

@@ -196,4 +196,3 @@ export function parseGitHubRepoFullName(value) {
         fullName: `${match[1]}/${match[2]}`,
     };
 }
-//# sourceMappingURL=github-poller-classifier.js.map

package/dist/observers/github-poller.d.ts

@@ -215,6 +215,9 @@ export declare class GitHubPoller implements Observer {
     private isRepoDue;
     private markRepoFired;
     private handlePollError;
+    private static readonly NETWORK_POLL_ERROR_PATTERN;
+    /** Visible for testing — see the WARN branch in `handlePollError`. */
+    static isNetworkPollError(message: string): boolean;
     private pollNotifications;
     private pollWorkflowRuns;
     /**
@@ -288,4 +291,3 @@ export declare function isObservationFresh(db: Database.Database, source: string
  * Exported for tests.
  */
 export declare function isWorkflowRepoCold(db: Database.Database, repoFullName: string): boolean;
-//# sourceMappingURL=github-poller.d.ts.map

package/dist/observers/github-poller.js

@@ -211,10 +211,26 @@ export class GitHubPoller {
         else if (message.includes("rate limit") || message.includes("429")) {
             logger.warn({ scope, consecutiveFailures: this.consecutiveFailures, skipRemaining: this.skipRemaining }, "GitHub rate limited — backing off");
         }
+        else if (GitHubPoller.isNetworkPollError(message)) {
+            // Connectivity failures (offline laptop, DNS hiccup, TCP reset) are
+            // environmental, not faults — the poller already absorbs them with the
+            // exponential backoff above, so they belong at WARN alongside the auth /
+            // rate-limit branches. Logging them at ERROR floods the error stream
+            // every time wifi drops or the machine sleeps (it was the github
+            // poller's dominant error-log line). Matches the `gh` CLI's "error
+            // connecting to ..." message and the Go net/transport errors `gh api`
+            // surfaces.
+            logger.warn({ scope, consecutiveFailures: this.consecutiveFailures, skipRemaining: this.skipRemaining }, "GitHub poll failed (network) — likely offline; backing off.");
+        }
         else {
             logger.error({ scope, err, consecutiveFailures: this.consecutiveFailures, skipRemaining: this.skipRemaining }, "GitHub poll failed — backing off");
         }
     }
+    static NETWORK_POLL_ERROR_PATTERN = /connecting to|check your internet|dial tcp|read tcp|write tcp|i\/o timeout|no such host|network is unreachable|connection refused|connection reset|tls handshake|timeout/i;
+    /** Visible for testing — see the WARN branch in `handlePollError`. */
+    static isNetworkPollError(message) {
+        return GitHubPoller.NETWORK_POLL_ERROR_PATTERN.test(message);
+    }
     async pollNotifications() {
         const lastEtag = readRuntimeState(this.db, NOTIF_ETAG_KEY);
         const lastModified = readRuntimeState(this.db, NOTIF_LAST_MODIFIED_KEY);
@@ -331,12 +347,22 @@ export class GitHubPoller {
             payload: classification.payload,
         });
         if (classification.emitEvent && isFresh) {
-            this.eventBus.put(createEvent({
+            // `eventBus.put` is async; fire-and-forget but explicitly handle
+            // rejection so a queue-eviction failure can't surface as an unhandled
+            // promise rejection (which would crash the daemon under Node's default
+            // `--unhandled-rejections=throw`).
+            void this.eventBus.put(createEvent({
                 type: classification.eventType,
                 source: "github-poller",
                 priority: classification.priority,
                 data: classification.payload,
-            }));
+            })).catch((err) => {
+                logger.error({
+                    err,
+                    eventType: classification.eventType,
+                    ref: classification.ref,
+                }, "Failed to emit GitHub event");
+            });
             logger.info({
                 eventType: classification.eventType,
                 priority: EventPriority[classification.priority],
@@ -606,4 +632,3 @@ export function isWorkflowRepoCold(db, repoFullName) {
         .get(`github:workflow:${repoFullName}`);
     return row === undefined;
 }
-//# sourceMappingURL=github-poller.js.map

package/dist/observers/imminent-event-scheduler.d.ts

@@ -39,9 +39,10 @@ export declare class ImminentEventScheduler implements Observer {
     private readonly now;
     readonly name = "imminent-event-scheduler";
     private timer;
+    private readonly guard;
     constructor(db: Database.Database, eventBus: EventBus, calendarId: string, intervalSeconds?: number, now?: () => Date);
     start(): Promise<void>;
     stop(): Promise<void>;
     tick(): Promise<void>;
+    private runTick;
 }
-//# sourceMappingURL=imminent-event-scheduler.d.ts.map

package/dist/observers/imminent-event-scheduler.js

@@ -1,6 +1,17 @@
 import { createEvent, EventPriority, } from "@aitne/shared";
 import { createLogger } from "../logging.js";
+import { PollGuard } from "./poll-guard.js";
 const logger = createLogger("imminent-event-scheduler");
+/**
+ * Wall-clock cap per tick. The tick is mostly synchronous SQLite + a
+ * handful of `eventBus.put` calls (in-process). A 30s cap is far above
+ * the healthy upper bound (sub-second) but tight enough that two
+ * consecutive ticks at the default 60s cadence cannot stack into the
+ * next interval. PollGuard's overlap guard is the primary defense; the
+ * timeout is the safety net for `eventBus.put` blocking on a full heap
+ * during sustained bursts.
+ */
+const TICK_TIMEOUT_MS = 30_000;
 function extractCalendarPayload(parsed) {
     // Observation `raw.title` wins for native rows; snapshot `summary` wins
     // for direct / delegated rows. The two writers never produce both keys,
@@ -49,6 +60,10 @@ export class ImminentEventScheduler {
     now;
     name = "imminent-event-scheduler";
     timer = null;
+    guard = new PollGuard({
+        name: "imminent-event-scheduler",
+        tickTimeoutMs: TICK_TIMEOUT_MS,
+    });
     constructor(db, eventBus, calendarId, intervalSeconds = 60, now = () => new Date()) {
         this.db = db;
         this.eventBus = eventBus;
@@ -66,9 +81,18 @@ export class ImminentEventScheduler {
             clearInterval(this.timer);
             this.timer = null;
         }
+        this.guard.abortInFlight(new Error("imminent_event_scheduler_stopped"));
         logger.info("Imminent event scheduler stopped");
     }
     async tick() {
+        try {
+            await this.guard.run((signal) => this.runTick(signal));
+        }
+        catch (err) {
+            logger.error({ err }, "Imminent event scheduler tick failed");
+        }
+    }
+    async runTick(signal) {
         const now = this.now();
         const max = new Date(now.getTime() + 15 * 60 * 1000);
         const nowIso = now.toISOString();
@@ -87,7 +111,7 @@ export class ImminentEventScheduler {
         // consumed (the pending-observations filter). Direct/delegated
         // snapshots have no consumed_at column — the writer reconciles
         // in-place, so the snapshot row always reflects the current state.
-        // Timestamp normalisation rationale (Issue A1, 2026-05-13).
+        // Timestamp normalisation rationale:
         //
         // Snapshot path: the writer normalises `item_start` to UTC ISO with
         // Z suffix via `normalizeTimeForRange` (integrations-snapshot.ts)
@@ -172,6 +196,11 @@ export class ImminentEventScheduler {
         // commits. Track item_ids in-loop and skip the second occurrence.
         const seen = new Set();
         for (const row of rows) {
+            // PollGuard's tick-timeout (or observer stop) — drop out cleanly
+            // mid-row so we don't keep emitting after the tick window has
+            // already expired.
+            if (signal.aborted)
+                return;
             if (seen.has(row.item_id))
                 continue;
             seen.add(row.item_id);
@@ -227,4 +256,3 @@ export class ImminentEventScheduler {
         }
     }
 }
-//# sourceMappingURL=imminent-event-scheduler.js.map

package/dist/observers/mail-poller.d.ts

@@ -137,4 +137,3 @@ export declare class MailPoller implements Observer {
     private handlePollError;
     private maybeSendReconsentDm;
 }
-//# sourceMappingURL=mail-poller.d.ts.map

package/dist/observers/mail-poller.js

@@ -249,7 +249,7 @@ export class MailPoller {
      */
     upsertMessages(accountId, messages) {
         if (messages.length === 0)
-            return;
+            return true;
         const nowIso = new Date().toISOString();
         const upsert = this.db.prepare(`INSERT INTO mail_messages_index (
          account_id, provider_msg_id, rfc822_msg_id, thread_id, folder,
@@ -280,14 +280,16 @@ export class MailPoller {
         });
         try {
             tx(messages);
+            return true;
         }
         catch (err) {
             logger.error({ err, accountId, count: messages.length }, "Failed to upsert mail_messages_index rows");
+            return false;
         }
     }
     softDeleteRemovedIds(accountId, providerMsgIds) {
         if (providerMsgIds.length === 0)
-            return;
+            return true;
         const uniqueIds = [...new Set(providerMsgIds)];
         const nowIso = new Date().toISOString();
         const update = this.db.prepare(`UPDATE mail_messages_index
@@ -300,9 +302,11 @@ export class MailPoller {
         });
         try {
             tx(uniqueIds);
+            return true;
         }
         catch (err) {
             logger.error({ err, accountId, removedCount: uniqueIds.length }, "Failed to soft-delete removed mail rows");
+            return false;
         }
     }
     async pollAccountSerialized(account) {
@@ -349,9 +353,6 @@ export class MailPoller {
             });
             return;
         }
-        // Successful pass: persist cursor + reset error counter.
-        if (cursor)
-            this.registry.savePollCursor(account.id, cursor);
         this.registry.recordPollTick(account.id, { success: true });
         // Forget prior re-consent DM cadence so a future failure can DM immediately
         // instead of silently waiting out `mailAuthFailureRetryHours` (§V3).
@@ -379,14 +380,41 @@ export class MailPoller {
         // deletion reconcile have something to work against. Idempotent on
         // (account_id, provider_msg_id); the AFTER INSERT trigger keeps
         // `fts_mail_messages` in sync.
-        this.upsertMessages(account.id, userMessages);
+        const upsertOk = this.upsertMessages(account.id, userMessages);
         // Classify + ingest travel_bookings / kindle_notebook / parse_failures
         // through the shared pipeline — identical rules as the prior Gmail-only
         // observer path. Receipt detection now flows through the same attachment
         // metadata surface for providers that expose it.
         const ingestion = await this.ingestClassified(account, provider, userMessages);
-        this.softDeleteRemovedIds(account.id, removedAggregated);
-        if (userMessages.length > 0 || removedAggregated.length > 0) {
+        const softDeleteOk = this.softDeleteRemovedIds(account.id, removedAggregated);
+        // Persist the cursor only AFTER local writes complete. A crash or DB
+        // failure between `pollSince` and `upsertMessages` would otherwise
+        // advance the cursor and silently drop the in-flight batch. Re-fetching
+        // is idempotent via UNIQUE(account_id, provider_msg_id), so the worst
+        // case on retry is a re-classification pass — no data loss.
+        if (cursor && upsertOk && softDeleteOk) {
+            this.registry.savePollCursor(account.id, cursor);
+        }
+        else if (cursor && (!upsertOk || !softDeleteOk)) {
+            logger.warn({
+                accountId: account.id,
+                upsertOk,
+                softDeleteOk,
+            }, "Skipping mail poll cursor save — local writes failed; next tick will re-fetch");
+        }
+        // Observe only what actually landed in local state. If upsert failed,
+        // `mail_messages_index` has no row for the provider's reported
+        // `userMessages` — emitting the observation anyway would tell the
+        // hourly-check signal compute (and downstream skill flows) that N new
+        // mails exist, and the agent would then query the index and find
+        // zero. Worse: when the next tick retries the upsert successfully it
+        // emits a second observation, double-counting the same batch. Gate
+        // the observation on the actual persistence outcome so the count
+        // reflects what is queryable, and zero out parts that failed to
+        // commit so the payload never points at phantom rows.
+        const hasNew = upsertOk && userMessages.length > 0;
+        const hasRemoved = softDeleteOk && removedAggregated.length > 0;
+        if (hasNew || hasRemoved) {
             recordObservation(this.db, {
                 source: "mail:lifecycle",
                 ref: `${account.id}-${Date.now()}`,
@@ -403,10 +431,12 @@ export class MailPoller {
                     accountId: account.id,
                     kind: account.kind,
                     email: account.email,
-                    newMessages: userMessages.length,
-                    removedMessages: removedAggregated.length,
-                    subjects: userMessages.slice(0, 5).map((m) => m.subject ?? "(no subject)"),
-                    fromAgentSuppressed: aggregated.length - userMessages.length,
+                    newMessages: hasNew ? userMessages.length : 0,
+                    removedMessages: hasRemoved ? removedAggregated.length : 0,
+                    subjects: hasNew
+                        ? userMessages.slice(0, 5).map((m) => m.subject ?? "(no subject)")
+                        : [],
+                    fromAgentSuppressed: hasNew ? aggregated.length - userMessages.length : 0,
                     travelBookings: ingestion.travelBookingsInserted,
                     receipts: ingestion.receiptsDetected,
                     kindleBooksCreated: ingestion.kindleBooksCreated,
@@ -487,11 +517,9 @@ export class MailPoller {
             : typeof err?.code === "string"
                 ? err.code
                 : null;
-        const gmailReason = 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        err?.response?.data?.error?.errors?.[0]?.reason ??
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            err?.errors?.[0]?.reason ??
+        const gmailErr = err;
+        const gmailReason = gmailErr?.response?.data?.error?.errors?.[0]?.reason ??
+            gmailErr?.errors?.[0]?.reason ??
             null;
         // ImapFlow IMAP errors don't carry a numeric responseCode; extract it
         // separately from the error object (distinct from httpStatus which is
@@ -582,4 +610,3 @@ function hasIdleSupport(provider) {
         "stopIdle" in provider &&
         typeof provider.stopIdle === "function");
 }
-//# sourceMappingURL=mail-poller.js.map

package/dist/observers/mail-reconciliation.d.ts

@@ -1,5 +1,5 @@
 /**
- * Mail reconciliation observer (Phase 7, §3.1.1).
+ * Mail reconciliation observer (see appendices/multi-mail-provider.md §3.1.1).
  *
  * Two responsibilities, both run on a daily cadence and both kept out of the
  * real-time {@link MailPoller} path so their slower failure modes don't
@@ -84,4 +84,3 @@ export declare class MailReconciliationJob implements Observer {
     private loadLocalMessages;
     private runPurge;
 }
-//# sourceMappingURL=mail-reconciliation.d.ts.map

package/dist/observers/mail-reconciliation.js

@@ -1,5 +1,5 @@
 /**
- * Mail reconciliation observer (Phase 7, §3.1.1).
+ * Mail reconciliation observer (see appendices/multi-mail-provider.md §3.1.1).
  *
  * Two responsibilities, both run on a daily cadence and both kept out of the
  * real-time {@link MailPoller} path so their slower failure modes don't
@@ -238,4 +238,3 @@ export class MailReconciliationJob {
         }
     }
 }
-//# sourceMappingURL=mail-reconciliation.js.map

package/dist/observers/manager.d.ts

@@ -38,14 +38,14 @@ export type StopAndUnregisterResult = {
  * - ObsidianWatcher (chokidar file system events)
  * - GitWatcher (git log polling)
  * - CalendarPoller (Google Calendar API polling)
- * - NotionPoller (Notion API polling, Phase 3)
+ * - NotionPoller (Notion API polling)
  */
 export declare class ObserverManager {
     private readonly observers;
     /**
-     * Management Mode Phase 2: pause-state tracks which observers were
-     * running at the moment `pauseAll()` was invoked so `resumeAll()` only
-     * restarts the ones it stopped — not observers that the user had
+     * Pause-state tracks which observers were running at the moment
+     * `pauseAll()` was invoked so `resumeAll()` only restarts the ones it
+     * stopped — not observers that the user had
      * already disabled or that failed to start in the first place. A set
      * of names is enough because each observer's identity is its name.
      */
@@ -54,9 +54,9 @@ export declare class ObserverManager {
     startAll(): Promise<void>;
     stopAll(): Promise<void>;
     /**
-     * Management Mode Phase 2 migration hook — stops every registered
-     * observer and remembers the set so `resumeAll()` can restart exactly
-     * those observers once the migration commits or rolls back.
+     * Migration hook — stops every registered observer and remembers the
+     * set so `resumeAll()` can restart exactly those observers once the
+     * migration commits or rolls back.
      *
      * Idempotent: a second `pauseAll()` before `resumeAll()` is a no-op
      * and preserves the original paused set. The migration endpoint uses
@@ -96,4 +96,3 @@ export declare class ObserverManager {
      */
     stopAndUnregister(name: string): Promise<StopAndUnregisterResult>;
 }
-//# sourceMappingURL=manager.d.ts.map

package/dist/observers/manager.js

@@ -7,14 +7,14 @@ const logger = createLogger("observer-manager");
  * - ObsidianWatcher (chokidar file system events)
  * - GitWatcher (git log polling)
  * - CalendarPoller (Google Calendar API polling)
- * - NotionPoller (Notion API polling, Phase 3)
+ * - NotionPoller (Notion API polling)
  */
 export class ObserverManager {
     observers = [];
     /**
-     * Management Mode Phase 2: pause-state tracks which observers were
-     * running at the moment `pauseAll()` was invoked so `resumeAll()` only
-     * restarts the ones it stopped — not observers that the user had
+     * Pause-state tracks which observers were running at the moment
+     * `pauseAll()` was invoked so `resumeAll()` only restarts the ones it
+     * stopped — not observers that the user had
      * already disabled or that failed to start in the first place. A set
      * of names is enough because each observer's identity is its name.
      */
@@ -43,9 +43,9 @@ export class ObserverManager {
         }
     }
     /**
-     * Management Mode Phase 2 migration hook — stops every registered
-     * observer and remembers the set so `resumeAll()` can restart exactly
-     * those observers once the migration commits or rolls back.
+     * Migration hook — stops every registered observer and remembers the
+     * set so `resumeAll()` can restart exactly those observers once the
+     * migration commits or rolls back.
      *
      * Idempotent: a second `pauseAll()` before `resumeAll()` is a no-op
      * and preserves the original paused set. The migration endpoint uses
@@ -151,4 +151,3 @@ export class ObserverManager {
         return { status: "removed" };
     }
 }
-//# sourceMappingURL=manager.js.map

package/dist/observers/notion-poller.d.ts

@@ -28,9 +28,11 @@ export declare class NotionPoller implements Observer {
     private readonly db;
     private readonly writeTracker?;
     private timer;
+    private readonly guard;
     constructor(opts: NotionPollerOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
+    private tick;
     private pollAll;
     /** Poll one data source: active pages (by last_edited_time), then trashed pages. */
     private pollDatabase;
@@ -40,4 +42,3 @@ export declare class NotionPoller implements Observer {
 export declare function extractPropertySummary(page: {
     properties?: Record<string, Record<string, unknown>>;
 }): string;
-//# sourceMappingURL=notion-poller.d.ts.map