@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/notification-rate-limit.js

@@ -0,0 +1,50 @@
+import { formatSqliteDatetime, getAgentDayBoundsUtc } from "@aitne/shared";
+const HOUR_MS = 60 * 60 * 1000;
+/**
+ * Count semantics mirror the pre-extraction `NotificationManager`
+ * implementation byte-for-byte: a multi-channel dispatch counts once
+ * (DISTINCT on dispatch_id, falling back to the row id for legacy rows
+ * with an empty dispatch_id), only `delivered` rows count, and
+ * `message.received` reply forwards never count against proactive budget.
+ */
+export function evaluateNotificationRateLimit(db, opts, now = new Date()) {
+    const hourFloor = formatSqliteDatetime(new Date(now.getTime() - HOUR_MS));
+    const hourly = db
+        .prepare(`SELECT COUNT(DISTINCT CASE
+           WHEN dispatch_id != '' THEN dispatch_id
+           ELSE CAST(id AS TEXT)
+         END) as cnt,
+         MIN(created_at) as oldest
+       FROM notification_log
+       WHERE status = 'delivered'
+         AND COALESCE(notification_type, '') != 'message.received'
+         AND created_at > ?`)
+        .get(hourFloor);
+    if (hourly.cnt >= opts.maxNotificationsPerHour) {
+        // The window opens when the oldest in-window delivery ages past 1 h.
+        // `oldest` is non-null whenever cnt > 0; the cnt===0 ∧ limit<=0 corner
+        // (a zero/negative configured cap) degrades to "retry at now + 1 h".
+        const oldestMs = hourly.oldest
+            ? new Date(`${hourly.oldest.replace(" ", "T")}Z`).getTime()
+            : now.getTime();
+        return {
+            limited: true,
+            retryAfter: formatSqliteDatetime(new Date(oldestMs + HOUR_MS)),
+        };
+    }
+    const bounds = getAgentDayBoundsUtc(opts.timezone || undefined, opts.dayBoundaryHour, now);
+    const daily = db
+        .prepare(`SELECT COUNT(DISTINCT CASE
+           WHEN dispatch_id != '' THEN dispatch_id
+           ELSE CAST(id AS TEXT)
+         END) as cnt
+       FROM notification_log
+       WHERE status = 'delivered'
+         AND COALESCE(notification_type, '') != 'message.received'
+         AND created_at >= ? AND created_at < ?`)
+        .get(bounds.start, bounds.end);
+    if (daily.cnt >= opts.maxNotificationsPerDay) {
+        return { limited: true, retryAfter: bounds.end };
+    }
+    return { limited: false, retryAfter: null };
+}

package/dist/core/policy-files.d.ts

@@ -31,7 +31,7 @@ export declare function createPromptInjectionBudget(maxBytes?: number): PromptIn
  *   - `policies/mcp.md` — MCP usage rules (B-003; inject when any MCP enabled)
  *   - `policies/journal-format.md` — daily journal format (morning routine)
  *   - `policies/redaction.md` — secret patterns (all flows)
- *   - `policies/routines/hourly.md` — hourly check list
+ *   - `policies/routines/activity-scan.md` — activity scan list
  *   - `policies/routines/morning.md` — 04:00 checks (morning routine)
  *   - `policies/routines/custom/<slug>.md` — per-custom-routine check list
  *

package/dist/core/policy-files.js

@@ -51,8 +51,8 @@ export const POLICY_FILE_REGISTRY = {
             injectIf: (ctx) => ctx.flags?.mcpEnabled === true,
         },
     ],
-    "routine.hourly_check": [
-        { path: CONTEXT_RELATIVE_PATHS.routines.hourly, label: "Hourly checks" },
+    "routine.activity_scan": [
+        { path: CONTEXT_RELATIVE_PATHS.routines.activityScan, label: "Activity scans" },
     ],
     "routine.morning_routine": [
         {

package/dist/core/pre-pass-freshness.d.ts

@@ -1,17 +1,17 @@
 /**
- * Freshness-window helpers for the hourly_check pre-pass harvester
+ * Freshness-window helpers for the activity_scan pre-pass harvester
  * (HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.4).
  *
  * The pre-pass fetcher writes a `runtime_state` row keyed by integration
- * after every successful per-integration completion. The hourly_check
+ * after every successful per-integration completion. The activity_scan
  * coordinator's `harvestForGate` reads the row to decide whether the
  * window is fresh enough to skip pre-pass on this tick.
  *
  * The key prefix is intentionally shared across every routine that
- * spawns `routine.fetch_window` (morning_routine, hourly_check,
+ * spawns `routine.fetch_window` (morning_routine, activity_scan,
  * evening_review, weekly_review, today_refresh). Sharing means a
  * morning_routine that just ran at 04:00 suppresses the 05:00
- * hourly_check pre-pass — exactly what we want to avoid double-fetching.
+ * activity_scan pre-pass — exactly what we want to avoid double-fetching.
  *
  * Module is intentionally trivial — separated so both the runner (writer)
  * and the coordinator (reader) can depend on a single string-builder

package/dist/core/retention.d.ts

@@ -90,6 +90,11 @@ export interface RetentionResult {
      * rows are never counted here; boot-recovery owns them.
      */
     browserTask: number;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §6 — terminal `background_task` rows
+     * pruned during this sweep (children cascade via FK).
+     */
+    backgroundTask: number;
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §5 — pending lite-final-confirm
      * tokens past their 5-min TTL flipped to `expired` during this sweep

package/dist/core/retention.js

@@ -6,6 +6,7 @@ import { expireStalePurchaseTokens, scrubRotatedPurchaseTokens, sweepOrphanedCon
 import { deletePurchaseRepliesOlderThan } from "../db/browser-automation-purchase-replies-store.js";
 import { deleteWorkflowRunsOlderThan } from "../db/browser-automation-store.js";
 import { deleteTerminalBrowserTasksOlderThan } from "../db/browser-task-store.js";
+import { deleteTerminalBackgroundTasksOlderThan } from "../db/background-task-store.js";
 import { expireStaleLiteFinalConfirmTokens, scrubRotatedLiteFinalConfirmTokens, } from "../db/browser-task-final-confirm-tokens-store.js";
 import { cleanupConsumedObservations, getStalePendingObservationStats, } from "../db/observations.js";
 import { pruneOldMcpToolCalls } from "../services/mcp/tool-audit.js";
@@ -61,6 +62,16 @@ const RETENTION_DAYS = {
      * sweep itself is broken and we should not paper over it.
      */
     browserTask: TRACE_RETENTION_DAYS,
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §6 — terminal `background_task` rows
+     * age out at 30 days. Unlike browser_task there are no trace
+     * screenshots to keep in sync; 30 days keeps a month of completed-task
+     * history so a late "what did that find?" follow-up can still
+     * `GET /api/background-task/:id`. Children
+     * (`background_task_clarifications`) cascade via FK. Non-terminal rows
+     * are NEVER deleted — boot re-dispatch owns them.
+     */
+    backgroundTask: 30,
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §14.11 Q#6 — lite-final-confirm tokens
      * carry the same `!~xxxxxxxx` shape as B-4 purchase tokens. Mirror the
@@ -79,7 +90,7 @@ const RETENTION_DAYS = {
     skillCurationRunningMaxHours: 24,
     tempFiles: 1,
     /**
-     * Pending observations are NEVER deleted by retention (the hourly_check
+     * Pending observations are NEVER deleted by retention (the activity_scan
      * dispatcher owns consumption). After this many days unconsumed, retention
      * logs a warning so the operator notices a stalled pipeline.
      */
@@ -193,6 +204,7 @@ export function runRetentionCleanup(db, config) {
         browserAutomationPurchaseTokensScrubbed: 0,
         browserAutomationPurchaseRepliesDeleted: 0,
         browserTask: 0,
+        backgroundTask: 0,
         browserTaskFinalConfirmTokensExpired: 0,
         browserTaskFinalConfirmTokensScrubbed: 0,
         ftsOptimized: false,
@@ -232,6 +244,7 @@ export function runRetentionCleanup(db, config) {
         browserAutomationPurchaseTokensScrubbed: 0,
         browserAutomationPurchaseRepliesDeleted: 0,
         browserTask: 0,
+        backgroundTask: 0,
         browserTaskFinalConfirmTokensExpired: 0,
         browserTaskFinalConfirmTokensScrubbed: 0,
     };
@@ -380,10 +393,12 @@ export function runRetentionCleanup(db, config) {
                 scrubRotatedLiteFinalConfirmTokens(db, tokenScrubCutoff);
             const browserTaskCutoff = now - RETENTION_DAYS.browserTask * 86_400_000;
             counts.browserTask = deleteTerminalBrowserTasksOlderThan(db, browserTaskCutoff);
+            const backgroundTaskCutoff = now - RETENTION_DAYS.backgroundTask * 86_400_000;
+            counts.backgroundTask = deleteTerminalBackgroundTasksOlderThan(db, backgroundTaskCutoff);
         }
         catch (err) {
             /* c8 ignore next 5 */
-            logger.warn({ err }, "browser_task retention sweep skipped (tables missing)");
+            logger.warn({ err }, "browser_task / background_task retention sweep skipped (tables missing)");
         }
     })();
     // Transaction committed — safe to copy counts into result.
@@ -416,6 +431,7 @@ export function runRetentionCleanup(db, config) {
     result.imminentEventNotifications = counts.imminentEventNotifications;
     result.browserAutomationWorkflows = counts.browserAutomationWorkflows;
     result.browserTask = counts.browserTask;
+    result.backgroundTask = counts.backgroundTask;
     result.browserTaskFinalConfirmTokensExpired =
         counts.browserTaskFinalConfirmTokensExpired;
     result.browserTaskFinalConfirmTokensScrubbed =
@@ -433,7 +449,7 @@ export function runRetentionCleanup(db, config) {
     result.attachmentOrphanRows = attachmentCleanup.orphanRows;
     result.attachmentDanglingRows = attachmentCleanup.danglingRows;
     result.attachmentUntrackedDirs = attachmentCleanup.untrackedDirs;
-    // Surface stale pending observations so a stalled hourly_check pipeline
+    // Surface stale pending observations so a stalled activity_scan pipeline
     // becomes visible in daemon logs. Pending rows are intentionally not
     // deleted (see RETENTION_DAYS.stalePendingObservationsWarn comment).
     const stalePending = getStalePendingObservationStats(db, RETENTION_DAYS.stalePendingObservationsWarn);
@@ -442,7 +458,7 @@ export function runRetentionCleanup(db, config) {
             stalePendingCount: stalePending.count,
             oldestObservedAt: stalePending.oldestObservedAt,
             thresholdDays: RETENTION_DAYS.stalePendingObservationsWarn,
-        }, "Stale pending observations detected — hourly_check may be skipping or stalled");
+        }, "Stale pending observations detected — activity_scan may be skipping or stalled");
     }
     // ── FTS5 segment optimization ──
     //

package/dist/core/review-context.d.ts

@@ -1,5 +1,5 @@
 import { type PromptInjectionBudget } from "./policy-files.js";
-export type ReviewFlowSlug = "hourly" | "morning" | "evening" | "weekly" | "monthly" | "roadmap";
+export type ReviewFlowSlug = "activity-scan" | "morning" | "evening" | "weekly" | "monthly" | "roadmap";
 interface ReviewFlowConfig {
     flow: ReviewFlowSlug;
     dossierPath: string;

package/dist/core/review-context.js

@@ -6,10 +6,10 @@ import { POLICY_FILE_MAX_BYTES, createPromptInjectionBudget, } from "./policy-fi
 import { createLogger } from "../logging.js";
 const logger = createLogger("review-context");
 const REVIEW_FLOW_BY_PROCESS_KEY = {
-    "routine.hourly_check": {
-        flow: "hourly",
-        dossierPath: dossierPath("hourly"),
-        dossierLabel: "Hourly dossier",
+    "routine.activity_scan": {
+        flow: "activity-scan",
+        dossierPath: dossierPath("activity-scan"),
+        dossierLabel: "Activity scan dossier",
     },
     "routine.morning_routine": {
         flow: "morning",
@@ -295,7 +295,12 @@ function reviewFlowsMatch(raw, flow) {
         .split(/[,;/\s]+/)
         .map((token) => token.trim())
         .filter(Boolean);
-    return tokens.includes(flow);
+    if (tokens.includes(flow))
+        return true;
+    // v0.1.10 → v0.1.11 rename: user-vault `_index.md` rows written before the
+    // rename tag the activity-scan flow as "hourly". Accept the legacy token
+    // until the index reconciler has naturally rewritten those rows.
+    return flow === "activity-scan" && tokens.includes("hourly");
 }
 function sanitizeContextIndexPath(rawPath) {
     const path = rawPath.trim().replace(/^\.\//, "");

package/dist/core/roadmap-write-lock.d.ts

@@ -31,8 +31,9 @@ export interface RoadmapWriteLockManager {
 export declare class InMemoryRoadmapWriteLockManager implements RoadmapWriteLockManager {
     private readonly timeoutMs;
     private holder;
-    private timer;
+    private expiresAtMs;
     constructor(timeoutMs: number);
+    private expireIfStale;
     acquire(): {
         ok: true;
         lockId: string;

package/dist/core/roadmap-write-lock.js

@@ -4,44 +4,49 @@ const logger = createLogger("roadmap-write-lock");
 export class InMemoryRoadmapWriteLockManager {
     timeoutMs;
     holder = null;
-    timer = null;
+    expiresAtMs = 0;
     constructor(timeoutMs) {
         this.timeoutMs = timeoutMs;
     }
+    // Wall-clock lazy expiry — mirrors today-write-lock.ts. A setTimeout
+    // here would freeze across machine sleep (monotonic clock) and hold
+    // the lock long past its TTL after wake.
+    expireIfStale() {
+        if (this.holder && Date.now() >= this.expiresAtMs) {
+            logger.warn({ lockId: this.holder }, "Roadmap write lock expired by timeout");
+            this.holder = null;
+        }
+    }
     acquire() {
+        this.expireIfStale();
         if (this.holder) {
             logger.debug({ existingHolder: this.holder }, "Lock acquire rejected — already held");
             return { ok: false, holder: this.holder };
         }
         const lockId = randomUUID();
         this.holder = lockId;
-        this.timer = setTimeout(() => {
-            logger.warn({ lockId: this.holder }, "Roadmap write lock expired by timeout");
-            this.holder = null;
-            this.timer = null;
-        }, this.timeoutMs);
+        this.expiresAtMs = Date.now() + this.timeoutMs;
         logger.debug({ lockId }, "Roadmap write lock acquired");
         return { ok: true, lockId };
     }
     release(lockId) {
+        this.expireIfStale();
         if (!this.holder || this.holder !== lockId) {
             return false;
         }
         this.holder = null;
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
         logger.debug({ lockId }, "Roadmap write lock released");
         return true;
     }
     isHeldBy(lockId) {
+        this.expireIfStale();
         if (!this.holder) {
             return false;
         }
         return this.holder === lockId;
     }
     getHolder() {
+        this.expireIfStale();
         return this.holder;
     }
 }

package/dist/core/routine-acquisition-plan.d.ts

@@ -27,12 +27,45 @@
  * ```
  */
 import { type BackendId, type IntegrationKey, type IntegrationState } from "@aitne/shared";
-import { type RoutineWindowKey } from "./routine-windows.js";
+import { type RoutineWindowKey, type WindowSymbol } from "./routine-windows.js";
 /**
  * Per-mode predicate string the partial filters on. Matches the predicate
  * names used by `applyIntegrationModeFilter` in `@aitne/shared`.
  */
 export type AcquisitionFetchMode = "direct" | "delegated-same" | "delegated-cross" | "native";
+/**
+ * Why a (window × integration) cell was dropped at plan-assembly time —
+ * PREPASS_COST_REDUCTION_PLAN.md N3. Before N3 these drops vanished
+ * without a trace; the runner now writes one `skipped` audit row per
+ * (integration × reason) group so the deferred no-surface streak skip
+ * (R5) and the empty-window backoff (R4) can be sized from data.
+ *
+ *  - `no_state` — integration absent from the `readIntegrations` snapshot.
+ *  - `no_binding` — delegated/native mode with a null backend binding.
+ *  - `disabled` — integration mode is explicitly `disabled`.
+ *  - `unknown_mode` — unrecognized mode string (forward-compat guard).
+ *  - `no_window_query` — `WINDOW_QUERIES` has no cell for the
+ *    (window, integration, mode) tuple where one was expected — a
+ *    genuine catalog hole.
+ *  - `no_accounts` — direct-mode per-account fan-out with zero active
+ *    accounts for the integration.
+ *  - `no_fetch_targets` — Notion routine fetches require an explicit
+ *    user allowlist so the pre-pass cannot scan the whole workspace.
+ *  - `direct_inline_prefetch` — the catalog *deliberately* omits the
+ *    `direct` cell because the daemon serves that data inline
+ *    (ContextBuilder pre-fetch / REST route) and a pre-pass row would
+ *    double-fetch (cf. `cal_morning_7d` in routine-windows.ts). Working
+ *    as designed, so the runner does NOT write an audit row for it —
+ *    counting it as a drop would pollute the R4/R5 sizing data the N3
+ *    audit stream exists to provide.
+ */
+export type AcquisitionPlanDropReason = "no_state" | "no_binding" | "disabled" | "unknown_mode" | "no_window_query" | "no_accounts" | "no_fetch_targets" | "direct_inline_prefetch";
+/** One dropped (window × integration) cell. */
+export interface AcquisitionPlanDrop {
+    integration: IntegrationKey;
+    window: WindowSymbol;
+    reason: AcquisitionPlanDropReason;
+}
 export interface AcquisitionAccount {
     /**
      * Integration key the account belongs to. Today only `gmail` and
@@ -215,3 +248,16 @@ export interface AcquisitionSubPlan {
  * `scoped="<key>"` attribute and the partition itself.
  */
 export declare function splitAcquisitionPlanByIntegration(input: BuildAcquisitionPlanInput): readonly AcquisitionSubPlan[];
+/**
+ * `splitAcquisitionPlanByIntegration` + the drop trace —
+ * PREPASS_COST_REDUCTION_PLAN.md N3. The fan-out runner consumes this
+ * variant so every (window × integration) cell dropped at plan-assembly
+ * time can be surfaced as a `skipped` audit row instead of vanishing.
+ * Same purity / ordering / row-preservation contract as the wrapper
+ * above.
+ */
+export interface AcquisitionPlanAssembly {
+    subPlans: readonly AcquisitionSubPlan[];
+    drops: readonly AcquisitionPlanDrop[];
+}
+export declare function buildAcquisitionPlanAssembly(input: BuildAcquisitionPlanInput): AcquisitionPlanAssembly;

package/dist/core/routine-acquisition-plan.js

@@ -111,7 +111,7 @@ function integrationsForWindow(symbol) {
  */
 function resolveFetchMode(integration, state, sessionBackend) {
     if (!state)
-        return null;
+        return "no_state";
     switch (state.mode) {
         case "direct":
             return "direct";
@@ -131,21 +131,31 @@ function resolveFetchMode(integration, state, sessionBackend) {
                 }
                 return "delegated-cross";
             }
-            return null;
+            return "no_binding";
         case "native":
             // Native binding must match the session backend. Otherwise the
             // partial's `mode:native:<key>` block would be filtered out by
             // `applyIntegrationModeFilter` anyway — skip the row to avoid
-            // emitting a `<fetch>` that no branch can handle.
+            // emitting a `<fetch>` that no branch can handle. With
+            // per-integration backend routing (`resolveIntegrationBackend`)
+            // the caller passes the integration's own `nativeBackend` here, so
+            // in practice this branch only drops rows whose binding is null.
             if (state.nativeBackend === sessionBackend)
                 return "native";
-            return null;
+            return "no_binding";
         case "disabled":
-            return null;
+            return "disabled";
         default:
-            return null;
+            return "unknown_mode";
     }
 }
+/** Narrow a `resolveFetchMode` result to the fetch-mode side of the union. */
+function isFetchMode(value) {
+    return (value === "direct"
+        || value === "delegated-same"
+        || value === "delegated-cross"
+        || value === "native");
+}
 /**
  * Resolve the backend the sub-session for this integration MUST run on
  * so that the partial body's resolved `mode:` block has a working wire
@@ -170,9 +180,9 @@ function resolveFetchMode(integration, state, sessionBackend) {
  *    backend keeps the pre-pass tier predictable.
  *  - `direct`: REST via curl to the daemon — sub-session stays on
  *    `defaultBackend`.
- *  - `disabled` / no state: irrelevant (`resolveFetchMode` returns
- *    `null` and the row is dropped before backend matters); returning
- *    `defaultBackend` is a no-op safety default.
+ *  - `disabled` / no state: irrelevant (`resolveFetchMode` returns a
+ *    drop reason and the row is dropped before backend matters);
+ *    returning `defaultBackend` is a no-op safety default.
  *
  * The function is intentionally `null`-free — every call site benefits
  * from a guaranteed backend so the per-integration spawn path never has
@@ -277,6 +287,11 @@ function renderFetchRow(row) {
     if (row.label !== undefined) {
         parts.push(`label="${xmlAttr(row.label)}"`);
     }
+    // `collectFetchRows` only attaches a non-empty allowlist (empty drops
+    // the row with `no_fetch_targets`), so defined ⇒ renderable.
+    if (row.fetchTargets !== undefined) {
+        parts.push(`targets='${xmlQueryAttr(JSON.stringify(row.fetchTargets))}'`);
+    }
     // Single-quote delimiter on `query=` — see `xmlQueryAttr` rationale.
     parts.push(`query='${xmlQueryAttr(row.query)}'`);
     return `  <fetch ${parts.join(" ")} />`;
@@ -291,31 +306,65 @@ function renderFetchRow(row) {
  * monolithic block and the union of per-integration sub-plan blocks
  * carry bit-identical row sequences.
  */
-function collectFetchRows(input) {
+function collectFetchRows(input, 
+/**
+ * N3 observability hook — invoked once per dropped (window ×
+ * integration) cell with the drop reason. Optional so the render-only
+ * consumers (`buildAcquisitionPlan`, `rebuildSubPlanForBackend`) pay
+ * nothing.
+ */
+onDrop) {
     const rows = [];
     const specs = ROUTINE_WINDOWS[input.routine];
     for (const spec of specs) {
         const integrations = integrationsForWindow(spec.window);
         for (const integration of integrations) {
             const state = input.integrations[integration];
+            // Notion rows carry the user's fetch-target allowlist (undefined
+            // for every other integration). Resolved up here — before the mode
+            // guards — but the empty-allowlist drop stays AFTER them, so a
+            // disabled / unbound Notion row keeps its mode-derived drop reason
+            // and `no_fetch_targets` means exactly "active but unconfigured".
+            const fetchTargets = integration === "notion" ? (state?.fetchTargets ?? []) : undefined;
             // Per-integration backend resolution. Was: `input.sessionBackend`
             // (single backend for the whole plan), which caused `resolveFetchMode`
-            // to return `null` for native bindings on a different backend —
-            // silently dropping the row. With `resolveIntegrationBackend` the
-            // sub-session is routed to the integration's actual bound backend
-            // (`nativeBackend`, or `delegatedBackend` for userManagedConnector),
-            // and `resolveFetchMode` then matches on the correct backend so the
+            // to drop rows for native bindings on a different backend. With
+            // `resolveIntegrationBackend` the sub-session is routed to the
+            // integration's actual bound backend (`nativeBackend`, or
+            // `delegatedBackend` for userManagedConnector), and
+            // `resolveFetchMode` then matches on the correct backend so the
             // row survives. The runner uses `requiredBackend` (bubbled up via
             // `FetchRow`) to spawn each sub-session on the right backend via
             // `BackendRouter.resolveBinding({ requestedBackendId })`.
             const requiredBackend = resolveIntegrationBackend(integration, state, input.sessionBackend);
             const fetchMode = resolveFetchMode(integration, state, requiredBackend);
-            if (fetchMode === null)
+            if (!isFetchMode(fetchMode)) {
+                onDrop?.({ integration, window: spec.window, reason: fetchMode });
                 continue;
+            }
             const queryTemplate = lookupQuery(spec.window, integration, fetchMode);
-            if (queryTemplate === undefined)
+            if (queryTemplate === undefined) {
+                // `integrationsForWindow` only yields integrations present in
+                // the catalog for this window, so an undefined template means
+                // the MODE cell is missing. For `direct` that is the documented
+                // intentional pattern (cf. `cal_morning_7d` in
+                // routine-windows.ts): the daemon serves the data inline, so the
+                // pre-pass must not double-fetch. Any other mode is a genuine
+                // catalog hole.
+                onDrop?.({
+                    integration,
+                    window: spec.window,
+                    reason: fetchMode === "direct"
+                        ? "direct_inline_prefetch"
+                        : "no_window_query",
+                });
                 continue;
+            }
             const query = substituteAcquisitionTokens(queryTemplate, input.timestamps);
+            if (fetchTargets !== undefined && fetchTargets.length === 0) {
+                onDrop?.({ integration, window: spec.window, reason: "no_fetch_targets" });
+                continue;
+            }
             // perAccount fan-out is meaningful only in `direct` mode, where the
             // daemon stores per-account OAuth tokens and polls each. In
             // `delegated-same` / `delegated-cross` / `native` the integration's
@@ -332,6 +381,9 @@ function collectFetchRows(input) {
             // surface so the partials never need to defend against them.
             if (spec.perAccount && fetchMode === "direct") {
                 const accountRows = input.accounts.filter((a) => a.integration === integration);
+                if (accountRows.length === 0) {
+                    onDrop?.({ integration, window: spec.window, reason: "no_accounts" });
+                }
                 for (const account of accountRows) {
                     rows.push({
                         integration,
@@ -340,6 +392,7 @@ function collectFetchRows(input) {
                         accountId: account.accountId,
                         label: account.label,
                         query,
+                        fetchTargets,
                         requiredBackend,
                     });
                 }
@@ -350,6 +403,7 @@ function collectFetchRows(input) {
                     mode: fetchMode,
                     window: spec.window,
                     query,
+                    fetchTargets,
                     requiredBackend,
                 });
             }
@@ -418,9 +472,13 @@ export function buildAcquisitionPlan(input) {
  * `scoped="<key>"` attribute and the partition itself.
  */
 export function splitAcquisitionPlanByIntegration(input) {
-    const rows = collectFetchRows(input);
+    return buildAcquisitionPlanAssembly(input).subPlans;
+}
+export function buildAcquisitionPlanAssembly(input) {
+    const drops = [];
+    const rows = collectFetchRows(input, (drop) => drops.push(drop));
     if (rows.length === 0)
-        return [];
+        return { subPlans: [], drops };
     // Group rows by integration while keeping insertion order inside each
     // group (the `ROUTINE_WINDOWS` walk order from `collectFetchRows`).
     const groups = new Map();
@@ -453,5 +511,5 @@ export function splitAcquisitionPlanByIntegration(input) {
             requiredBackend,
         });
     }
-    return out;
+    return { subPlans: out, drops };
 }

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

@@ -84,10 +84,13 @@ function isFetchFailedWithStatus(err, predicate) {
 /**
  * Sentinel error-status strings the runner classifies as deterministic
  * (no point retrying — the next attempt re-emits the same bytes and
- * re-trips the same gate). Centralised so the partial author (who emits
- * these strings into `errors[*].status`), the runner (which interprets
- * them here), and any future telemetry that filters on them all reference
- * the same vocabulary.
+ * re-trips the same gate). The emitting side of the contract is the
+ * agent profile's `fetch-failed` bullet
+ * (`agent-assets/agent-profiles/routine-fetch-window.md`), which
+ * instructs the agent to set `status:"permission-denied"` when its own
+ * permission layer blocked a tool call; the runner interprets the
+ * strings here, and any future telemetry that filters on them
+ * references the same vocabulary.
  *
  * See `RETRY_REASONS.DETERMINISTIC_FAILURE` for the rationale and the
  * specific gates these sentinels are paired with — and for why