@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/dispatcher.js

@@ -1,4 +1,4 @@
-import { EventPriority, createEvent, getAgentDayBoundsUtc, isMessageEvent, isRoutineEvent, isAgentTaskEvent, isScheduledEvent, isScheduledBrowserTaskEvent, isScheduledDmEvent, isKnowledgeImportEvent, parseSqliteUtcMs, } from "@aitne/shared";
+import { EventPriority, createEvent, getAgentDayBoundsUtc, isBackendId, isMessageEvent, isRoutineEvent, isAgentTaskEvent, isScheduledEvent, isScheduledBrowserTaskEvent, isScheduledBackgroundTaskEvent, isScheduledDmEvent, isTaskDeliveryEvent, isKnowledgeImportEvent, parseSqliteUtcMs, } from "@aitne/shared";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
@@ -23,15 +23,15 @@ export { parseStage2Verdict, };
 import { PromptAssembler } from "./dispatcher-prompt.js";
 import { DispatcherErrorRouter } from "./dispatcher-error-handling.js";
 import { ResultProcessor } from "./dispatcher-result-processor.js";
-import { HourlyCheckCoordinator } from "./dispatcher-hourly-check.js";
+import { ActivityScanCoordinator } from "./dispatcher-activity-scan.js";
 import { morningRoutineRanToday } from "../bootstrap/schedule-helpers.js";
 /**
  * Routine names that depend on `routine.morning_routine` having completed
  * successfully for the current agent-day. The pre-routine gate in
  * `dispatch()` enqueues a morning_routine wake and skips the dependent
- * routine when the predicate trips — hourly_check is gated separately
- * inside `HourlyCheckCoordinator.trigger` because it has its own entry
- * point (`triggerHourlyCheck`) before any event hits the bus.
+ * routine when the predicate trips — activity_scan is gated separately
+ * inside `ActivityScanCoordinator.trigger` because it has its own entry
+ * point (`triggerActivityScan`) before any event hits the bus.
  */
 const REVIEW_ROUTINES_REQUIRING_MORNING = new Set([
     "evening_review",
@@ -43,8 +43,10 @@ import { MorningRoutinePipelineOrchestrator } from "./morning/orchestrator.js";
 import { DailyJournalComposer } from "./morning/daily-journal-composer.js";
 import { randomUUID } from "node:crypto";
 import { RoutineFetchWindowRunner } from "./routine-fetch-window-runner.js";
+import { AutonomousSpawnGate, } from "./spawn-gates.js";
 import { ScheduledTaskRunner, SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS, } from "./dispatcher-scheduled-tasks.js";
 import { MessageHandler } from "./dispatcher-message-handler.js";
+import { TASK_DELIVERY_GATE_KEYS, handleTaskDeliveryInsideGate, } from "./dispatcher-task-delivery.js";
 export { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS };
 const CURRENT_SETUP_MODE_STATE_KEY = "current_setup_mode";
 export class EventDispatcher {
@@ -128,6 +130,14 @@ export class EventDispatcher {
      * instead of leaving the row silently flipped to `failed` in the DB.
      */
     browserTaskTerminalNotifier = null;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — the dispatcher routes
+     * `scheduled.background_task` events to this runner. Wired at startup
+     * from `bootstrap/event-pipeline.ts` via `setBackgroundTaskRunner`.
+     * Null when the runner factory has not landed — the dispatch branch
+     * flips the row to `failed (runner_unavailable)` so it doesn't park.
+     */
+    backgroundTaskRunner = null;
     /**
      * Current setup mode — scope-agnostic flag that survives internal
      * direct-message session refresh (day boundary, stale flag, etc). Previously this
@@ -153,42 +163,42 @@ export class EventDispatcher {
      *  keep their own lane. SCHEDULED-DM-IMPLEMENTATION-PLAN §3.6 — also
      *  used by `scheduled.dm` to acquire BOTH owner-facing scopes in
      *  lex-sorted (deadlock-free) order. */
-    sessionGates = new SessionGateRegistry();
+    sessionGates;
     /** Dedup guard: timestamp of the last roadmap_refresh emission */
     lastRoadmapRefreshEmitMs = 0;
     morningRoutineInProgress = false;
-    hourlyCheckInProgress = false;
+    activityScanInProgress = false;
     /**
      * Wall-clock timestamp (ms since epoch) of the most recent flip of
-     * `hourlyCheckInProgress` to `true`, or `null` when the flag is false.
+     * `activityScanInProgress` to `true`, or `null` when the flag is false.
      *
-     * Paired with `HOURLY_CHECK_FLAG_MAX_AGE_MS` to break the silent-stall
+     * Paired with `ACTIVITY_SCAN_FLAG_MAX_AGE_MS` to break the silent-stall
      * pattern where the flag is set true at enqueue time but the matching
      * `dispatchSafe` finally never runs — currently possible when the
      * EventBus evicts/drops the queued routine event under `put()` pressure
      * (heap-js drops the lowest-priority entry silently when `heap.size() >=
      * maxSize=1000`). Without the timestamp the flag stays `true` until
      * process restart and every subsequent hourly tick short-circuits with
-     * `hourly_check_in_progress`.
+     * `activity_scan_in_progress`.
      *
-     * Read side (`isHourlyCheckInProgress` callback below) checks the age
+     * Read side (`isActivityScanInProgress` callback below) checks the age
      * and auto-clears when it exceeds the bound, surfacing the recovery via
      * a warn log so the operator sees the EventBus pressure event.
      */
-    hourlyCheckInProgressAt = null;
+    activityScanInProgressAt = null;
     /**
-     * Upper bound for how long `hourlyCheckInProgress=true` can plausibly
+     * Upper bound for how long `activityScanInProgress=true` can plausibly
      * be valid before we treat it as stuck and force-clear.
      *
-     * Sized generously above the realistic Stage-3 hourly_check ceiling
-     * (fetch_window pre-pass ~30–60 s + Sonnet hourly_check session
+     * Sized generously above the realistic Stage-3 activity_scan ceiling
+     * (fetch_window pre-pass ~30–60 s + Sonnet activity_scan session
      * ~1–3 min) so a slow but normal run is never falsely cleared. Sized
      * well below an entire agent-day so a stuck flag recovers within a
      * single hourly cron cycle's worst case (default cadence 60 min).
      * The 30-minute window is comfortably outside any plausible "still
      * running" interpretation and inside one full hourly slot.
      */
-    static HOURLY_CHECK_FLAG_MAX_AGE_MS = 30 * 60 * 1000;
+    static ACTIVITY_SCAN_FLAG_MAX_AGE_MS = 30 * 60 * 1000;
     /**
      * P22 §3.4 — wired by `index.ts` after the daemon's data dir + skills root
      * are known. Returns a `{runId, runToken, workdirPath, targetSkills}` tuple
@@ -216,12 +226,19 @@ export class EventDispatcher {
      *  and older code paths that don't wire the store. When null, the
      *  dispatcher skips attachment staging + outbound collection. */
     attachmentStore = null;
+    /** Injected lazily via `setTaskDeliveryAssetResolver` — optional.
+     *  Resolves a task's deliverable assets (browser-task screenshots +
+     *  worker-written files) to outbound attachments for the `task.delivery`
+     *  idle + active branches (the ingest hook is constructed after this
+     *  dispatcher, so it is wired post-construction like the attachment
+     *  store). When null, task-delivery DMs are text-only. */
+    taskDeliveryAssetResolver = null;
     /** Injected lazily via `setDelegatedSyncRefresh` — optional. When null,
-     *  hourly check fires without first refreshing delegated-mode snapshots,
+     *  activity scan fires without first refreshing delegated-mode snapshots,
      *  matching the pre-Phase-9 behaviour. Wired in production when at
      *  least one integration is in delegated mode. See
      *  `docs/design/appendices/delegated-sync-opt-in.md` and the worker's
-     *  `runDisabledCadencesForHourlyCheck` method. */
+     *  `runDisabledCadencesForActivityScan` method. */
     delegatedSyncRefresh = null;
     /**
      * Injected lazily via `setQueueMorningRoutineWake` (wired in `index.ts`
@@ -240,7 +257,7 @@ export class EventDispatcher {
      * Injected lazily via `setEventBroadcaster` — optional. When wired, the
      * dispatcher emits `routine_started` / `routine_completed` SSE events at
      * the `dispatchSafe` chokepoint so the dashboard can render real-time
-     * progress for autonomous routines (morning_routine, hourly_check,
+     * progress for autonomous routines (morning_routine, activity_scan,
      * roadmap_refresh, evening/weekly/monthly reviews, etc.).
      *
      * Failure to broadcast is non-fatal: the throw is swallowed and logged
@@ -317,21 +334,38 @@ export class EventDispatcher {
      */
     resultProcessor;
     /**
-     * Phase D-2 coordinator: owns `triggerHourlyCheck` and the
+     * Phase D-2 coordinator: owns `triggerActivityScan` and the
      * cost-reduction-structural §B three-stage gate. Borrows live
-     * accessors for the dispatcher's `hourlyCheckInProgress` flag so the
+     * accessors for the dispatcher's `activityScanInProgress` flag so the
      * pre-existing C1 atomic check-and-set semantics survive the split.
      */
     /**
      * docs/design/appendices/routine-data-acquisition.md Phase 4 / D1 — shared pre-pass
-     * runner for `routine.fetch_window`. Injected into HourlyCheckCoordinator
+     * runner for `routine.fetch_window`. Injected into ActivityScanCoordinator
      * (D3), MorningRoutineRunner (D2), and ScheduledTaskRunner (D4) so
      * every routine that has rows in `ROUTINE_WINDOWS` gets the same
      * fetcher session ahead of its parent dispatch. Pure helper, no
      * mutable state of its own.
      */
     fetchWindowRunner;
-    hourlyCheck;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — offline (backend-API-host DNS) +
+     * cached-auth spawn gate for autonomous sessions. Shared with the
+     * pre-pass fan-out runner so both layers reuse one DNS verdict cache.
+     */
+    spawnGate;
+    /**
+     * Last spawn-gate skip *audit write* per (schedule-or-type, reason) —
+     * ms epoch. A released schedule row is re-claimed by the
+     * ScheduleWatcher every poll tick (default 5s), so an hours-long
+     * offline window would otherwise INSERT thousands of identical
+     * `result='skipped'` rows. The DB row release/claim churn is bounded
+     * (UPDATEs to one row); the audit INSERT is what must be throttled.
+     * In-memory on purpose: worst case after a restart is one extra row.
+     */
+    spawnGateSkipAuditAt = new Map();
+    static SPAWN_GATE_SKIP_AUDIT_THROTTLE_MS = 10 * 60 * 1000;
+    activityScan;
     /**
      * Phase D-2 coordinator: owns morning-routine execution end-to-end
      * (lock acquisition, prompt-variant selection, retry chain, today.md
@@ -363,7 +397,7 @@ export class EventDispatcher {
      * thin shims that forward into this handler.
      */
     messageHandler;
-    constructor(eventBus, agentRouter, contextBuilder, getTaskFlow, notificationMgr, sessionMgr, messageRecorder, audit, db, config, todayWriteLock, services, roadmapWriteLock, writeTracker) {
+    constructor(eventBus, agentRouter, contextBuilder, getTaskFlow, notificationMgr, sessionMgr, messageRecorder, audit, db, config, todayWriteLock, services, roadmapWriteLock, writeTracker, sessionGates) {
         this.eventBus = eventBus;
         this.agentRouter = agentRouter;
         this.contextBuilder = contextBuilder;
@@ -378,6 +412,7 @@ export class EventDispatcher {
         this.services = services;
         this.roadmapWriteLock = roadmapWriteLock;
         this.writeTracker = writeTracker;
+        this.sessionGates = sessionGates ?? new SessionGateRegistry();
         this.reactiveSem = new Semaphore(config.maxReactiveSessions);
         this.autonomousSem = new Semaphore(config.maxConcurrentSessions);
         const messageColumns = new Set(this.db.pragma("table_info(messages)").map((column) => column.name));
@@ -407,10 +442,17 @@ export class EventDispatcher {
             recordExecutionOutcome: (event, outcome) => this.agentExecutionTracker?.recordOutcome(event.correlationId, outcome),
         });
         // docs/design/appendices/routine-data-acquisition.md Phase 4 / D1 — shared pre-pass
-        // runner consumed by HourlyCheckCoordinator (D3), MorningRoutineRunner
+        // runner consumed by ActivityScanCoordinator (D3), MorningRoutineRunner
         // (D2), and ScheduledTaskRunner.executeDefault (D4). Constructed
         // before all three so it can be injected as a dep rather than
         // lazily resolved.
+        // PREPASS_COST_REDUCTION_PLAN.md N2 — shared offline/auth spawn gate.
+        // One instance for the dispatcher's autonomous-event gate AND the
+        // pre-pass fan-out runner so the per-host DNS verdict cache (~60s)
+        // is shared across both layers within a tick.
+        this.spawnGate = new AutonomousSpawnGate(this.db, {
+            authFreshnessMs: this.config.authPreflightFreshnessMs,
+        });
         this.fetchWindowRunner = new RoutineFetchWindowRunner({
             db: this.db,
             config: this.config,
@@ -418,6 +460,7 @@ export class EventDispatcher {
             agentRouter: this.agentRouter,
             audit: this.audit,
             prompt: this.prompt,
+            spawnGate: this.spawnGate,
             getActiveMailAccounts: () => this.getActiveMailAccounts(),
             // Live accessor so the SSE broadcaster wired later via
             // `setEventBroadcaster` (after dispatcher construction in
@@ -427,7 +470,7 @@ export class EventDispatcher {
             // skips its pre-pass progress emits cleanly.
             getEventBroadcaster: () => this.eventBroadcaster,
         });
-        this.hourlyCheck = new HourlyCheckCoordinator({
+        this.activityScan = new ActivityScanCoordinator({
             db: this.db,
             config: this.config,
             eventBus: this.eventBus,
@@ -438,27 +481,27 @@ export class EventDispatcher {
             prompt: this.prompt,
             fetchWindowRunner: this.fetchWindowRunner,
             getDelegatedSyncRefresh: () => this.delegatedSyncRefresh,
-            setHourlyCheckInProgress: (value) => {
-                this.hourlyCheckInProgress = value;
-                this.hourlyCheckInProgressAt = value ? Date.now() : null;
+            setActivityScanInProgress: (value) => {
+                this.activityScanInProgress = value;
+                this.activityScanInProgressAt = value ? Date.now() : null;
             },
-            isHourlyCheckInProgress: () => {
-                if (!this.hourlyCheckInProgress)
+            isActivityScanInProgress: () => {
+                if (!this.activityScanInProgress)
                     return false;
-                // Stale-flag recovery — see `hourlyCheckInProgressAt` doc-comment.
+                // Stale-flag recovery — see `activityScanInProgressAt` doc-comment.
                 // The branch fires only when an enqueued event never reached
                 // `dispatchSafe`'s finally (EventBus eviction is the realistic
                 // cause; a future code path that forgets to reset the flag would
                 // also self-heal here within one cron cycle).
-                if (this.hourlyCheckInProgressAt !== null) {
-                    const ageMs = Date.now() - this.hourlyCheckInProgressAt;
-                    if (ageMs > EventDispatcher.HOURLY_CHECK_FLAG_MAX_AGE_MS) {
+                if (this.activityScanInProgressAt !== null) {
+                    const ageMs = Date.now() - this.activityScanInProgressAt;
+                    if (ageMs > EventDispatcher.ACTIVITY_SCAN_FLAG_MAX_AGE_MS) {
                         logger.warn({
                             ageMs,
-                            maxAgeMs: EventDispatcher.HOURLY_CHECK_FLAG_MAX_AGE_MS,
-                        }, "hourlyCheckInProgress flag exceeded max age — auto-clearing (likely EventBus drop or missed dispatchSafe finally)");
-                        this.hourlyCheckInProgress = false;
-                        this.hourlyCheckInProgressAt = null;
+                            maxAgeMs: EventDispatcher.ACTIVITY_SCAN_FLAG_MAX_AGE_MS,
+                        }, "activityScanInProgress flag exceeded max age — auto-clearing (likely EventBus drop or missed dispatchSafe finally)");
+                        this.activityScanInProgress = false;
+                        this.activityScanInProgressAt = null;
                         return false;
                     }
                 }
@@ -573,7 +616,7 @@ export class EventDispatcher {
             diagnoseTodayMdState: () => this.scheduledTasks.diagnoseTodayMdState(),
             isRoadmapStale: () => this.isRoadmapStale(),
             emitRoadmapRefresh: (source) => this.emitRoadmapRefresh(source),
-            triggerHourlyCheck: (source) => this.triggerHourlyCheck(source),
+            triggerActivityScan: (source) => this.triggerActivityScan(source),
             pipelineOrchestrator,
         });
         this.scheduledTasks = new ScheduledTaskRunner({
@@ -617,6 +660,8 @@ export class EventDispatcher {
             getBangCommandRegistry: () => this.bangCommandRegistry,
             getPurchaseHandler: () => this.purchaseHandler,
             getFinalConfirmHandler: () => this.finalConfirmHandler,
+            getBackgroundTaskRunner: () => this.backgroundTaskRunner,
+            getBrowserTaskRunner: () => this.browserTaskRunner,
             getCurrentSetupMode: () => this.currentSetupMode,
             beginSetupMode: (mode) => this.beginSetupMode(mode),
             lookupCustomBangCommandForEvent: (event) => this.lookupCustomBangCommandForEvent(event),
@@ -684,6 +729,15 @@ export class EventDispatcher {
     getBrowserTaskRunner() {
         return this.browserTaskRunner;
     }
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — wire the generic
+     * background-task runner so the `scheduled.background_task` dispatch
+     * branch can hand fire-time events to it. Pairs with the
+     * `event-pipeline.ts` `createBackgroundTaskRunner` factory call.
+     */
+    setBackgroundTaskRunner(runner) {
+        this.backgroundTaskRunner = runner;
+    }
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §7 — wire the terminal-state DM
      * emitter used by the `scheduled.browser_task` failure paths (see
@@ -713,6 +767,14 @@ export class EventDispatcher {
     setAttachmentStore(store) {
         this.attachmentStore = store;
     }
+    /** BACKGROUND_TASK_RUNNER_DESIGN.md Phase 1 (delivery assets) — inject the
+     *  asset resolver used by the `task.delivery` idle + active branches to
+     *  attach a task's deliverable files (screenshots, PDF/PPTX/PNG/docs)
+     *  inline. Wired post-construction because the underlying
+     *  dashboard-ingest hook is built after this dispatcher. */
+    setTaskDeliveryAssetResolver(resolver) {
+        this.taskDeliveryAssetResolver = resolver;
+    }
     /** Inject the local-Whisper voice transcriber. Optional — when unset,
      *  inbound audio attachments are passed to the backend with a path-only
      *  reference (the pre-feature behaviour). */
@@ -721,7 +783,7 @@ export class EventDispatcher {
     }
     /**
      * Inject the delegated-sync refresh callback. Called from
-     * `triggerHourlyCheck` before the gate decision so any cadence the
+     * `triggerActivityScan` before the gate decision so any cadence the
      * operator left opted-OUT (post-Phase-9 default) populates fresh
      * Gmail / Notion observations the agent can then consume.
      *
@@ -731,7 +793,7 @@ export class EventDispatcher {
      * dispatcher holding a stale reference.
      *
      * Pass `null` to detach (e.g. when no delegated integration exists).
-     * The hourly check then proceeds without a refresh — equivalent to the
+     * The activity scan then proceeds without a refresh — equivalent to the
      * pre-injection behaviour.
      */
     setDelegatedSyncRefresh(fn) {
@@ -739,7 +801,7 @@ export class EventDispatcher {
     }
     /**
      * Wire the scheduler's `queueMorningRoutineWake` so the pre-routine
-     * gate (hourly_check + evening/weekly/monthly review) can self-recover
+     * gate (activity_scan + evening/weekly/monthly review) can self-recover
      * after a missed 04:00 cron fire. Wired once in `index.ts` after both
      * the dispatcher and scheduler are constructed; passing `null` detaches.
      * When unset, the gate logs a warning and still skips the dependent
@@ -766,6 +828,16 @@ export class EventDispatcher {
     setAgentExecutionTracker(tracker) {
         this.agentExecutionTracker = tracker;
     }
+    /**
+     * Resolve the user-Agent slug owning an in-flight firing, for stamping
+     * `agent_id` into quiet-hours-deferred DM rows (QUIET_HOURS_HARDENING_PLAN
+     * Phase 1 — the `/api/notify` gate coalesces per Agent so an hourly Agent
+     * firing five times overnight yields one combined DM). `null` when no
+     * tracker is wired or no execution is active for the correlation id.
+     */
+    agentIdForCorrelation(correlationId) {
+        return this.agentExecutionTracker?.currentAgentId(correlationId) ?? null;
+    }
     /**
      * Open an execution row for an agent-resolvable firing (§8.1), called from
      * `dispatchSafe` after the setup / cost gates pass so a skipped firing never
@@ -974,7 +1046,7 @@ export class EventDispatcher {
     /**
      * Enter setup mode. Called from `POST /setup/start` so the warm gate
      * engages the moment the user opens the dashboard setup flow — before any
-     * agent turn runs — so concurrent hourly_check / morning routine / scheduled
+     * agent turn runs — so concurrent activity_scan / morning routine / scheduled
      * wake work cannot race with the setup conversation. Persisted to
      * `runtime_state` so the flag survives daemon restart.
      */
@@ -1035,8 +1107,8 @@ export class EventDispatcher {
         if (this.morningRoutineInProgress) {
             executions.push({ kind: "routine", key: "morning_routine" });
         }
-        if (this.hourlyCheckInProgress) {
-            executions.push({ kind: "routine", key: "hourly_check" });
+        if (this.activityScanInProgress) {
+            executions.push({ kind: "routine", key: "activity_scan" });
         }
         const runningTasks = this.db
             .prepare(`SELECT id, task_type, task_description
@@ -1054,7 +1126,7 @@ export class EventDispatcher {
         return executions;
     }
     /**
-     * Gate for autonomous background work (cron routines, hourly_check,
+     * Gate for autonomous background work (cron routines, activity_scan,
      * scheduled wake tasks, startup catchup, calendar-poller reactive events).
      *
      * Two layers:
@@ -1143,7 +1215,7 @@ export class EventDispatcher {
     /**
      * Check whether this autonomous event should be skipped because the daily
      * autonomous cost cap has been exceeded. Uses priority-based degradation:
-     * hourly_check (lowest priority, skipped first) → roadmap_refresh →
+     * activity_scan (lowest priority, skipped first) → roadmap_refresh →
      * evening_review → morning_routine (highest, last to be cut).
      *
      * Lower-priority events are skipped at 100% of cap; higher-priority events
@@ -1169,7 +1241,7 @@ export class EventDispatcher {
             ? event.routine
             : null;
         const thresholds = {
-            hourly_check: 1.0, // skipped first (at 100% of cap)
+            activity_scan: 1.0, // skipped first (at 100% of cap)
             roadmap_refresh: 1.2, // skipped at 120%
             evening_review: 1.5, // skipped at 150%
             morning_routine: 2.0, // last to be cut (only at 200%)
@@ -1177,6 +1249,45 @@ export class EventDispatcher {
         const threshold = routine ? (thresholds[routine] ?? 1.0) : 1.0;
         return todayCost >= cap * threshold;
     }
+    /**
+     * Resolve the candidate backends for an autonomous event and run the
+     * N2 spawn gates against them. Fail-open on every internal error
+     * (binding resolution included) — the gate exists to save sessions
+     * that would deterministically fail, never to block live ones.
+     * Returns `null` when the gate could not be evaluated.
+     */
+    async evaluateAutonomousSpawnGate(event) {
+        try {
+            // Scheduled rows / integration cron events can pin a backend via
+            // `requestedBackendId`; the router's backend-only override branch
+            // then routes to exactly that backend WITHOUT a fallback. Mirror
+            // that contract here: gating a pinned row on the *default* binding
+            // would keep skipping it while its pinned backend is healthy (and
+            // re-skip every watcher tick until the wrong backend recovered).
+            const pinned = event
+                .requestedBackendId;
+            if (typeof pinned === "string" && isBackendId(pinned)) {
+                return await this.spawnGate.evaluate([pinned]);
+            }
+            // No pin → event-type default binding. Process-key overrides that
+            // some dispatch branches apply (e.g. `agent.task`, morning stage
+            // keys) are approximated by this default: a mismatch is possible
+            // only when the operator routed that specific process key to a
+            // different backend, and the gate's fail-open posture bounds the
+            // cost to one tick of latency during a partial outage.
+            const binding = this.agentRouter.resolveBinding(event);
+            const candidates = [binding.main.backendId];
+            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, eventType: event.type }, "Spawn-gate binding resolution failed — failing open");
+            return null;
+        }
+    }
     async handleEvent(event) {
         try {
             await this.handleEventInner(event);
@@ -1198,12 +1309,12 @@ export class EventDispatcher {
         }
     }
     /**
-     * Public entry point. Delegates to the HourlyCheckCoordinator.
+     * Public entry point. Delegates to the ActivityScanCoordinator.
      * The dispatcher keeps the wrapper because tests + the cron entry
-     * call `dispatcher.triggerHourlyCheck(source, opts)` directly.
+     * call `dispatcher.triggerActivityScan(source, opts)` directly.
      */
-    async triggerHourlyCheck(source, options = {}) {
-        return this.hourlyCheck.trigger(source, options);
+    async triggerActivityScan(source, options = {}) {
+        return this.activityScan.trigger(source, options);
     }
     /**
      * Advisory check: is a morning routine execution or retry currently in
@@ -1218,7 +1329,7 @@ export class EventDispatcher {
      *
      * Public (not private) because Phase 4's `AuthHealthMonitor.checkAll()`
      * shares the same skip-while-morning-routine-active invariant as the
-     * hourly check, and injects this method as an option so a probe tick
+     * activity scan, and injects this method as an option so a probe tick
      * running concurrently with morning routine can no-op cleanly. See
      * `docs/design/09-safety-cost.md` §9.5.4.
      */
@@ -1257,6 +1368,38 @@ export class EventDispatcher {
                 .run(event.scheduleId);
         }
     }
+    /**
+     * Throttle for spawn-gate skip audit rows. A released schedule row is
+     * due immediately, so the watcher re-claims it every poll tick (5s
+     * default) for the whole outage — without this, one offline day per
+     * pending row writes ~17k identical agent_actions rows. Keyed by
+     * (schedule id | event type) × reason so distinct routines and
+     * distinct reasons each still get their own first row, and a reason
+     * flip (offline → auth_unhealthy) is recorded promptly.
+     */
+    shouldWriteSpawnGateSkipAudit(event, reason) {
+        const subject = isScheduledEvent(event) && event.scheduleId
+            ? `schedule:${event.scheduleId}`
+            : `type:${event.type}`;
+        const key = `${subject}|${reason}`;
+        const now = Date.now();
+        const last = this.spawnGateSkipAuditAt.get(key);
+        if (last !== undefined
+            && now - last < EventDispatcher.SPAWN_GATE_SKIP_AUDIT_THROTTLE_MS) {
+            return false;
+        }
+        // Opportunistic prune so a long outage across many schedule rows
+        // cannot grow the map unbounded.
+        if (this.spawnGateSkipAuditAt.size > 256) {
+            for (const [k, ts] of this.spawnGateSkipAuditAt) {
+                if (now - ts >= EventDispatcher.SPAWN_GATE_SKIP_AUDIT_THROTTLE_MS) {
+                    this.spawnGateSkipAuditAt.delete(k);
+                }
+            }
+        }
+        this.spawnGateSkipAuditAt.set(key, now);
+        return true;
+    }
     async dispatchSafe(event) {
         const trigger = this.isReactive(event) ? "reactive" : "autonomous";
         const startMs = Date.now();
@@ -1294,7 +1437,7 @@ export class EventDispatcher {
                 }
                 // Autonomous daily cost cap — safety net distinct from removed Phase 9
                 // maxDailyCostUsd (which blanket-blocked all sessions including DMs).
-                // Reactive sessions always pass. Degradation priority: hourly_check is
+                // Reactive sessions always pass. Degradation priority: activity_scan is
                 // skipped first, morning_routine last.
                 if (this.shouldSkipForCostCap(event)) {
                     this.releaseClaimedSchedule(event);
@@ -1302,6 +1445,36 @@ export class EventDispatcher {
                     logger.info({ eventType: event.type, source: event.source }, "Event skipped — autonomous daily cost cap exceeded");
                     return;
                 }
+                // PREPASS_COST_REDUCTION_PLAN.md N2 — offline + auth spawn gates.
+                // Skip the spawn only when EVERY candidate backend (main +
+                // fallback) is non-viable: backend API host unresolvable
+                // (`reason='offline'`) or auth confirmed bad in a fresh cache
+                // (`reason='auth_unhealthy'`). A scheduled row is released back
+                // to `pending` so the next watcher tick retries — the skip costs
+                // at most one tick of latency, and only during a window where
+                // the session would have failed anyway. Reactive work (user DMs)
+                // is exempt by construction: a user-visible attempt + error beats
+                // silent suppression.
+                const gateDecision = await this.evaluateAutonomousSpawnGate(event);
+                if (gateDecision?.skip) {
+                    this.releaseClaimedSchedule(event);
+                    const reason = gateDecision.reason ?? "offline";
+                    if (this.shouldWriteSpawnGateSkipAudit(event, reason)) {
+                        this.audit.logSkip(event, reason, trigger, {
+                            spawnGate: { backends: gateDecision.backends },
+                        });
+                        logger.info({
+                            eventType: event.type,
+                            source: event.source,
+                            reason,
+                            backends: gateDecision.backends,
+                        }, "Event skipped — autonomous spawn gate (offline / auth-unhealthy backends)");
+                    }
+                    else {
+                        logger.debug({ eventType: event.type, source: event.source, reason }, "Event skipped — spawn gate (audit row throttled, same skip already recorded)");
+                    }
+                    return;
+                }
             }
             // AGENT_DEFINITIONS_DESIGN.md §8.1 — open the execution row after the
             // setup / cost gates pass (a gated firing records no execution) and
@@ -1350,9 +1523,9 @@ export class EventDispatcher {
             await this.errorRouter.handleError(event, err);
         }
         finally {
-            if (isRoutineEvent(event) && event.routine === "hourly_check") {
-                this.hourlyCheckInProgress = false;
-                this.hourlyCheckInProgressAt = null;
+            if (isRoutineEvent(event) && event.routine === "activity_scan") {
+                this.activityScanInProgress = false;
+                this.activityScanInProgressAt = null;
             }
         }
     }
@@ -1428,7 +1601,7 @@ export class EventDispatcher {
                 await this.scheduledTasks.executeSkillCurationRoutine(event);
             }
             else {
-                // hourly_check, evening_review, weekly_review, monthly_review
+                // activity_scan, evening_review, weekly_review, monthly_review
                 // Tier is resolved from process-key defaults by BackendRouter.
                 await this.scheduledTasks.executeDefault(event);
             }
@@ -1472,6 +1645,19 @@ export class EventDispatcher {
                 await this.scheduledTasks.executeScheduledTask(event);
             });
         }
+        else if (isTaskDeliveryEvent(event)) {
+            await this.runWithSessionGates([...TASK_DELIVERY_GATE_KEYS], async () => {
+                await handleTaskDeliveryInsideGate({
+                    db: this.db,
+                    config: this.config,
+                    notificationMgr: this.notificationMgr,
+                    executeScheduledTask: (scheduledEvent) => this.scheduledTasks.executeScheduledTask(scheduledEvent),
+                    ...(this.taskDeliveryAssetResolver
+                        ? { resolveAssets: this.taskDeliveryAssetResolver }
+                        : {}),
+                }, event);
+            });
+        }
         else if (isAgentTaskEvent(event)) {
             // scheduled.task — no gate, retains existing parallel-execution
             // behavior. (scheduled.dm subtype is handled above.)
@@ -1484,10 +1670,49 @@ export class EventDispatcher {
             // logic; here we wire it into the agent_schedule lifecycle.
             await this.handleScheduledBrowserTaskDispatch(event);
         }
+        else if (isScheduledBackgroundTaskEvent(event)) {
+            // BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — fire-time row creation +
+            // runner handoff, wired into the agent_schedule lifecycle exactly
+            // like scheduled.browser_task.
+            await this.handleScheduledBackgroundTaskDispatch(event);
+        }
         else {
             await this.scheduledTasks.executeDefault(event);
         }
     }
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — dispatch branch for
+     * `scheduled.background_task`. Defers to `handleScheduledBackgroundTask`
+     * (validation + row creation + runner handoff) and translates the
+     * outcome into the `agent_schedule.status` write.
+     */
+    async handleScheduledBackgroundTaskDispatch(event) {
+        const { handleScheduledBackgroundTask } = await import("./dispatcher-scheduled-background-task.js");
+        const outcome = await handleScheduledBackgroundTask({ db: this.db, runner: this.backgroundTaskRunner }, event);
+        const succeeded = outcome.kind === "dispatched" || outcome.kind === "row_already_exists";
+        this.db
+            .prepare("UPDATE agent_schedule SET status = ? WHERE id = ? AND status = 'running'")
+            .run(succeeded ? "completed" : "failed", event.scheduleId);
+        if (!succeeded) {
+            try {
+                this.db
+                    .prepare(`INSERT INTO agent_actions
+               (action_type, detail, result, started_at, completed_at)
+             VALUES (?, ?, 'failure', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
+                    .run("background_task.scheduled_dispatch_failed", JSON.stringify({
+                    scheduleId: event.scheduleId,
+                    kind: outcome.kind,
+                    ...("taskId" in outcome ? { taskId: outcome.taskId } : {}),
+                    ...("reason" in outcome ? { reason: outcome.reason } : {}),
+                }));
+            }
+            catch (auditErr) {
+                /* c8 ignore start -- defensive */
+                logger.warn({ err: auditErr, scheduleId: event.scheduleId, kind: outcome.kind }, "failed to record background_task.scheduled_dispatch_failed audit row");
+                /* c8 ignore stop */
+            }
+        }
+    }
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — dispatch branch for
      * `scheduled.browser_task`. Defers the heavy lifting to

package/dist/core/dm-freshness-metrics.d.ts

@@ -51,7 +51,7 @@ export interface DmFreshnessAggregate {
      * `agent_log_lag_minutes=0` by construction (the snapshot is built at
      * dispatch time), so including them would drag the percentile toward 0
      * and hide the cohort the plan §6 acceptance threshold targets
-     * ("p95 ≤ 60 — i.e. resumed turns are typically within an hourly_check
+     * ("p95 ≤ 60 — i.e. resumed turns are typically within an activity_scan
      * cadence of session start"). When `resumedTurns === 0`, both
      * percentiles are 0 — there is no lag to report.
      */