@aitne/daemon 0.1.7 → 0.1.9

package/dist/db/browser-task-store.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Browser-task row store — BROWSER_TASK_REDESIGN_PLAN.md §6.4.
+ *
+ * I/O-bound CRUD over `browser_task`. The state machine itself (§4) is
+ * enforced at this layer via the CHECK constraint on the `state` column
+ * (closed set) plus the per-transition helpers below — `markRunning`,
+ * `markAwaitingUser`, `markFinalConfirm`, `markCompleted`,
+ * `markTerminal` — each one's WHERE clause refuses an out-of-order
+ * write so a race between two writers cannot flip a row backwards.
+ *
+ * Pure decision logic (state-machine guards, queue arithmetic) lives in
+ * `services/browser-task/browser-task-slots.ts` and is the 100%-covered
+ * surface; this module is the SQL wrapper and is excluded from the
+ * coverage gate (same posture as `browser-automation-purchase-tokens-store.ts`).
+ */
+import type Database from "better-sqlite3";
+export type BrowserTaskState = "pending" | "running" | "awaiting_user" | "final_confirm" | "completed" | "failed" | "timeout" | "cancelled" | "abandoned";
+export declare const BROWSER_TASK_TERMINAL_STATES: ReadonlySet<BrowserTaskState>;
+export declare const BROWSER_TASK_NON_TERMINAL_STATES: ReadonlySet<BrowserTaskState>;
+export interface BrowserTaskRow {
+    id: string;
+    description: string;
+    siteKey: string | null;
+    extraAllowedHosts: readonly string[];
+    originatingChannel: string | null;
+    scheduleRowId: number | null;
+    requireFinalConfirm: boolean;
+    state: BrowserTaskState;
+    outcomeDetail: string | null;
+    report: string | null;
+    effectiveAllowlistRegex: string | null;
+    blockedRequestsCount: number;
+    extractCharsTotal: number;
+    createdAt: number;
+    startedAt: number | null;
+    finishedAt: number | null;
+}
+export interface CreateBrowserTaskInput {
+    id: string;
+    description: string;
+    siteKey: string | null;
+    extraAllowedHosts: readonly string[];
+    originatingChannel: string | null;
+    scheduleRowId: number | null;
+    requireFinalConfirm: boolean;
+    effectiveAllowlistRegex: string | null;
+    createdAt: number;
+}
+/** Insert a fresh row in state=pending. The slot manager promotes it
+ *  to `running` once a slot frees. */
+export declare function createBrowserTask(db: Database.Database, input: CreateBrowserTaskInput): BrowserTaskRow;
+export declare function getBrowserTask(db: Database.Database, id: string): BrowserTaskRow | null;
+export interface ListBrowserTasksOptions {
+    states?: readonly BrowserTaskState[];
+    siteKey?: string | null;
+    limit?: number;
+    offset?: number;
+}
+export declare function listBrowserTasks(db: Database.Database, options?: ListBrowserTasksOptions): readonly BrowserTaskRow[];
+export declare function countBrowserTasks(db: Database.Database, options?: ListBrowserTasksOptions): number;
+/** Pending → running. CAS on prior state so a concurrent terminal
+ *  transition (cancel-while-pending → cancelled) does not get clobbered.
+ *  Returns the new row or null on CAS miss. */
+export declare function markRunning(db: Database.Database, id: string, startedAt: number): BrowserTaskRow | null;
+/** Running → awaiting_user. Slot stays held; resume via /clarify. */
+export declare function markAwaitingUser(db: Database.Database, id: string): BrowserTaskRow | null;
+/** Running → final_confirm. Slot stays held; resume via token. */
+export declare function markFinalConfirm(db: Database.Database, id: string): BrowserTaskRow | null;
+/** Parked state → running. Used by /clarify resume and token-consume
+ *  resume. Either parked state is acceptable. */
+export declare function markRunningFromParked(db: Database.Database, id: string): BrowserTaskRow | null;
+export interface TerminalTransitionInput {
+    id: string;
+    state: "completed" | "failed" | "timeout" | "cancelled" | "abandoned";
+    outcomeDetail: string | null;
+    report: string | null;
+    finishedAt: number;
+}
+/** Any non-terminal state → terminal. Idempotent — re-running on an
+ *  already-terminal row CAS-misses and returns null. */
+export declare function markTerminal(db: Database.Database, input: TerminalTransitionInput): BrowserTaskRow | null;
+/** Increment the per-task CDP-blocked counter. Atomic. */
+export declare function incrementBlockedRequests(db: Database.Database, id: string, by: number): void;
+/** Increment the per-task cumulative untrusted-content counter. */
+export declare function incrementExtractChars(db: Database.Database, id: string, by: number): void;
+/**
+ * §6.5 boot-recovery sweep — flip every non-terminal row to
+ * (failed, 'daemon_restarted', finishedAt) on boot, before the
+ * dispatcher starts consuming events.
+ *
+ * Pure SQL UPDATE; returns the affected row count and the ids that
+ * were flipped so the caller can fan out one DM per row to the
+ * persisted `originating_channel`.
+ */
+export declare function sweepNonTerminalRowsForBootRecovery(db: Database.Database, nowMs: number): readonly {
+    id: string;
+    originatingChannel: string | null;
+}[];
+/**
+ * Retention prune for terminal `browser_task` rows older than `cutoffMs`
+ * (BROWSER_TASK_REDESIGN_PLAN.md §6.5 deferred follow-up + §14.7 — the
+ * trace-store window is 30 days; the SQL row lifetime matches so the
+ * dashboard never renders a row whose screenshots are 404). Children in
+ * `browser_task_action_log`, `browser_task_clarifications`, and
+ * `browser_task_final_confirm_tokens` go with the parent via the
+ * ON DELETE CASCADE FK declared in `schema.ts`.
+ *
+ * Non-terminal rows are NEVER deleted (the boot-recovery sweep is the
+ * sole path that mutates them after their owner's daemon-restart).
+ * `finished_at` is the lifetime anchor — for the few terminal
+ * transitions where the runner failed to set it (defensive), we fall
+ * back to `created_at` to avoid stranding rows.
+ */
+export declare function deleteTerminalBrowserTasksOlderThan(db: Database.Database, cutoffMs: number): number;

package/dist/db/browser-task-store.js

@@ -0,0 +1,250 @@
+/**
+ * Browser-task row store — BROWSER_TASK_REDESIGN_PLAN.md §6.4.
+ *
+ * I/O-bound CRUD over `browser_task`. The state machine itself (§4) is
+ * enforced at this layer via the CHECK constraint on the `state` column
+ * (closed set) plus the per-transition helpers below — `markRunning`,
+ * `markAwaitingUser`, `markFinalConfirm`, `markCompleted`,
+ * `markTerminal` — each one's WHERE clause refuses an out-of-order
+ * write so a race between two writers cannot flip a row backwards.
+ *
+ * Pure decision logic (state-machine guards, queue arithmetic) lives in
+ * `services/browser-task/browser-task-slots.ts` and is the 100%-covered
+ * surface; this module is the SQL wrapper and is excluded from the
+ * coverage gate (same posture as `browser-automation-purchase-tokens-store.ts`).
+ */
+export const BROWSER_TASK_TERMINAL_STATES = new Set(["completed", "failed", "timeout", "cancelled", "abandoned"]);
+export const BROWSER_TASK_NON_TERMINAL_STATES = new Set(["pending", "running", "awaiting_user", "final_confirm"]);
+function fromDbRow(row) {
+    let hosts = [];
+    if (row.extra_allowed_hosts_json) {
+        try {
+            const parsed = JSON.parse(row.extra_allowed_hosts_json);
+            hosts = Array.isArray(parsed)
+                ? parsed.filter((v) => typeof v === "string")
+                : [];
+        }
+        catch {
+            hosts = [];
+        }
+    }
+    return {
+        id: row.id,
+        description: row.description,
+        siteKey: row.site_key,
+        extraAllowedHosts: hosts,
+        originatingChannel: row.originating_channel,
+        scheduleRowId: row.schedule_row_id,
+        requireFinalConfirm: row.require_final_confirm === 1,
+        state: row.state,
+        outcomeDetail: row.outcome_detail,
+        report: row.report,
+        effectiveAllowlistRegex: row.effective_allowlist_regex,
+        blockedRequestsCount: row.blocked_requests_count,
+        extractCharsTotal: row.extract_chars_total,
+        createdAt: row.created_at,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+    };
+}
+/** Insert a fresh row in state=pending. The slot manager promotes it
+ *  to `running` once a slot frees. */
+export function createBrowserTask(db, input) {
+    db.prepare(`INSERT INTO browser_task
+       (id, description, site_key, extra_allowed_hosts_json,
+        originating_channel, schedule_row_id, require_final_confirm,
+        state, outcome_detail, report, effective_allowlist_regex,
+        blocked_requests_count, extract_chars_total,
+        created_at, started_at, finished_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, 0, 0, ?, NULL, NULL)`).run(input.id, input.description, input.siteKey, JSON.stringify([...input.extraAllowedHosts]), input.originatingChannel, input.scheduleRowId, input.requireFinalConfirm ? 1 : 0, input.effectiveAllowlistRegex, input.createdAt);
+    const row = getBrowserTask(db, input.id);
+    if (!row) {
+        throw new Error(`createBrowserTask: post-insert row for ${input.id} missing`);
+    }
+    return row;
+}
+export function getBrowserTask(db, id) {
+    const row = db
+        .prepare(`SELECT id, description, site_key, extra_allowed_hosts_json,
+              originating_channel, schedule_row_id, require_final_confirm,
+              state, outcome_detail, report, effective_allowlist_regex,
+              blocked_requests_count, extract_chars_total,
+              created_at, started_at, finished_at
+         FROM browser_task
+        WHERE id = ?`)
+        .get(id);
+    return row ? fromDbRow(row) : null;
+}
+export function listBrowserTasks(db, options = {}) {
+    const { states, siteKey, limit = 50, offset = 0 } = options;
+    const where = [];
+    const params = [];
+    if (states && states.length > 0) {
+        where.push(`state IN (${states.map(() => "?").join(", ")})`);
+        params.push(...states);
+    }
+    if (siteKey !== undefined) {
+        if (siteKey === null) {
+            where.push("site_key IS NULL");
+        }
+        else {
+            where.push("site_key = ?");
+            params.push(siteKey);
+        }
+    }
+    const sql = `SELECT id, description, site_key, extra_allowed_hosts_json,
+                      originating_channel, schedule_row_id, require_final_confirm,
+                      state, outcome_detail, report, effective_allowlist_regex,
+                      blocked_requests_count, extract_chars_total,
+                      created_at, started_at, finished_at
+                 FROM browser_task
+               ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+               ORDER BY created_at DESC
+               LIMIT ? OFFSET ?`;
+    params.push(limit, offset);
+    const rows = db
+        .prepare(sql)
+        .all(...params);
+    return rows.map(fromDbRow);
+}
+export function countBrowserTasks(db, options = {}) {
+    const { states, siteKey } = options;
+    const where = [];
+    const params = [];
+    if (states && states.length > 0) {
+        where.push(`state IN (${states.map(() => "?").join(", ")})`);
+        params.push(...states);
+    }
+    if (siteKey !== undefined) {
+        if (siteKey === null) {
+            where.push("site_key IS NULL");
+        }
+        else {
+            where.push("site_key = ?");
+            params.push(siteKey);
+        }
+    }
+    const sql = `SELECT COUNT(*) AS c
+                 FROM browser_task
+               ${where.length ? `WHERE ${where.join(" AND ")}` : ""}`;
+    const row = db.prepare(sql).get(...params);
+    return row?.c ?? 0;
+}
+/** Pending → running. CAS on prior state so a concurrent terminal
+ *  transition (cancel-while-pending → cancelled) does not get clobbered.
+ *  Returns the new row or null on CAS miss. */
+export function markRunning(db, id, startedAt) {
+    const result = db
+        .prepare(`UPDATE browser_task
+          SET state = 'running', started_at = ?
+        WHERE id = ? AND state = 'pending'`)
+        .run(startedAt, id);
+    return result.changes > 0 ? getBrowserTask(db, id) : null;
+}
+/** Running → awaiting_user. Slot stays held; resume via /clarify. */
+export function markAwaitingUser(db, id) {
+    const result = db
+        .prepare(`UPDATE browser_task
+          SET state = 'awaiting_user'
+        WHERE id = ? AND state = 'running'`)
+        .run(id);
+    return result.changes > 0 ? getBrowserTask(db, id) : null;
+}
+/** Running → final_confirm. Slot stays held; resume via token. */
+export function markFinalConfirm(db, id) {
+    const result = db
+        .prepare(`UPDATE browser_task
+          SET state = 'final_confirm'
+        WHERE id = ? AND state = 'running'`)
+        .run(id);
+    return result.changes > 0 ? getBrowserTask(db, id) : null;
+}
+/** Parked state → running. Used by /clarify resume and token-consume
+ *  resume. Either parked state is acceptable. */
+export function markRunningFromParked(db, id) {
+    const result = db
+        .prepare(`UPDATE browser_task
+          SET state = 'running'
+        WHERE id = ? AND state IN ('awaiting_user', 'final_confirm')`)
+        .run(id);
+    return result.changes > 0 ? getBrowserTask(db, id) : null;
+}
+/** Any non-terminal state → terminal. Idempotent — re-running on an
+ *  already-terminal row CAS-misses and returns null. */
+export function markTerminal(db, input) {
+    const result = db
+        .prepare(`UPDATE browser_task
+          SET state = ?,
+              outcome_detail = ?,
+              report = COALESCE(?, report),
+              finished_at = ?
+        WHERE id = ?
+          AND state IN ('pending', 'running', 'awaiting_user', 'final_confirm')`)
+        .run(input.state, input.outcomeDetail, input.report, input.finishedAt, input.id);
+    return result.changes > 0 ? getBrowserTask(db, input.id) : null;
+}
+/** Increment the per-task CDP-blocked counter. Atomic. */
+export function incrementBlockedRequests(db, id, by) {
+    db.prepare(`UPDATE browser_task
+        SET blocked_requests_count = blocked_requests_count + ?
+      WHERE id = ?`).run(by, id);
+}
+/** Increment the per-task cumulative untrusted-content counter. */
+export function incrementExtractChars(db, id, by) {
+    db.prepare(`UPDATE browser_task
+        SET extract_chars_total = extract_chars_total + ?
+      WHERE id = ?`).run(by, id);
+}
+/**
+ * §6.5 boot-recovery sweep — flip every non-terminal row to
+ * (failed, 'daemon_restarted', finishedAt) on boot, before the
+ * dispatcher starts consuming events.
+ *
+ * Pure SQL UPDATE; returns the affected row count and the ids that
+ * were flipped so the caller can fan out one DM per row to the
+ * persisted `originating_channel`.
+ */
+export function sweepNonTerminalRowsForBootRecovery(db, nowMs) {
+    const txn = db.transaction(() => {
+        const rows = db
+            .prepare(`SELECT id, originating_channel
+           FROM browser_task
+          WHERE state IN ('pending', 'running', 'awaiting_user', 'final_confirm')`)
+            .all();
+        if (rows.length === 0)
+            return [];
+        db.prepare(`UPDATE browser_task
+          SET state = 'failed',
+              outcome_detail = 'daemon_restarted',
+              finished_at = ?
+        WHERE state IN ('pending', 'running', 'awaiting_user', 'final_confirm')`).run(nowMs);
+        return rows.map((r) => ({
+            id: r.id,
+            originatingChannel: r.originating_channel,
+        }));
+    });
+    return txn();
+}
+/**
+ * Retention prune for terminal `browser_task` rows older than `cutoffMs`
+ * (BROWSER_TASK_REDESIGN_PLAN.md §6.5 deferred follow-up + §14.7 — the
+ * trace-store window is 30 days; the SQL row lifetime matches so the
+ * dashboard never renders a row whose screenshots are 404). Children in
+ * `browser_task_action_log`, `browser_task_clarifications`, and
+ * `browser_task_final_confirm_tokens` go with the parent via the
+ * ON DELETE CASCADE FK declared in `schema.ts`.
+ *
+ * Non-terminal rows are NEVER deleted (the boot-recovery sweep is the
+ * sole path that mutates them after their owner's daemon-restart).
+ * `finished_at` is the lifetime anchor — for the few terminal
+ * transitions where the runner failed to set it (defensive), we fall
+ * back to `created_at` to avoid stranding rows.
+ */
+export function deleteTerminalBrowserTasksOlderThan(db, cutoffMs) {
+    const result = db
+        .prepare(`DELETE FROM browser_task
+        WHERE state IN ('completed', 'failed', 'timeout', 'cancelled', 'abandoned')
+          AND COALESCE(finished_at, created_at) < ?`)
+        .run(cutoffMs);
+    return result.changes;
+}

package/dist/db/client.d.ts

@@ -3,4 +3,3 @@ import type { AgentConfig } from "../config.js";
 export declare function createDatabase(config: AgentConfig): Database.Database;
 /** Create an in-memory database for testing */
 export declare function createTestDatabase(): Database.Database;
-//# sourceMappingURL=client.d.ts.map

package/dist/db/client.js

@@ -44,4 +44,3 @@ export function createTestDatabase() {
     db.pragma("foreign_keys = ON");
     return db;
 }
-//# sourceMappingURL=client.js.map

package/dist/db/entities-store.d.ts

@@ -3,7 +3,7 @@ import { type Domain, type EntityType } from "@aitne/shared";
 /**
  * Public entity DTO. `sources` is the parsed `frontmatter.sources` map
  * — keys are user-typed app labels, matching the `App` column in
- * `rules/management.md`. The route layer serializes this directly.
+ * `policies/management.md`. The route layer serializes this directly.
  */
 export interface EntityRecord {
     path: string;
@@ -38,11 +38,11 @@ export interface EntityRecord {
  */
 export declare function findEntitiesBySource(db: Database.Database, sourceKey: string, externalId: string): EntityRecord[];
 /**
- * Bias-input lookup for `management-task-register` Step 4a. Returns
- * every entity carrying a `sources.<sourceKey>.*` binding regardless
- * of `external_id`. Used so the registration skill can pick the
- * `(domain, type)` already dominant for that app instead of guessing
- * from the probe sample shape alone.
+ * Bias-input lookup for the `managed-tasks` skill's `## Register` flow
+ * (Step 4a — Decide `output_path`). Returns every entity carrying a
+ * `sources.<sourceKey>.*` binding regardless of `external_id`. Used so
+ * the registration flow can pick the `(domain, type)` already dominant
+ * for that app instead of guessing from the probe sample shape alone.
  *
  * Distinct from `findEntitiesBySource` (which requires both the key
  * and the id) because the bias query has no candidate id yet — it
@@ -89,4 +89,3 @@ export declare function resolveDomainType(domain: string, typePluralOrSingular:
     domain: Domain;
     type: EntityType;
 } | null;
-//# sourceMappingURL=entities-store.d.ts.map

package/dist/db/entities-store.js

@@ -81,11 +81,11 @@ export function findEntitiesBySource(db, sourceKey, externalId) {
         .filter((r) => r !== null);
 }
 /**
- * Bias-input lookup for `management-task-register` Step 4a. Returns
- * every entity carrying a `sources.<sourceKey>.*` binding regardless
- * of `external_id`. Used so the registration skill can pick the
- * `(domain, type)` already dominant for that app instead of guessing
- * from the probe sample shape alone.
+ * Bias-input lookup for the `managed-tasks` skill's `## Register` flow
+ * (Step 4a — Decide `output_path`). Returns every entity carrying a
+ * `sources.<sourceKey>.*` binding regardless of `external_id`. Used so
+ * the registration flow can pick the `(domain, type)` already dominant
+ * for that app instead of guessing from the probe sample shape alone.
  *
  * Distinct from `findEntitiesBySource` (which requires both the key
  * and the id) because the bias query has no candidate id yet — it
@@ -177,4 +177,3 @@ function escapeLike(value) {
     // metacharacters keeps the API contract simple.
     return value.replace(/[\\%_]/g, "");
 }
-//# sourceMappingURL=entities-store.js.map

package/dist/db/hourly-check-signals.d.ts

@@ -75,4 +75,3 @@ export interface ComputeHourlyCheckSignalsOptions {
     agentTimezone?: string;
 }
 export declare function computeHourlyCheckSignals(db: Database.Database, options?: ComputeHourlyCheckSignalsOptions): HourlyCheckSignals;
-//# sourceMappingURL=hourly-check-signals.d.ts.map

package/dist/db/hourly-check-signals.js

@@ -10,34 +10,63 @@
  * The shape mirrors the design doc 1:1 so the gate (Stage 1) can be
  * a pure function over `HourlyCheckSignals` + a config block.
  */
+import { buildSourcePrefixFilter, } from "@aitne/shared";
+/**
+ * Build a `(source LIKE 'a:%' OR source LIKE 'b:%' ...)` clause covering
+ * every direct-poller and pre-pass-partial prefix for the given kinds.
+ * Sourced from `INTEGRATION_DESCRIPTORS` so a new integration shipping
+ * with `prePassPartial: "<kind>-acquire.<key>.md"` auto-extends the
+ * gate's view of the world. Empty `kinds` yields `(1=0)` (defensive).
+ *
+ * CLAUDE.md: "Never hardcode an integration reference outside the
+ * registry."
+ */
+function sourceMatchClause(kinds) {
+    return buildSourcePrefixFilter(kinds);
+}
+/** All-kinds union — every observation source the gate cares about. */
+const ALL_KINDS = [
+    "mail",
+    "calendar",
+    "notion",
+    "vault",
+    "repo",
+];
 export function computeHourlyCheckSignals(db, options = {}) {
     const now = options.now ?? new Date();
     const vipSenders = (options.vipMailSenders ?? []).map((s) => s.toLowerCase());
     const calendarHorizonMs = (options.calendarHorizonHours ?? 24) * 60 * 60 * 1000;
     const scheduleHorizonHours = options.scheduleHorizonHours ?? 6;
+    // Gate filters by `source` (mail/calendar/notion/vault/repo), NEVER by
+    // `actor`. Delegated-sync-worker and the routine.fetch_window pre-pass
+    // both POST `actor='agent'` rows; the gate must see them as real
+    // activity. The 30-min `pre_pass_last_run:<key>` freshness window in
+    // `HourlyCheckCoordinator.harvestForGate` structurally prevents a
+    // single pre-pass row from being re-counted across ticks.
+    const allFilter = sourceMatchClause(ALL_KINDS);
     const pending = db
         .prepare(`SELECT COUNT(*) AS count
          FROM observations
         WHERE consumed_at IS NULL
-          AND actor = 'user'`)
-        .get();
+          AND ${allFilter.clause}`)
+        .get(...allFilter.values);
     const noveltyMaxRow = db
         .prepare(`SELECT MAX(novelty_score) AS max_score
          FROM observations
         WHERE consumed_at IS NULL
-          AND actor = 'user'
           AND summary_status = 'done'
-          AND novelty_score IS NOT NULL`)
-        .get();
+          AND novelty_score IS NOT NULL
+          AND ${allFilter.clause}`)
+        .get(...allFilter.values);
     const distributionRows = db
         .prepare(`SELECT novelty_score AS score, COUNT(*) AS count
          FROM observations
         WHERE consumed_at IS NULL
-          AND actor = 'user'
           AND summary_status = 'done'
           AND novelty_score IS NOT NULL
+          AND ${allFilter.clause}
         GROUP BY novelty_score`)
-        .all();
+        .all(...allFilter.values);
     const noveltyDistribution = { low: 0, mid: 0, high: 0 };
     for (const row of distributionRows) {
         if (row.score <= 1)
@@ -48,13 +77,13 @@ export function computeHourlyCheckSignals(db, options = {}) {
             noveltyDistribution.high += row.count;
     }
     const vipMailUnreadCount = countVipUnreadMail(db, vipSenders);
+    const calendarFilter = sourceMatchClause(["calendar"]);
     const calendarRow = db
         .prepare(`SELECT COUNT(*) AS count
          FROM observations
         WHERE consumed_at IS NULL
-          AND actor = 'user'
-          AND source LIKE 'calendar:%'`)
-        .get();
+          AND ${calendarFilter.clause}`)
+        .get(...calendarFilter.values);
     const calendarHas24hChange = calendarRow.count > 0;
     const calendarHasConflict = detectCalendarConflict(db, now, calendarHorizonMs);
     const agentPlanOverdueCount = countOverdueAgentPlanRows(options.todayMd ?? null, now, options.agentTimezone);
@@ -82,37 +111,96 @@ export function computeHourlyCheckSignals(db, options = {}) {
 function countVipUnreadMail(db, vipSenders) {
     if (vipSenders.length === 0)
         return 0;
-    // Defensive against a partially-migrated DB that lacks the table.
+    // Primary path (delegated / native / direct-with-pre-pass):
+    // unread VIP mail rides on `observations` with source prefixes
+    // `gmail:%` / `outlook_mail:%` (pre-pass) or `mail:%` (direct
+    // aggregate; only carries lifecycle metadata). The pre-pass payload
+    // is normalized at the `/api/observations` POST chokepoint to surface
+    // `is_read=0` + `from_email=<lowercased>` so this query can read a
+    // single canonical shape regardless of provider. We treat a row as
+    // VIP-unread when EITHER:
+    //   (a) the normalized `is_read=0` + `from_email` keys are present
+    //       and match, OR
+    //   (b) `is_read` is absent (pre-normalization payload or non-mail
+    //       lifecycle row) but `payload.raw.from` is a substring match
+    //       for one of the VIP addresses — captures the legacy case
+    //       where the partial doesn't emit the normalized keys.
+    const mailFilter = sourceMatchClause(["mail"]);
+    const senderPlaceholders = vipSenders.map(() => "?").join(",");
+    const observationsRow = db
+        .prepare(`SELECT COUNT(*) AS count
+         FROM observations
+        WHERE consumed_at IS NULL
+          AND ${mailFilter.clause}
+          AND COALESCE(json_extract(payload, '$.is_read'), 0) = 0
+          AND LOWER(
+                COALESCE(
+                  json_extract(payload, '$.from_email'),
+                  json_extract(payload, '$.raw.from'),
+                  json_extract(payload, '$.from'),
+                  ''
+                )
+              ) IN (${senderPlaceholders})`)
+        .get(...mailFilter.values, ...vipSenders);
+    let observationsCount = observationsRow.count;
+    // Substring fallback for `payload.raw.from` shapes like
+    // "Foo Bar <foo@bar.com>" — the IN-match above only catches exact
+    // address fields. Defensive cap (50 rows) keeps the per-tick cost
+    // bounded; tens of unread VIP mails in one window is already a
+    // hard-escalate signal regardless of exact count.
+    if (observationsCount === 0) {
+        const candidateRows = db
+            .prepare(`SELECT json_extract(payload, '$.raw.from') AS rawFrom
+           FROM observations
+          WHERE consumed_at IS NULL
+            AND ${mailFilter.clause}
+            AND COALESCE(json_extract(payload, '$.is_read'), 0) = 0
+          LIMIT 50`)
+            .all(...mailFilter.values);
+        for (const row of candidateRows) {
+            if (!row.rawFrom)
+                continue;
+            const haystack = row.rawFrom.toLowerCase();
+            if (vipSenders.some((s) => haystack.includes(s))) {
+                observationsCount += 1;
+            }
+        }
+    }
+    // Fallback path (direct mode pre-pre-pass installs whose observations
+    // are aggregate `mail:lifecycle` rows without per-message detail).
+    // The `mail_messages_index` table carries the canonical `is_read` +
+    // `from_email` columns and the MailPoller writes to it on every poll.
     const tableExists = db
         .prepare(`SELECT 1 AS present
          FROM sqlite_master
         WHERE type = 'table' AND name = 'mail_messages_index'`)
         .get();
-    if (!tableExists)
-        return 0;
-    const placeholders = vipSenders.map(() => "?").join(",");
-    const row = db
-        .prepare(`SELECT COUNT(*) AS count
-         FROM mail_messages_index
-        WHERE is_read = 0
-          AND deleted_at_utc IS NULL
-          AND LOWER(COALESCE(from_email, '')) IN (${placeholders})`)
-        .get(...vipSenders);
-    return row.count;
+    let tableCount = 0;
+    if (tableExists) {
+        const row = db
+            .prepare(`SELECT COUNT(*) AS count
+           FROM mail_messages_index
+          WHERE is_read = 0
+            AND deleted_at_utc IS NULL
+            AND LOWER(COALESCE(from_email, '')) IN (${senderPlaceholders})`)
+            .get(...vipSenders);
+        tableCount = row.count;
+    }
+    return Math.max(observationsCount, tableCount);
 }
 function detectCalendarConflict(db, now, horizonMs) {
     // Pull pending calendar observation payloads. We tolerate the common
     // shapes (`start`, `end`, `start.dateTime`, `end.dateTime`) and bail
     // gracefully when neither is recognizable. A "conflict" is two events
     // whose [start, end) ranges intersect within the lookahead window.
+    const calendarFilter = sourceMatchClause(["calendar"]);
     const rows = db
         .prepare(`SELECT payload
          FROM observations
         WHERE consumed_at IS NULL
-          AND actor = 'user'
-          AND source LIKE 'calendar:%'
-          AND payload IS NOT NULL`)
-        .all();
+          AND payload IS NOT NULL
+          AND ${calendarFilter.clause}`)
+        .all(...calendarFilter.values);
     const ranges = [];
     const horizon = now.getTime() + horizonMs;
     for (const row of rows) {
@@ -237,20 +325,18 @@ function minutesOfDayInTimezone(now, timezone) {
     }
 }
 function computeHoursSinceLastStage3(db, now) {
-    // Prefer the gate-emitted row (`hourly_check.gate` with stage_reached
-    // ∈ {'stage3', 'stage3_shadow'}) — that matches the design doc's
-    // "since the last Stage 3 run" semantics. Shadow mode writes
-    // `stage3_shadow`, but a shadow tick still spawns a full Stage-3
-    // session; treating both as "did a real run" keeps the heartbeat
-    // honest in shadow mode without depending on the legacy fallback row
-    // (which can be pruned independently). Fall back to the legacy
+    // Prefer the gate-emitted row (`hourly_check.gate` with
+    // stage_reached='stage3') — that matches the design doc's "since the
+    // last Stage 3 run" semantics. Fall back to the legacy
     // `routine.hourly_check` action-type for installs deployed before
-    // the gate was wired.
+    // the gate was wired. (The `stage3_shadow` marker was removed when
+    // the gateMode enum collapsed in HOURLY_CHECK_GATE_REDESIGN_PLAN.md
+    // Phase 4 — only the canonical `stage3` is ever written now.)
     const gateRow = db
         .prepare(`SELECT started_at
          FROM agent_actions
         WHERE action_type = 'hourly_check.gate'
-          AND json_extract(detail, '$.stage_reached') IN ('stage3', 'stage3_shadow')
+          AND json_extract(detail, '$.stage_reached') = 'stage3'
         ORDER BY started_at DESC
         LIMIT 1`)
         .get();
@@ -286,4 +372,3 @@ function parseSqliteUtc(value) {
     const ts = Date.parse(iso);
     return Number.isFinite(ts) ? ts : null;
 }
-//# sourceMappingURL=hourly-check-signals.js.map