@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/routine-fetch-window-runner.d.ts

@@ -3,7 +3,7 @@
  *
  * docs/design/appendices/routine-data-acquisition.md §6.1.1 + docs/design/appendices/pre-pass-fan-out.md
  * — every routine dispatcher (morning_routine, today_refresh,
- * hourly_check, evening / weekly / monthly review) calls this runner
+ * activity_scan, evening / weekly / monthly review) calls this runner
  * immediately before dispatching the parent session. The runner:
  *
  *  1. Reads the per-routine plan from `ROUTINE_WINDOWS` and the current
@@ -27,7 +27,7 @@
  *  4. The caller grafts the block into the **parent** routine event's
  *     `event.data.fetchReportBlock`. ContextBuilder injects it verbatim
  *     into the parent session's prompt (mirrors the `<gate_decision>`
- *     pattern used by hourly_check Stage 3).
+ *     pattern used by activity_scan Stage 3).
  *
  * Failure-mode contract (docs/design/appendices/pre-pass-fan-out.md §5):
  *
@@ -57,6 +57,7 @@ import type { IAgentRouter } from "./backends/backend-router.js";
 import type { IAuditLogger, IContextBuilder } from "./dispatcher-types.js";
 import type { PromptAssembler } from "./dispatcher-prompt.js";
 import { type RoutineWindowKey } from "./routine-windows.js";
+import type { AutonomousSpawnGate } from "./spawn-gates.js";
 /**
  * Structured form of the agent's single-line JSON output. Matches the
  * contract in `agent-profiles/routine-fetch-window.md`:
@@ -142,7 +143,7 @@ export interface RoutineFetchWindowResult {
 /**
  * HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.4 — caller options for `run()`.
  *
- * The hourly_check coordinator passes `integrationKeyFilter` to restrict
+ * The activity_scan coordinator passes `integrationKeyFilter` to restrict
  * the fan-out to the subset of integrations whose freshness window has
  * elapsed. Morning_routine / evening_review / weekly_review call
  * `run()` without options so they fetch every integration the routine
@@ -194,6 +195,14 @@ export interface RoutineFetchWindowRunnerDeps {
     getEventBroadcaster?: () => {
         broadcastEvent: (data: unknown) => void;
     } | null;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — offline/auth spawn gate shared
+     * with the dispatcher. Evaluated per integration sub-session (the
+     * hourly `harvestForGate` path spawns the runner directly, bypassing
+     * the dispatcher's own gate). Optional: when undefined the runner
+     * spawns unconditionally, exactly as pre-N2.
+     */
+    spawnGate?: AutonomousSpawnGate;
 }
 /**
  * Compose the per-execute `allowedToolsOverride` for the pre-pass. The
@@ -340,6 +349,7 @@ export declare class RoutineFetchWindowRunner {
     private readonly prompt;
     private readonly getActiveMailAccounts;
     private readonly getEventBroadcaster;
+    private readonly spawnGate;
     constructor(deps: RoutineFetchWindowRunnerDeps);
     /**
      * Broadcast a single pre-pass progress event to the dashboard SSE
@@ -426,6 +436,32 @@ export declare class RoutineFetchWindowRunner {
     private budgetCapAttemptRecord;
     private didExhaustRetries;
     private backoffForAttempt;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — evaluate the offline/auth spawn
+     * gate for one integration's sub-session. Candidates are the
+     * pre-resolved binding's main + fallback backends; when pre-resolve
+     * failed, the sub-plan's `requiredBackend` is the only candidate the
+     * attempt loop could use. Fail-open on every error path (returns null).
+     */
+    private evaluateSpawnGate;
+    /**
+     * Build the `skipped` SubReport for a spawn-gate skip and write its
+     * audit row. Mirrors the empty-attempts synthetic record (attempt 0,
+     * no SSE sub-session emits — no session was spawned). The audit row is
+     * `result='skipped'` with `detail.prePass.skipReason` carrying N2's
+     * `offline` / `auth_unhealthy`, matching the N3 plan-drop row shape so
+     * all pre-pass skip telemetry is queryable through one path.
+     */
+    private spawnGateSkippedSubReport;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N3 — one `skipped` audit row per
+     * (integration × reason) group of plan-assembly drops, with the
+     * dropped windows listed in `detail.prePass.windows`. Grouped at
+     * integration granularity because that is the unit a session would
+     * have been spawned for (and the unit the deferred R5 streak skip
+     * will key on). Observability only — no skip behavior changes here.
+     */
+    private logPlanAssemblyDrops;
     /**
      * Unified audit-row companion for every fan-out failure mode —
      * binding-resolve-failed, global-budget-cap, budget-cap (per-integration),

package/dist/core/routine-fetch-window-runner.js

@@ -3,7 +3,7 @@
  *
  * docs/design/appendices/routine-data-acquisition.md §6.1.1 + docs/design/appendices/pre-pass-fan-out.md
  * — every routine dispatcher (morning_routine, today_refresh,
- * hourly_check, evening / weekly / monthly review) calls this runner
+ * activity_scan, evening / weekly / monthly review) calls this runner
  * immediately before dispatching the parent session. The runner:
  *
  *  1. Reads the per-routine plan from `ROUTINE_WINDOWS` and the current
@@ -27,7 +27,7 @@
  *  4. The caller grafts the block into the **parent** routine event's
  *     `event.data.fetchReportBlock`. ContextBuilder injects it verbatim
  *     into the parent session's prompt (mirrors the `<gate_decision>`
- *     pattern used by hourly_check Stage 3).
+ *     pattern used by activity_scan Stage 3).
  *
  * Failure-mode contract (docs/design/appendices/pre-pass-fan-out.md §5):
  *
@@ -54,7 +54,9 @@ import { readIntegrations } from "../db/integrations-store.js";
 import { renderPartialForFanOut } from "./prompts.js";
 import { OBSERVATIONS_MCP_TOOL_NAME } from "../services/mcp/sdk-observations-server.js";
 import { ROUTINE_WINDOWS, routineHasWindows, WINDOW_QUERIES, } from "./routine-windows.js";
-import { buildAcquisitionTimestamps, splitAcquisitionPlanByIntegration, } from "./routine-acquisition-plan.js";
+import { buildAcquisitionPlanAssembly, buildAcquisitionTimestamps, splitAcquisitionPlanByIntegration, } from "./routine-acquisition-plan.js";
+import { extractBackendSpend } from "./agent-core.js";
+import { BackendRouterHandledError } from "./backends/backend-router.js";
 import { RETRY_REASONS, buildPriorAttemptHintBlock, defaultRetryDecision, } from "./routine-fetch-window-retry.js";
 import { writeRuntimeState } from "../db/runtime-state.js";
 import { prePassLastRunRuntimeStateKey } from "./pre-pass-freshness.js";
@@ -118,7 +120,7 @@ const FETCH_WINDOW_INTEGRATION_PARTIAL_PLACEHOLDER = "{integration_partial}";
 function buildPrePassDaemonRestPatterns(apiPort, sessionBackend) {
     const root = `http://localhost:${apiPort}/api`;
     // Observations WRITE surface — the only write the pre-pass performs (GET
-    // reads of pending observations live in the hourly-check session, never
+    // reads of pending observations live in the activity-scan session, never
     // here). For Claude the structured MCP tool
     // `mcp__aitne-observations__submit_observations` (added by
     // `composePrePassAllowedTools`) is the ONLY sanctioned write path, so we
@@ -774,6 +776,55 @@ async function runWithConcurrency(tasks, concurrency) {
     await Promise.all(workers);
     return results;
 }
+function recoverRouterErrorSpend(error) {
+    const failures = [];
+    if (error instanceof BackendRouterHandledError) {
+        failures.push(error.mainFailure);
+        if (error.fallbackFailure && error.fallbackFailure !== error.mainFailure) {
+            failures.push(error.fallbackFailure);
+        }
+        if (error.cause && !failures.includes(error.cause)) {
+            failures.push(error.cause);
+        }
+    }
+    else {
+        failures.push(error);
+    }
+    let found = false;
+    let costUsd = 0;
+    let numTurns = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let cacheReadInputTokens = 0;
+    let costSource = null;
+    for (const failure of failures) {
+        const spend = extractBackendSpend(failure);
+        if (!spend)
+            continue;
+        found = true;
+        costUsd += spend.costUsd;
+        numTurns += spend.numTurns;
+        inputTokens += spend.usage.inputTokens;
+        outputTokens += spend.usage.outputTokens;
+        cacheCreationInputTokens += spend.usage.cacheCreationInputTokens;
+        cacheReadInputTokens += spend.usage.cacheReadInputTokens;
+        costSource = costSource ?? spend.costSource ?? null;
+    }
+    if (!found)
+        return null;
+    return {
+        costUsd,
+        numTurns,
+        costSource,
+        usage: {
+            inputTokens,
+            outputTokens,
+            cacheCreationInputTokens,
+            cacheReadInputTokens,
+        },
+    };
+}
 // ── Runner ────────────────────────────────────────────────────────────────
 export class RoutineFetchWindowRunner {
     db;
@@ -784,6 +835,7 @@ export class RoutineFetchWindowRunner {
     prompt;
     getActiveMailAccounts;
     getEventBroadcaster;
+    spawnGate;
     constructor(deps) {
         this.db = deps.db;
         this.config = deps.config;
@@ -793,6 +845,7 @@ export class RoutineFetchWindowRunner {
         this.prompt = deps.prompt;
         this.getActiveMailAccounts = deps.getActiveMailAccounts;
         this.getEventBroadcaster = deps.getEventBroadcaster ?? null;
+        this.spawnGate = deps.spawnGate ?? null;
     }
     /**
      * Broadcast a single pre-pass progress event to the dashboard SSE
@@ -925,8 +978,13 @@ export class RoutineFetchWindowRunner {
         catch (err) {
             return this.fail(key, agentDay, parentEvent, "plan-assembly-failed", err);
         }
+        // PREPASS_COST_REDUCTION_PLAN.md N3 — surface plan-assembly drops as
+        // `skipped` audit rows before the empty-plan short-circuit below, so
+        // the all-cells-dropped case (the one the short-circuit hides) is
+        // recorded too. Observability only — no new skip behavior.
+        this.logPlanAssemblyDrops(parentEvent, key, planContext.drops);
         // HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.4 — when the caller is the
-        // hourly_check coordinator, the freshness gate restricts pre-pass to
+        // activity_scan coordinator, the freshness gate restricts pre-pass to
         // a subset of integrations. `integrationKeyFilter` is honoured here
         // (before fan-out) so the runner only spawns sub-sessions for stale
         // integrations.
@@ -1010,7 +1068,7 @@ export class RoutineFetchWindowRunner {
             accounts,
             timestamps,
         };
-        const subPlans = splitAcquisitionPlanByIntegration(planInput);
+        const { subPlans, drops } = buildAcquisitionPlanAssembly(planInput);
         // Observability: surface integrations whose `<fetch>` row will spawn
         // on a backend OTHER than the pre-pass default. Per-integration
         // backend routing (resolveIntegrationBackend +
@@ -1042,6 +1100,7 @@ export class RoutineFetchWindowRunner {
             subPlans,
             accounts,
             timestamps,
+            drops,
         };
     }
     /**
@@ -1183,6 +1242,17 @@ export class RoutineFetchWindowRunner {
         return merged;
     }
     async runOneIntegrationWithRetry(input) {
+        // PREPASS_COST_REDUCTION_PLAN.md N2 — offline/auth spawn gate, per
+        // sub-session because each integration can route to a different
+        // backend (`requiredBackend`). Skips only when EVERY candidate
+        // backend is non-viable; the DNS verdict is cached (~60s) inside the
+        // gate so an N-integration fan-out costs one lookup per host.
+        // Freshness (`pre_pass_last_run:<key>`) is untouched by construction
+        // — only `success` writes it — so the next tick retries.
+        const gateDecision = await this.evaluateSpawnGate(input);
+        if (gateDecision?.skip) {
+            return this.spawnGateSkippedSubReport(input, gateDecision);
+        }
         const attempts = [];
         // Per-integration budget cap is enforced at TWO complementary layers,
         // BOTH driven by `policy.perIntegrationBudgetUsd`:
@@ -1414,10 +1484,16 @@ export class RoutineFetchWindowRunner {
                 record = this.attemptRecordFromResult(attempt, fetcherEvent, startedAt, result);
             }
             catch (err) {
-                input.globalBudget.commit(globalReservation, 0);
-                integrationBudget.commit(integrationReservation, 0);
+                // PREPASS_COST_REDUCTION_PLAN.md N1 — the throw path can still
+                // have billed the provider (post-hoc budget kill, partial stream
+                // abort). Recover the spend the backend cores attached so the
+                // budget guards account for real consumption and the attempt
+                // record / audit row carry the cost instead of a silent 0.
+                const failureSpend = recoverRouterErrorSpend(err);
+                input.globalBudget.commit(globalReservation, failureSpend?.costUsd ?? 0);
+                integrationBudget.commit(integrationReservation, failureSpend?.costUsd ?? 0);
                 executeErr = err;
-                record = this.failedAttemptRecord(attempt, fetcherEvent.correlationId, startedAt, "agent-execute-failed", err);
+                record = this.failedAttemptRecord(attempt, fetcherEvent.correlationId, startedAt, "agent-execute-failed", err, failureSpend);
             }
             attempts.push(record);
             const decision = retryOn(record, attempt, input.policy, attempts.slice(0, -1));
@@ -1439,6 +1515,7 @@ export class RoutineFetchWindowRunner {
                     err: executeErr,
                     binding: binding.main,
                     startedAt,
+                    spend: recoverRouterErrorSpend(executeErr),
                 });
             }
             this.emitSubSessionCompleted(input, fetcherEvent.correlationId, attempt, record, decision);
@@ -1470,7 +1547,7 @@ export class RoutineFetchWindowRunner {
         // timestamp on every successful integration completion. The
         // coordinator's `harvestForGate` reads this key to suppress
         // redundant pre-pass spawns within the configured freshness window
-        // (default 30 min). Shared across morning_routine / hourly_check /
+        // (default 30 min). Shared across morning_routine / activity_scan /
         // evening_review / weekly_review / today_refresh by construction:
         // the runner has no notion of parent routine.
         //
@@ -1602,7 +1679,14 @@ export class RoutineFetchWindowRunner {
             numTurns: result.numTurns,
         };
     }
-    failedAttemptRecord(attempt, fetcherCorrelationId, startedAt, kind, err) {
+    failedAttemptRecord(attempt, fetcherCorrelationId, startedAt, kind, err, 
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N1 — spend recovered from the
+     * failure signal when the provider already billed the attempt.
+     * Absent for pre-execute failures (binding/context), which are
+     * genuinely zero-cost.
+     */
+    spend) {
         const message = err instanceof Error ? err.message : String(err);
         const endedAt = new Date().toISOString();
         return {
@@ -1615,8 +1699,8 @@ export class RoutineFetchWindowRunner {
             fetcherCorrelationId,
             startedAt,
             endedAt,
-            costUsd: 0,
-            numTurns: 0,
+            costUsd: spend?.costUsd ?? 0,
+            numTurns: spend?.numTurns ?? 0,
         };
     }
     budgetCapAttemptRecord(attempt, fetcherCorrelationId, startedAt, type, remaining) {
@@ -1663,6 +1747,156 @@ export class RoutineFetchWindowRunner {
         const last = policy.backoffMs[policy.backoffMs.length - 1];
         return typeof last === "number" ? Math.max(0, last) : 0;
     }
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — evaluate the offline/auth spawn
+     * gate for one integration's sub-session. Candidates are the
+     * pre-resolved binding's main + fallback backends; when pre-resolve
+     * failed, the sub-plan's `requiredBackend` is the only candidate the
+     * attempt loop could use. Fail-open on every error path (returns null).
+     */
+    async evaluateSpawnGate(input) {
+        if (!this.spawnGate)
+            return null;
+        try {
+            const binding = input.preResolvedBinding;
+            const candidates = binding
+                ? [binding.main.backendId]
+                : [input.subPlan.requiredBackend];
+            if (binding?.fallback
+                && binding.fallback.backendId !== binding.main.backendId) {
+                candidates.push(binding.fallback.backendId);
+            }
+            return await this.spawnGate.evaluate(candidates);
+        }
+        catch (err) {
+            logger.warn({
+                err,
+                routine: input.key,
+                integrationKey: input.subPlan.integrationKey,
+            }, "Pre-pass spawn-gate evaluation failed — failing open");
+            return null;
+        }
+    }
+    /**
+     * Build the `skipped` SubReport for a spawn-gate skip and write its
+     * audit row. Mirrors the empty-attempts synthetic record (attempt 0,
+     * no SSE sub-session emits — no session was spawned). The audit row is
+     * `result='skipped'` with `detail.prePass.skipReason` carrying N2's
+     * `offline` / `auth_unhealthy`, matching the N3 plan-drop row shape so
+     * all pre-pass skip telemetry is queryable through one path.
+     */
+    spawnGateSkippedSubReport(input, decision) {
+        const reason = decision.reason ?? "offline";
+        const now = new Date().toISOString();
+        const record = {
+            attempt: 0,
+            status: "skipped",
+            fetched: 0,
+            posted: 0,
+            duplicates: 0,
+            errors: [{ type: "spawn-gate-skipped", reason, attempt: 0 }],
+            fetcherCorrelationId: input.parentEvent.correlationId,
+            startedAt: now,
+            endedAt: now,
+            costUsd: 0,
+            numTurns: 0,
+        };
+        try {
+            const fetcherEvent = this.createFanOutFetcherEvent(input.parentEvent, input.key, input.subPlan, 0, input.policy.maxAttempts);
+            this.audit.logSkip(fetcherEvent, reason, "autonomous", {
+                prePass: {
+                    parentCorrelationId: input.parentEvent.correlationId,
+                    parentRoutine: input.key,
+                    integrationKey: input.subPlan.integrationKey,
+                    skipReason: reason,
+                    spawnGate: { backends: decision.backends },
+                },
+            });
+        }
+        catch (err) {
+            logger.warn({
+                err,
+                routine: input.key,
+                integrationKey: input.subPlan.integrationKey,
+                reason,
+            }, "Failed to log spawn-gate skip audit row");
+        }
+        logger.info({
+            routine: input.key,
+            integrationKey: input.subPlan.integrationKey,
+            reason,
+            backends: decision.backends,
+            parentCorrelationId: input.parentEvent.correlationId,
+        }, "Pre-pass sub-session skipped — spawn gate (offline / auth-unhealthy backends)");
+        return {
+            ...record,
+            integrationKey: input.subPlan.integrationKey,
+            attempts: [record],
+            retriesExhausted: false,
+        };
+    }
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N3 — one `skipped` audit row per
+     * (integration × reason) group of plan-assembly drops, with the
+     * dropped windows listed in `detail.prePass.windows`. Grouped at
+     * integration granularity because that is the unit a session would
+     * have been spawned for (and the unit the deferred R5 streak skip
+     * will key on). Observability only — no skip behavior changes here.
+     */
+    logPlanAssemblyDrops(parentEvent, key, allDrops) {
+        // `direct_inline_prefetch` is the catalog working as designed (the
+        // daemon fetches that data inline; see the reason's doc comment) —
+        // auditing it every run would bury the genuine drop signal R4/R5
+        // need under deterministic noise.
+        const drops = allDrops.filter((d) => d.reason !== "direct_inline_prefetch");
+        if (drops.length === 0)
+            return;
+        try {
+            const groups = new Map();
+            for (const drop of drops) {
+                const groupKey = `${drop.integration}|${drop.reason}`;
+                const existing = groups.get(groupKey);
+                if (existing) {
+                    existing.windows.push(drop.window);
+                }
+                else {
+                    groups.set(groupKey, {
+                        integration: drop.integration,
+                        reason: drop.reason,
+                        windows: [drop.window],
+                    });
+                }
+            }
+            for (const group of groups.values()) {
+                const dropEvent = {
+                    ...createEvent({
+                        type: FETCH_WINDOW_EVENT_TYPE,
+                        source: parentEvent.source,
+                        priority: EventPriority.NORMAL,
+                        correlationId: parentEvent.correlationId,
+                    }),
+                    routine: "fetch_window",
+                };
+                this.audit.logSkip(dropEvent, `plan_drop:${group.reason}`, "autonomous", {
+                    prePass: {
+                        parentCorrelationId: parentEvent.correlationId,
+                        parentRoutine: key,
+                        integrationKey: group.integration,
+                        skipReason: group.reason,
+                        windows: group.windows,
+                    },
+                });
+            }
+            logger.debug({
+                routine: key,
+                parentCorrelationId: parentEvent.correlationId,
+                drops,
+            }, "Pre-pass plan-assembly drops recorded");
+        }
+        catch (err) {
+            logger.warn({ err, routine: key, dropCount: drops.length }, "Failed to log pre-pass plan-assembly drop audit rows");
+        }
+    }
     /**
      * Unified audit-row companion for every fan-out failure mode —
      * binding-resolve-failed, global-budget-cap, budget-cap (per-integration),
@@ -1694,6 +1928,23 @@ export class RoutineFetchWindowRunner {
                 ...(durationMs !== undefined ? { durationMs } : {}),
                 ...(options.binding ? { backendId: options.binding.backendId } : {}),
                 ...(options.binding ? { modelId: options.binding.modelId } : {}),
+                ...(options.spend
+                    ? {
+                        costUsd: options.spend.costUsd,
+                        numTurns: options.spend.numTurns,
+                        ...(options.spend.costSource
+                            ? { costSource: options.spend.costSource }
+                            : {}),
+                        ...(options.spend.usage
+                            ? {
+                                tokensInput: options.spend.usage.inputTokens,
+                                tokensOutput: options.spend.usage.outputTokens,
+                                tokensCacheCreation: options.spend.usage.cacheCreationInputTokens,
+                                tokensCacheRead: options.spend.usage.cacheReadInputTokens,
+                            }
+                            : {}),
+                    }
+                    : {}),
                 failureKind: options.failureKind,
                 prePass: {
                     parentCorrelationId: input.parentEvent.correlationId,

package/dist/core/routine-windows.d.ts

@@ -49,7 +49,7 @@ export type WindowSymbol = (typeof WINDOW_SYMBOLS)[number];
  * `routine.morning_routine`; the daemon-prepared `<roadmap_skeleton>`
  * block (not a window fetch) handles the first-run roadmap populate.
  */
-export declare const ROUTINE_WINDOW_KEYS: readonly ["routine.morning_routine", "routine.today_refresh", "routine.hourly_check", "routine.evening_review", "routine.weekly_review", "routine.monthly_review"];
+export declare const ROUTINE_WINDOW_KEYS: readonly ["routine.morning_routine", "routine.today_refresh", "routine.activity_scan", "routine.evening_review", "routine.weekly_review", "routine.monthly_review"];
 export type RoutineWindowKey = (typeof ROUTINE_WINDOW_KEYS)[number];
 export interface RoutineWindowSpec {
     /** Fetch shape — drives partial selection (mail-acquire vs calendar-acquire vs notion-acquire). */
@@ -102,7 +102,7 @@ export interface RoutineWindowSpec {
  *    differs). The dispatcher's `applySinceFilter` in
  *    `db/observations.ts` ensures the main session reads back the
  *    merged pending set uniformly.
- *  - `hourly_check`: small, frequent. `unread_last_hour` typically
+ *  - `activity_scan`: small, frequent. `unread_last_hour` typically
  *    yields ≤1 mail item; `imminent_2h` ≤1 calendar item. Notion
  *    `updated_1h` is similarly bounded.
  *  - `evening_review`: ContextBuilder covers `<calendar_events_3d>`,

package/dist/core/routine-windows.js

@@ -83,7 +83,7 @@ export const WINDOW_SYMBOLS = [
 export const ROUTINE_WINDOW_KEYS = [
     "routine.morning_routine",
     "routine.today_refresh",
-    "routine.hourly_check",
+    "routine.activity_scan",
     "routine.evening_review",
     "routine.weekly_review",
     "routine.monthly_review",
@@ -112,7 +112,7 @@ export const ROUTINE_WINDOW_KEYS = [
  *    differs). The dispatcher's `applySinceFilter` in
  *    `db/observations.ts` ensures the main session reads back the
  *    merged pending set uniformly.
- *  - `hourly_check`: small, frequent. `unread_last_hour` typically
+ *  - `activity_scan`: small, frequent. `unread_last_hour` typically
  *    yields ≤1 mail item; `imminent_2h` ≤1 calendar item. Notion
  *    `updated_1h` is similarly bounded.
  *  - `evening_review`: ContextBuilder covers `<calendar_events_3d>`,
@@ -147,7 +147,7 @@ export const ROUTINE_WINDOWS = {
     "routine.today_refresh": [
         { kind: "calendar", window: "cal_next_24h_drift", perAccount: false },
     ],
-    "routine.hourly_check": [
+    "routine.activity_scan": [
         { kind: "mail", window: "unread_last_hour", perAccount: true },
         { kind: "calendar", window: "imminent_2h", perAccount: false },
         { kind: "notion", window: "updated_1h", perAccount: false },
@@ -216,7 +216,7 @@ export const WINDOW_QUERIES = {
     // shell-fragile Unicode whitespace. Filtering at the FETCH boundary
     // means the agent never sees these messages at all: zero cost, zero
     // chance of a Unicode-whitespace-bearing curl body, zero observations
-    // for the morning_routine / hourly_check skill to wade through.
+    // for the morning_routine / activity_scan skill to wade through.
     //
     // Sent-folder windows (today_outcomes) skip the filter — sent mail is
     // the user's own writing, not promotional.
@@ -334,6 +334,9 @@ export const WINDOW_QUERIES = {
     // (Outlook), so a pre-pass row would double-fetch. The dispatcher
     // skips rows whose `(symbol, integration, mode)` cell is undefined
     // (cf. `lookupQuery`); pre-pass only fires for delegated / native.
+    // Plan assembly classifies this pattern as `direct_inline_prefetch`
+    // (N3) — distinct from `no_window_query` (a genuine catalog hole) —
+    // and the runner excludes it from the drop-audit stream.
     cal_morning_7d: {
         google_calendar: {
             delegated: 'timeMin="{day_start_iso}" timeMax="{week_end_iso}" maxResults=100',
@@ -401,7 +404,7 @@ export function routineHasWindows(key) {
     return ROUTINE_WINDOWS[key].length > 0;
 }
 // Note: there is intentionally no `routineHasCalendarPrepass` helper
-// even though every morning_routine / hourly_check / today_refresh /
+// even though every morning_routine / activity_scan / today_refresh /
 // weekly_review row carries a calendar entry. The decision a caller
 // (e.g. ContextBuilder.buildCalendarBlock) really wants to make is
 // "does the pre-pass own the window I'm about to emit," and that needs