@aitne/daemon 0.1.9 → 0.1.11

package/dist/api/server.d.ts

@@ -4,7 +4,7 @@ import type { AgentConfig } from "../config.js";
 import { EventBroadcaster } from "./routes/sse.js";
 import type { AttachmentStore } from "../services/attachments/store.js";
 import type { EventBus } from "../core/event-bus.js";
-import type { InFlightExecutionInfo, TriggerHourlyCheckOptions, TriggerHourlyCheckResult } from "../core/dispatcher.js";
+import type { InFlightExecutionInfo, TriggerActivityScanOptions, TriggerActivityScanResult } from "../core/dispatcher.js";
 import type { PromptContextChangedCallback } from "../core/context-staleness.js";
 import type { IAgentCore } from "../core/agent-core.js";
 import type { AuthHealthMonitor } from "../core/backends/auth-health-monitor.js";
@@ -58,6 +58,31 @@ export interface MessagingHealthStatus {
     lastInboundAt: string | null;
     error: string | null;
 }
+/**
+ * Outcome of the API-deps `sendNotification` chokepoint
+ * (QUIET_HOURS_HARDENING_PLAN.md Phase 1). Inside quiet hours a
+ * non-critical message is deferred to a durable `task_type='dm'`
+ * schedule row at the quiet-hours edge (never silently dropped);
+ * outside quiet hours the proactive hourly/daily rate limits apply and
+ * a limited message is NOT sent — the live session can adapt.
+ */
+export type SendNotificationResult = {
+    status: "sent";
+    dispatchId: string;
+    deliveries: {
+        platform: string;
+        channel: string;
+        messageId?: string;
+    }[];
+} | {
+    status: "deferred_quiet_hours";
+    scheduleId: string;
+    /** SQLite-format UTC datetime the deferred DM fires at. */
+    deliverAfter: string;
+} | {
+    status: "rate_limited";
+    retryAfter: string | null;
+};
 export interface ApiDependencies {
     db: Database.Database;
     config: AgentConfig;
@@ -88,6 +113,7 @@ export interface ApiDependencies {
     isStartupComplete?: () => boolean;
     eventBus?: EventBus;
     getHealthData: () => {
+        /** Seconds since daemon start (see HealthStatus.daemonUptime). */
         uptime: number;
         eventBusSize: number;
         activeSessions: number;
@@ -132,14 +158,13 @@ export interface ApiDependencies {
         priority?: string;
         notificationType?: string;
         originSessionId?: number;
-    }) => Promise<{
-        dispatchId: string;
-        deliveries: {
-            platform: string;
-            channel: string;
-            messageId?: string;
-        }[];
-    }>;
+        /**
+         * Event correlation id of the calling agent session, when known —
+         * lets the quiet-hours gate resolve the owning user-Agent slug so
+         * deferred DMs coalesce per Agent (QUIET_HOURS_HARDENING_PLAN Phase 1).
+         */
+        correlationId?: string;
+    }) => Promise<SendNotificationResult>;
     /**
      * Notify-dedup hook — called by the `/api/notify` route when the request
      * carries an `X-Pa-Event-Correlation-Id` header (auto-injected by
@@ -176,6 +201,14 @@ export interface ApiDependencies {
      */
     browserTaskRunner?: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner;
     browserTaskSlotStateRef?: import("../services/browser-task/browser-task-runner.js").SlotStateRef;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4 — generic background-task runner
+     * + shared slot state, wired together at boot in `index.ts`. Optional
+     * in tests; when absent the POST /api/background-task route writes a
+     * synthetic terminal transition so the row doesn't hang in pending.
+     */
+    backgroundTaskRunner?: import("../services/background-task/background-task-runner.js").BackgroundTaskRunner;
+    backgroundTaskSlotStateRef?: import("../services/background-task/background-task-runner.js").BackgroundTaskSlotStateRef;
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 — lite-final-confirm
      * token handler. The runner calls into it from the final-confirm
@@ -199,11 +232,6 @@ export interface ApiDependencies {
      * without waiting for its own chokidar debounce window.
      */
     onIndexableContextChange?: (path: string) => void;
-    /**
-     * B-007 §5.8 — called after any write/delete under `policies/routines/custom/`
-     * so the CustomRoutineScheduler re-enumerates and re-registers jobs.
-     */
-    onCustomRoutinesChanged?: () => void;
     /**
      * Called after a mutation to the effective mail scope — enabled providers,
      * account add/remove, active toggle, or app-password refresh. Implementations
@@ -212,8 +240,8 @@ export interface ApiDependencies {
      * tearing down the SDK session.
      */
     onMailScopeChanged?: (reason: string) => void;
-    /** Manual trigger for the polling-based hourly check */
-    triggerHourlyCheck?: (source: string, options?: TriggerHourlyCheckOptions) => Promise<TriggerHourlyCheckResult>;
+    /** Manual trigger for the polling-based activity scan */
+    triggerActivityScan?: (source: string, options?: TriggerActivityScanOptions) => Promise<TriggerActivityScanResult>;
     /**
      * Evening-review slimdown §2.2 — synchronous manual fire of
      * `runRoadmapMechanicalMaintenance` (substeps 2a / 2b / 2d). Used

package/dist/api/server.js

@@ -30,6 +30,8 @@ import { createSystemRoutes } from "./routes/system.js";
 import { createBackendRoutes } from "./routes/backends.js";
 import { createSkillsRoutes } from "./routes/skills.js";
 import { createObservationRoutes } from "./routes/observations.js";
+import { createFeedbackRoutes } from "./routes/feedback.js";
+import { createTuningRoutes } from "./routes/tuning.js";
 import { createSkillCurationRoutes } from "./routes/skill-curation.js";
 import { createProfileQuestionsRoutes } from "./routes/profile-questions.js";
 import { createRecurringScheduleRoutes } from "./routes/recurring-schedules.js";
@@ -54,6 +56,7 @@ import { createBrowserHistoryManagedRoutes } from "./routes/browser-history-mana
 import { createBrowserAutomationSitesRoutes } from "./routes/browser-automation-sites.js";
 import { createBrowserAutomationPurchaseRoutes } from "./routes/browser-automation-purchase.js";
 import { createBrowserTaskRoutes } from "./routes/browser-task.js";
+import { createBackgroundTaskRoutes } from "./routes/background-task.js";
 import { buildManagedTasksRoutesDepsFromApi, createManagedTasksRoutes, } from "./routes/managed-tasks.js";
 import { buildSotBindingsRoutesDepsFromApi, createSotBindingsRoutes, } from "./routes/sot-bindings.js";
 import { buildEntitiesRoutesDepsFromApi, createEntitiesRoutes, } from "./routes/entities.js";
@@ -326,6 +329,8 @@ export function createApp(deps) {
     const backendRoutes = createBackendRoutes(deps);
     const skillsRoutes = createSkillsRoutes({ config: deps.config });
     const observationRoutes = createObservationRoutes(deps);
+    const feedbackRoutes = createFeedbackRoutes(deps);
+    const tuningRoutes = createTuningRoutes(deps);
     const skillCurationRoutes = createSkillCurationRoutes(deps);
     const profileQuestionsRoutes = createProfileQuestionsRoutes(deps);
     const recurringScheduleRoutes = createRecurringScheduleRoutes(deps);
@@ -368,6 +373,10 @@ export function createApp(deps) {
     // wired (tests / lite installs). The route handlers degrade
     // gracefully on absent runner / slot ref.
     const browserTaskRoutes = createBrowserTaskRoutes(deps);
+    // BACKGROUND_TASK_RUNNER_DESIGN.md §7 — generic background-task surface.
+    // Mounted unconditionally; the handlers degrade gracefully when the
+    // runner / slot ref are absent (tests / lite installs).
+    const backgroundTaskRoutes = createBackgroundTaskRoutes(deps);
     // Management Registry & Entities (docs/design/21-management-registry-
     // and-entities.md). The managed-tasks and sot-bindings routes MUST
     // share one lock manager — separate instances would let back-to-back
@@ -395,6 +404,8 @@ export function createApp(deps) {
     app.route("/api", backendRoutes);
     app.route("/api", skillsRoutes);
     app.route("/api", observationRoutes);
+    app.route("/api", feedbackRoutes);
+    app.route("/api", tuningRoutes);
     app.route("/api", skillCurationRoutes);
     app.route("/api", profileQuestionsRoutes);
     app.route("/api", recurringScheduleRoutes);
@@ -423,6 +434,7 @@ export function createApp(deps) {
     app.route("/api", browserAutomationSitesRoutes);
     app.route("/api", browserAutomationPurchaseRoutes);
     app.route("/api", browserTaskRoutes);
+    app.route("/api", backgroundTaskRoutes);
     // ── Chat file attachments (Phase 1) ──
     if (deps.attachmentStore) {
         const attachmentRoutes = createAttachmentRoutes({

package/dist/bootstrap/adapters.d.ts

@@ -37,6 +37,7 @@ import { SlackAdapter } from "../adapters/slack-adapter.js";
 import { TelegramAdapter } from "../adapters/telegram-adapter.js";
 import { WhatsAppAdapter, type WhatsAppQrSnapshot } from "../adapters/whatsapp-adapter.js";
 import type { WhatsAppQrResponse } from "../api/server.js";
+import { AdapterWatchdog } from "../adapters/adapter-watchdog.js";
 /**
  * Mutable holder for the live adapter instances. The bootstrap factory
  * updates these fields in place; `index.ts` and the dashboard-controls
@@ -98,6 +99,24 @@ export interface AdapterReloaders {
     enableWhatsAppAdapter(): Promise<void>;
 }
 export declare function createAdapterReloaders(deps: BootstrapAdapterDeps): AdapterReloaders;
+/**
+ * Build the connection watchdog for the library-managed adapters
+ * (Slack socket-mode, Discord gateway, Telegram long-poll).
+ *
+ * Each entry reads the live instance out of the mutable `AdapterState`
+ * slot — a reload that swaps the instance is picked up on the next probe
+ * automatically — and restarts through the bootstrap reloader so the
+ * stop→register→start lifecycle (and its MessageHub status transitions)
+ * stays in one place. WhatsApp is deliberately NOT watched: the Baileys
+ * adapter owns a sustained reconnect watch with ban-risk-aware pacing
+ * that a blunt stop→start cycle would fight against.
+ *
+ * On a down/recovery transition the hub status flips to error/ok so
+ * `/health` and notification-eligibility reflect the live socket state
+ * instead of the boot-time snapshot (pre-watchdog, a dead socket kept
+ * reporting "ok" forever).
+ */
+export declare function createAdapterWatchdog(deps: Pick<BootstrapAdapterDeps, "messageHub" | "state">, reloaders: Pick<AdapterReloaders, "reloadDiscordAdapter" | "reloadSlackAdapter" | "reloadTelegramAdapter">): AdapterWatchdog;
 /**
  * Pure projection of the WhatsApp adapter (+ optional snapshot
  * override) into the `WhatsAppQrResponse` wire shape. Lives outside

package/dist/bootstrap/adapters.js

@@ -32,6 +32,7 @@ import { DiscordAdapter } from "../adapters/discord.js";
 import { SlackAdapter } from "../adapters/slack-adapter.js";
 import { TelegramAdapter } from "../adapters/telegram-adapter.js";
 import { WhatsAppAdapter, } from "../adapters/whatsapp-adapter.js";
+import { AdapterWatchdog } from "../adapters/adapter-watchdog.js";
 import { createLogger, toSafeErrorMessage } from "../logging.js";
 const logger = createLogger("daemon-bootstrap-adapters");
 export function createAdapterReloaders(deps) {
@@ -207,6 +208,66 @@ export function createAdapterReloaders(deps) {
         enableWhatsAppAdapter,
     };
 }
+/**
+ * Build the connection watchdog for the library-managed adapters
+ * (Slack socket-mode, Discord gateway, Telegram long-poll).
+ *
+ * Each entry reads the live instance out of the mutable `AdapterState`
+ * slot — a reload that swaps the instance is picked up on the next probe
+ * automatically — and restarts through the bootstrap reloader so the
+ * stop→register→start lifecycle (and its MessageHub status transitions)
+ * stays in one place. WhatsApp is deliberately NOT watched: the Baileys
+ * adapter owns a sustained reconnect watch with ban-risk-aware pacing
+ * that a blunt stop→start cycle would fight against.
+ *
+ * On a down/recovery transition the hub status flips to error/ok so
+ * `/health` and notification-eligibility reflect the live socket state
+ * instead of the boot-time snapshot (pre-watchdog, a dead socket kept
+ * reporting "ok" forever).
+ */
+export function createAdapterWatchdog(deps, reloaders) {
+    const { messageHub, state } = deps;
+    const watchdog = new AdapterWatchdog();
+    const entries = [
+        {
+            platform: "discord",
+            getConnectionState: () => state.discord?.getConnectionState() ?? "unknown",
+            restart: () => reloaders.reloadDiscordAdapter(true),
+        },
+        {
+            platform: "slack",
+            getConnectionState: () => state.slack?.getConnectionState() ?? "unknown",
+            restart: () => reloaders.reloadSlackAdapter(true),
+        },
+        {
+            platform: "telegram",
+            getConnectionState: () => state.telegram?.getConnectionState() ?? "unknown",
+            restart: () => reloaders.reloadTelegramAdapter(true),
+        },
+    ];
+    for (const entry of entries) {
+        watchdog.register({
+            platform: entry.platform,
+            getConnectionState: entry.getConnectionState,
+            restart: entry.restart,
+            onStateChange: (connectionState) => {
+                if (connectionState === "down") {
+                    messageHub.setPlatformRuntimeStatus(entry.platform, {
+                        runtimeState: "error",
+                        error: "Connection lost — watchdog will restart the adapter if it does not self-recover",
+                    });
+                }
+                else if (connectionState === "ok") {
+                    messageHub.setPlatformRuntimeStatus(entry.platform, {
+                        runtimeState: "ok",
+                        error: null,
+                    });
+                }
+            },
+        });
+    }
+    return watchdog;
+}
 /**
  * Pure projection of the WhatsApp adapter (+ optional snapshot
  * override) into the `WhatsAppQrResponse` wire shape. Lives outside

package/dist/bootstrap/api.d.ts

@@ -10,7 +10,7 @@
  *  1. Assemble the `ApiDependencies` record from typed inputs — translate
  *     subsystem instances (dispatcher, scheduler, messageHub, …) into the
  *     small closures the API surface consumes (`getHealthData`,
- *     `sendNotification`, `triggerHourlyCheck`, etc.).
+ *     `sendNotification`, `triggerActivityScan`, etc.).
  *  2. Construct WhatsApp / messaging-platform controls (Pattern-C; takes
  *     the adapter state holder + reload closures as deps).
  *  3. Invoke `createApp(apiDeps)` to mount every route module and the
@@ -52,7 +52,6 @@ import type { AuthRecovery } from "../core/backends/auth-recovery.js";
 import type { AuthTelemetry } from "../core/backends/auth-telemetry.js";
 import type { EventBus } from "../core/event-bus.js";
 import type { AgentScheduler } from "../core/scheduler.js";
-import type { CustomRoutineScheduler } from "../core/custom-routine-scheduler.js";
 import type { HealthMonitor } from "../core/health-monitor.js";
 import type { Heartbeat } from "../core/heartbeat.js";
 import type { MessageHub } from "../adapters/message-hub.js";
@@ -128,7 +127,6 @@ export interface BootstrapApiDeps {
      * it on an `enabled` change. Optional so partial test harnesses can omit it.
      */
     readonly agentEnabledCache?: import("../core/agents/loader.js").AgentEnabledCache;
-    readonly customRoutineScheduler: CustomRoutineScheduler;
     readonly healthMonitor: HealthMonitor;
     readonly heartbeat: Heartbeat;
     readonly messageHub: MessageHub;
@@ -145,6 +143,10 @@ export interface BootstrapApiDeps {
      *  wired so the runner returns `failed (not_implemented)`; Phase 2
      *  passes the Playwright + Claude SDK driver into the same factory. */
     readonly browserTaskRunner: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner;
+    /** BACKGROUND_TASK_RUNNER_DESIGN.md §4 — generic background-task runner
+     *  + shared slot state, constructed in `event-pipeline.ts`. */
+    readonly backgroundTaskSlotStateRef: import("../services/background-task/background-task-runner.js").BackgroundTaskSlotStateRef;
+    readonly backgroundTaskRunner: import("../services/background-task/background-task-runner.js").BackgroundTaskRunner;
     readonly writeTracker: AgentWriteTracker;
     readonly auditLogger: AuditLogger;
     readonly attachmentStore: AttachmentStore;

package/dist/bootstrap/api.js

@@ -10,7 +10,7 @@
  *  1. Assemble the `ApiDependencies` record from typed inputs — translate
  *     subsystem instances (dispatcher, scheduler, messageHub, …) into the
  *     small closures the API surface consumes (`getHealthData`,
- *     `sendNotification`, `triggerHourlyCheck`, etc.).
+ *     `sendNotification`, `triggerActivityScan`, etc.).
  *  2. Construct WhatsApp / messaging-platform controls (Pattern-C; takes
  *     the adapter state holder + reload closures as deps).
  *  3. Invoke `createApp(apiDeps)` to mount every route module and the
@@ -49,6 +49,7 @@ import { applyIntegrationModeChange, } from "../core/integration-lifecycle.js";
 import { continueDashboardSession as continueDashboardSessionFromHistory, endDashboardSession as endDashboardSessionFromChannel, } from "../core/dashboard-session-controls.js";
 import { sendSetupWelcomeDm } from "../messaging/setup-welcome-dm.js";
 import { recordProactiveForwardDeliveries } from "../core/channel-timeline.js";
+import { gateOutboundNotification } from "../core/notification-gate.js";
 import { createApp, } from "../api/server.js";
 import { createDocsRoutes } from "../api/routes/docs.js";
 import { whatsappQrResponseFromAdapter, } from "./adapters.js";
@@ -125,14 +126,51 @@ export function startApiServer(deps) {
  * call site reads as one factory call.
  */
 function composeApiDependencies(deps) {
-    const { db, config, secretBroker, services, blobStore, agentBackends, authHealthMonitor, authRecovery, authTelemetry, eventBus, readTokenManager, morningRoutineLock, roadmapWriteLock, migrationLock, contextWriteGate, managementMdWriteLockManager, dispatcher, scheduler, agentEnabledCache, customRoutineScheduler, healthMonitor, heartbeat, messageHub, observerManager, contextIndexReconciler, primaryVaultWatcher, delegatedBackendInvoker, gitAccountRegistry, writeTracker, auditLogger, attachmentStore, dashboardAdapter, eventBroadcaster, getIntegrationStatus, getMessagingStatus, isStartupComplete, getDelegatedSyncWorker, handleSecretChange, handlePromptContextChanged, onGoogleServicesReady, rematerializeActiveDmWorkdirs, fireRoadmapMaintenance, buildCalendarPoller, buildNotionPoller, buildGitWatcher, buildGithubPoller, buildDelegatedSyncWorker, buildGitDelegatedCronObserver, clearGitWatcher, queueGitProjectInitsForCurrentConfig, } = deps;
+    const { db, config, secretBroker, services, blobStore, agentBackends, authHealthMonitor, authRecovery, authTelemetry, eventBus, readTokenManager, morningRoutineLock, roadmapWriteLock, migrationLock, contextWriteGate, managementMdWriteLockManager, dispatcher, scheduler, agentEnabledCache, healthMonitor, heartbeat, messageHub, observerManager, contextIndexReconciler, primaryVaultWatcher, delegatedBackendInvoker, gitAccountRegistry, writeTracker, auditLogger, attachmentStore, dashboardAdapter, eventBroadcaster, getIntegrationStatus, getMessagingStatus, isStartupComplete, getDelegatedSyncWorker, handleSecretChange, handlePromptContextChanged, onGoogleServicesReady, rematerializeActiveDmWorkdirs, fireRoadmapMaintenance, buildCalendarPoller, buildNotionPoller, buildGitWatcher, buildGithubPoller, buildDelegatedSyncWorker, buildGitDelegatedCronObserver, clearGitWatcher, queueGitProjectInitsForCurrentConfig, } = deps;
     const whatsappControls = buildWhatsAppControls(deps);
     const messagingControls = {
         telegram: deps.buildTelegramControls(),
         slack: deps.buildSlackControls(),
         discord: deps.buildDiscordControls(),
     };
-    const sendNotification = async ({ message, platforms, priority, notificationType, originSessionId }) => {
+    const sendNotification = async ({ message, platforms, priority, notificationType, originSessionId, correlationId }) => {
+        // QUIET_HOURS_HARDENING_PLAN.md Phase 1 — this chokepoint used to
+        // wire straight into `messageHub.sendToUser`, letting any
+        // autonomous session DM the owner at 03:00 (finding F1). Gate
+        // order: safety/critical bypass → quiet-hours deferral (durable
+        // `task_type='dm'` row at the quiet-hours edge, coalesced per
+        // origin) → proactive rate limits on the immediate path.
+        const gateVerdict = gateOutboundNotification(db, config, {
+            message,
+            platforms,
+            priority,
+            notificationType,
+            originSessionId,
+            agentId: correlationId !== undefined
+                ? dispatcher.agentIdForCorrelation(correlationId)
+                : null,
+            deferredFrom: "api.notify",
+        });
+        if (gateVerdict.action === "defer") {
+            logger.info({
+                scheduleId: gateVerdict.scheduleId,
+                deliverAfter: gateVerdict.deliverAfter,
+                coalesced: gateVerdict.coalesced,
+                notificationType: notificationType ?? "agent",
+            }, "Outbound notification deferred to quiet-hours end");
+            return {
+                status: "deferred_quiet_hours",
+                scheduleId: gateVerdict.scheduleId,
+                deliverAfter: gateVerdict.deliverAfter,
+            };
+        }
+        if (gateVerdict.action === "rate_limit") {
+            logger.warn({
+                retryAfter: gateVerdict.retryAfter,
+                notificationType: notificationType ?? "agent",
+            }, "Outbound notification rate-limited — not sent");
+            return { status: "rate_limited", retryAfter: gateVerdict.retryAfter };
+        }
         const dispatchId = randomBytes(16).toString("hex");
         const deliveries = await messageHub.sendToUser(message, platforms, {
             dispatchId,
@@ -167,7 +205,7 @@ function composeApiDependencies(deps) {
                 notificationType: "proactive_forward",
             });
         }
-        return { dispatchId, deliveries };
+        return { status: "sent", dispatchId, deliveries };
     };
     const onIntegrationModeChange = async (key, prev, next) => {
         const buildObserver = (observerName) => {
@@ -369,6 +407,8 @@ function composeApiDependencies(deps) {
         // race on the same value.
         browserTaskRunner: deps.browserTaskRunner,
         browserTaskSlotStateRef: deps.browserTaskSlotStateRef,
+        backgroundTaskRunner: deps.backgroundTaskRunner,
+        backgroundTaskSlotStateRef: deps.backgroundTaskSlotStateRef,
         onIntegrationModeChange,
         onMainBackendChange,
         onSetupStart: (mode) => {
@@ -391,15 +431,7 @@ function composeApiDependencies(deps) {
             // non-indexed paths is harmless.
             contextIndexReconciler.requestReconcile("manual");
         },
-        onCustomRoutinesChanged: () => {
-            try {
-                customRoutineScheduler.reload();
-            }
-            catch (err) {
-                logger.error({ err }, "Custom routine reload failed");
-            }
-        },
-        triggerHourlyCheck: (source, options) => dispatcher.triggerHourlyCheck(source, options),
+        triggerActivityScan: (source, options) => dispatcher.triggerActivityScan(source, options),
         triggerRoadmapRefresh: (source, options) => dispatcher.emitRoadmapRefresh(source, options),
         triggerRoadmapMaintenance: () => fireRoadmapMaintenance(),
         endDashboardSession: (channelId) => endDashboardSessionFromChannel({

package/dist/bootstrap/catchup.d.ts

@@ -15,7 +15,7 @@ import type { EventDispatcher } from "../core/dispatcher.js";
 export interface StartupCatchupResult {
     postMessagingRoadmapRefresh: boolean;
     postMessagingRoutines: string[];
-    postMessagingHourlyCheck: boolean;
+    postMessagingActivityScan: boolean;
 }
 export declare function runCatchup(db: Database.Database, dispatcher: EventDispatcher, config: AgentConfig): Promise<StartupCatchupResult>;
 export declare function runPostMessagingCatchup(dispatcher: EventDispatcher, catchup: StartupCatchupResult): Promise<void>;

package/dist/bootstrap/catchup.js

@@ -14,7 +14,7 @@ import { createEvent, EventPriority, getAgentDayBoundsUtc, } from "@aitne/shared
 import { getContextDir, isRoadmapStale } from "../config.js";
 import { discardStalePendingSchedules, recoverOrphanedRunningSchedules, } from "../core/schedule-maintenance.js";
 import { createLogger } from "../logging.js";
-import { getDueCatchupRoutines, hasFreshAgentDayTodayMd, shouldCatchUpHourlyCheck, } from "./schedule-helpers.js";
+import { getDueCatchupRoutines, hasFreshAgentDayTodayMd, shouldCatchUpActivityScan, } from "./schedule-helpers.js";
 const logger = createLogger("daemon-bootstrap-catchup");
 export async function runCatchup(db, dispatcher, config) {
     // Setup gate — on first boot (before rules/management.md exists) we must
@@ -29,7 +29,7 @@ export async function runCatchup(db, dispatcher, config) {
         return {
             postMessagingRoadmapRefresh: false,
             postMessagingRoutines: [],
-            postMessagingHourlyCheck: false,
+            postMessagingActivityScan: false,
         };
     }
     const now = new Date();
@@ -49,7 +49,7 @@ export async function runCatchup(db, dispatcher, config) {
     // clock across the catchup's pre / post freshness probes.
     const needsMorning = !hasFreshAgentDayTodayMd(todayMdPath, tz, config.dayBoundaryHour, now);
     const dueCatchupRoutines = getDueCatchupRoutines(db, config, agentDayStartUtc, agentDayEndUtc, now);
-    const needsHourlyCheckCatchup = shouldCatchUpHourlyCheck(db, config, now);
+    const needsActivityScanCatchup = shouldCatchUpActivityScan(db, config, now);
     let ranMorningCatchup = false;
     if (needsMorning) {
         try {
@@ -66,7 +66,7 @@ export async function runCatchup(db, dispatcher, config) {
                 priority: EventPriority.HIGH,
                 data: {
                     postCatchupRoutines: dueCatchupRoutines,
-                    postCatchupHourlyCheck: needsHourlyCheckCatchup,
+                    postCatchupActivityScan: needsActivityScanCatchup,
                     deferPostMorningCatchupsUntilStartupReady: true,
                 },
             }),
@@ -78,13 +78,13 @@ export async function runCatchup(db, dispatcher, config) {
             return {
                 postMessagingRoadmapRefresh: false,
                 postMessagingRoutines: [],
-                postMessagingHourlyCheck: false,
+                postMessagingActivityScan: false,
             };
         }
         return {
             postMessagingRoadmapRefresh: isRoadmapStale(contextDir),
             postMessagingRoutines: dueCatchupRoutines,
-            postMessagingHourlyCheck: needsHourlyCheckCatchup,
+            postMessagingActivityScan: needsActivityScanCatchup,
         };
     }
     if (!ranMorningCatchup && isRoadmapStale(contextDir)) {
@@ -94,7 +94,7 @@ export async function runCatchup(db, dispatcher, config) {
     return {
         postMessagingRoadmapRefresh: false,
         postMessagingRoutines: dueCatchupRoutines,
-        postMessagingHourlyCheck: needsHourlyCheckCatchup,
+        postMessagingActivityScan: needsActivityScanCatchup,
     };
 }
 export async function runPostMessagingCatchup(dispatcher, catchup) {
@@ -106,9 +106,9 @@ export async function runPostMessagingCatchup(dispatcher, catchup) {
         logger.info({ routine }, "Running same-day routine catchup after messaging startup");
         await processRoutineCatchup(dispatcher, routine);
     }
-    if (catchup.postMessagingHourlyCheck) {
-        logger.info("Triggering hourly_check catchup after messaging startup");
-        await dispatcher.triggerHourlyCheck("catchup_startup", { force: false });
+    if (catchup.postMessagingActivityScan) {
+        logger.info("Triggering activity_scan catchup after messaging startup");
+        await dispatcher.triggerActivityScan("catchup_startup", { force: false });
     }
 }
 export async function processRoutineCatchup(dispatcher, routine) {
@@ -116,7 +116,7 @@ export async function processRoutineCatchup(dispatcher, routine) {
         ...createEvent({
             type: `routine.${routine}`,
             source: "catchup",
-            priority: routine === "hourly_check" ? EventPriority.NORMAL : EventPriority.HIGH,
+            priority: routine === "activity_scan" ? EventPriority.NORMAL : EventPriority.HIGH,
         }),
         routine,
     });

package/dist/bootstrap/event-pipeline.d.ts

@@ -226,6 +226,17 @@ export interface BootstrapEventPipelineResult {
      * driver into the same factory call.
      */
     readonly browserTaskRunner: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4 — generic background-task runner +
+     * shared slot state. The runner + route layer hold THIS instance so a
+     * cancel-while-pending and a runner-side promote race on one value.
+     */
+    readonly backgroundTaskSlotStateRef: import("../services/background-task/background-task-runner.js").BackgroundTaskSlotStateRef;
+    readonly backgroundTaskRunner: import("../services/background-task/background-task-runner.js").BackgroundTaskRunner;
+    /** 30 s housekeeping tick — clarification-deadline + pending-queue
+     *  timeout + delivery recovery sweep for background tasks. Cleared on
+     *  graceful shutdown. */
+    readonly backgroundTaskHousekeepingTimer: NodeJS.Timeout;
 }
 /**
  * Construct the event-processing pipeline (§10). See the file-level