@aitne/daemon 0.1.10 → 0.1.11

package/dist/bootstrap/event-pipeline.js

@@ -89,6 +89,8 @@ import { EventPriority } from "@aitne/shared";
 import { createLogger } from "../logging.js";
 import { markContextChanged } from "../core/dashboard-session-controls.js";
 import { EventDispatcher } from "../core/dispatcher.js";
+import { SessionGateRegistry } from "../core/session-gate.js";
+import { enqueueUndeliveredBrowserTaskDeliveries } from "../core/dispatcher-task-delivery.js";
 import { SignalDetector } from "../core/signal-detector.js";
 import { ContextBuilder } from "../core/context-builder.js";
 import { getTaskFlow, initTaskFlows } from "../core/prompts.js";
@@ -111,6 +113,7 @@ import { AuthRecovery } from "../core/backends/auth-recovery.js";
 // Workdir / skills
 import { ensureBackendMaterialized, syncAllUserSkills, buildConfiguredServices, refreshDmSessionWorkdirs, validateDelegatedStartup, } from "../core/workdir.js";
 import { validateBuiltinSkillSourceTree } from "../core/skills-compiler-variants.js";
+import { eventTypeAcceptsUserSkills } from "../core/skills-manifest.js";
 // Audit / safety / messaging
 import { AuditLogger } from "../safety/audit.js";
 import { AgentExecutionRecorder } from "../core/agent-execution-recorder.js";
@@ -182,7 +185,29 @@ export async function createEventPipeline(deps) {
     // row whose flush timer didn't fire (process killed) would otherwise
     // linger forever and confuse the dashboard's notification feed.
     NotificationManager.closeStaleBatchedRows(db);
-    const notificationManager = new NotificationManager(messageHub, db, config);
+    // BACKGROUND_TASK_RUNNER_DESIGN.md §2.3 / §13 Decision 4 (Phase 4, opt-in)
+    // — router that hands an ACTIVE-owner proactive forward to the
+    // task-delivery gate so the real DM agent weaves it into the live thread.
+    // Only invoked by `deliverProactive` when the owner is active AND
+    // `autonomousForwardNaturalDelivery` is on (default off). Resolves the
+    // owner's default DM channel as the weave target; no channel ⇒ returns
+    // false and the verbatim path runs unchanged.
+    const { createAutonomousForwardDeliveryEvent: makeAutonomousForwardEvent } = await import("../core/dispatcher-task-delivery.js");
+    const { selectDefaultOwnerChannel: resolveOwnerDmChannel } = await import("../messaging/owner-channels.js");
+    const { channelRef: ownerChannelRef } = await import("../db/browser-automation-purchase-primary-channels-store.js");
+    const notificationManager = new NotificationManager(messageHub, db, config, {
+        routeAutonomousForwardNaturally: async ({ content, event }) => {
+            const owner = resolveOwnerDmChannel(db);
+            if (!owner)
+                return false;
+            await eventBus.put(makeAutonomousForwardEvent({
+                content,
+                originatingChannel: ownerChannelRef(owner.platform, owner.channelId),
+                correlationId: event.correlationId ?? null,
+            }));
+            return true;
+        },
+    });
     const authTelemetry = new AuthTelemetry(db);
     const makeAuthNotifier = (source) => ({
         send: async (message, options) => {
@@ -222,7 +247,13 @@ export async function createEventPipeline(deps) {
         });
         const mailAccounts = services.mail?.listActiveAccounts() ?? [];
         ensureBackendMaterialized(config.workspaceDir, sessionDir, backendId, eventType, processKey, cfgServices, mailAccounts, readIntegrations(db), config.character, wikiWorkspaceName, getContextDir(config, db), db, messageText ?? null);
-        syncAllUserSkills(sessionDir, resolveUserSkillsRoot(config));
+        // Narrow-persona keys (wiki.* / routine.research_*) run a tight
+        // built-in manifest and never call a user skill — skip the owner's
+        // library on the fallback re-materialise too, matching the primary
+        // workdir path. See `eventTypeAcceptsUserSkills`.
+        if (eventTypeAcceptsUserSkills(processKey ?? eventType)) {
+            syncAllUserSkills(sessionDir, resolveUserSkillsRoot(config));
+        }
     });
     // docs/design/appendices/skills-unification.md Phase 1 §R5 / item 6 — refuse to boot on a
     // malformed source tree. Throws on slug-pattern violations and
@@ -319,7 +350,8 @@ export async function createEventPipeline(deps) {
     initTaskFlows(config.workspaceDir, config.dataDir);
     // ── Signal detector + dispatcher ──────────────────────────────────────
     const signalDetector = new SignalDetector(config, { db });
-    const dispatcher = new EventDispatcher(eventBus, agentRouter, contextBuilder, getTaskFlow, notificationManager, sessionManager, messageRecorder, auditLogger, db, config, morningRoutineLock, services, roadmapWriteLock, writeTracker);
+    const sessionGates = new SessionGateRegistry();
+    const dispatcher = new EventDispatcher(eventBus, agentRouter, contextBuilder, getTaskFlow, notificationManager, sessionManager, messageRecorder, auditLogger, db, config, morningRoutineLock, services, roadmapWriteLock, writeTracker, sessionGates);
     notificationManager.setSignalDetector(signalDetector);
     // Wire the scoped read-token manager into every backend so daemon-API
     // calls from `<sessionDir>` workdirs carry a per-session token, not the
@@ -453,7 +485,7 @@ export async function createEventPipeline(deps) {
     // re-registration when an integration mode flips. When no delegated
     // integration is present, the worker is null and the call is a no-op.
     dispatcher.setDelegatedSyncRefresh(async () => {
-        await delegatedSyncWorker?.runDisabledCadencesForHourlyCheck();
+        await delegatedSyncWorker?.runDisabledCadencesForActivityScan();
     });
     // ── Delegated probe observer (DELEGATED-MODE-V2 §7.1) ────────────────
     // Hourly re-probe of delegated integrations' connector tools so the
@@ -502,6 +534,40 @@ export async function createEventPipeline(deps) {
             return null;
         }
     };
+    // BACKGROUND_TASK_RUNNER_DESIGN.md Phase 1 (delivery assets) — the
+    // `task.delivery` idle + active branches attach a task's deliverable
+    // files inline: browser-task trace screenshots (resolved by key) and
+    // worker-produced output files like PDF / PPTX / PNG (resolved by path).
+    // The dispatcher owns delivery but has no messageHub / trace-store
+    // access, so we inject this resolver → outbound attachment refs (native
+    // file for messaging adapters, ingested store ref for the dashboard).
+    // Best-effort — unresolvable assets (retention drop, missing file,
+    // unknown type) are dropped; the text draft still sends.
+    {
+        const { resolveScreenshotAttachment, buildPathAttachment } = await import("../messaging/browser-task-screenshot-attachment.js");
+        dispatcher.setTaskDeliveryAssetResolver(async (platform, assets) => {
+            const resolved = await Promise.all(assets.map((asset) => {
+                if (asset.screenshotKey) {
+                    return resolveScreenshotAttachment({
+                        platform,
+                        key: asset.screenshotKey,
+                        paDataDir: config.dataDir,
+                        ingestOutboundImage: ingestBrowserTaskScreenshot,
+                    });
+                }
+                if (asset.path) {
+                    return buildPathAttachment({
+                        platform,
+                        absPath: asset.path,
+                        filename: asset.filename,
+                        ingestOutboundImage: ingestBrowserTaskScreenshot,
+                    });
+                }
+                return Promise.resolve(null);
+            }));
+            return resolved.filter((a) => a !== null);
+        });
+    }
     // ── Phase B-4 purchase handler ────────────────────────────────────────
     // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 / §13 step 50.
     //
@@ -646,9 +712,8 @@ export async function createEventPipeline(deps) {
     const { createBrowserTaskMcpNotifier } = await import("../messaging/browser-task-mcp-notifier.js");
     const browserTaskSlotStateRef = createSlotStateRef(config.browserTaskMaxConcurrent);
     const browserTaskMcpNotifier = createBrowserTaskMcpNotifier({
-        messageHub,
-        paDataDir: config.dataDir,
-        ingestOutboundImage: ingestBrowserTaskScreenshot,
+        eventBus,
+        db,
     });
     const browserTaskHostProfile = createBrowserTaskHostProfile();
     // Hoisted out of the `createBrowserTaskRunner({ notifier: ... })` arg
@@ -739,6 +804,41 @@ export async function createEventPipeline(deps) {
     // a user-scheduled task can silently fail at fire time hours/days
     // after the user issued it.
     dispatcher.setBrowserTaskTerminalNotifier(browserTaskTerminalNotifier);
+    // ── Background-task runner (BACKGROUND_TASK_RUNNER_DESIGN.md §4) ───────
+    // Generic detached-task worker. Shares the proven slot manager (via a
+    // synthetic per-task key so tasks contend only on the global cap) and
+    // the gated `task.delivery` boundary. The worker is a plain SDK session
+    // (no Playwright). The delivery enqueuer wraps the `task.delivery` event
+    // factories + the event bus so the runner stays free of any core import.
+    const { createBackgroundTaskRunner, createBackgroundTaskSlotStateRef, } = await import("../services/background-task/background-task-runner.js");
+    const { createBackgroundTaskTransitionEmitter: createBackgroundTaskTransitionEmitterAtBoot, } = await import("../services/background-task/background-task-transition-events.js");
+    const { createBackgroundTaskResultDeliveryEvent, createBackgroundTaskClarificationDeliveryEvent, enqueueUndeliveredBackgroundTaskDeliveries, } = await import("../core/dispatcher-task-delivery.js");
+    const backgroundTaskSlotStateRef = createBackgroundTaskSlotStateRef(config.backgroundTaskMaxConcurrent);
+    const backgroundTaskTransitionEmitter = createBackgroundTaskTransitionEmitterAtBoot(eventBroadcaster);
+    const backgroundTaskDeliveryEnqueuer = {
+        async enqueueResult(input) {
+            await eventBus.put(createBackgroundTaskResultDeliveryEvent(input));
+        },
+        async enqueueClarification(input) {
+            await eventBus.put(createBackgroundTaskClarificationDeliveryEvent(input));
+        },
+    };
+    const backgroundTaskRunner = createBackgroundTaskRunner({
+        db,
+        slotStateRef: backgroundTaskSlotStateRef,
+        transitionEmitter: backgroundTaskTransitionEmitter,
+        deliveryEnqueuer: backgroundTaskDeliveryEnqueuer,
+        resumeAcrossRestart: config.backgroundTaskResumeAcrossRestart,
+        driver: {
+            db,
+            paDataDir: config.dataDir,
+            workspaceDir: config.workspaceDir,
+            contextDir: getContextDir(config),
+            clarificationTtlMs: config.backgroundTaskClarificationTtlMinutes * 60_000,
+            transitionEmitter: backgroundTaskTransitionEmitter,
+        },
+    });
+    dispatcher.setBackgroundTaskRunner(backgroundTaskRunner);
     // ── Browser-task deadline scanner tick ────────────────────────────────
     // BROWSER_TASK_REDESIGN_PLAN.md §5 ask_user "Deadline enforcement" +
     // §5.1 pending-queue timeout safety valve. Single 30 s tick handles
@@ -786,6 +886,7 @@ export async function createEventPipeline(deps) {
                     expiredPending: sweep.expired,
                     nowMs: now,
                 });
+                await sweepDeliveryRecovery(now);
                 if (actions.length === 0)
                     return;
                 for (const action of actions) {
@@ -859,6 +960,16 @@ export async function createEventPipeline(deps) {
                 logger.warn({ err }, "browser-task deadline tick failed (continuing)");
             }
         }
+        async function sweepDeliveryRecovery(nowMs) {
+            const count = await enqueueUndeliveredBrowserTaskDeliveries({
+                db,
+                eventBus,
+                nowMs,
+            });
+            if (count > 0) {
+                logger.debug({ count }, "browser-task delivery recovery enqueued task.delivery events");
+            }
+        }
         async function sendDeadlineDm(ref, text) {
             if (!ref)
                 return;
@@ -884,8 +995,132 @@ export async function createEventPipeline(deps) {
         // a 30 s tick is housekeeping, not load-bearing for liveness.
         if (typeof timer.unref === "function")
             timer.unref();
+        void tick();
         return timer;
     })();
+    // ── Background-task housekeeping tick ──────────────────────────────────
+    // BACKGROUND_TASK_RUNNER_DESIGN.md §6 / §10.2 — one 30 s tick that:
+    //   1. transitions overdue clarifications (resolved=0 AND deadline_at <
+    //      now) to `timeout` via the runner (releases the slot + synthesizes
+    //      a fail-loud artifact + enqueues delivery);
+    //   2. sweeps pending-queue timeouts (a task that sat behind the
+    //      concurrency cap too long);
+    //   3. runs the delivery recovery sweep (re-enqueue `task.delivery` for
+    //      completed notify=true artifacts whose DM was lost, + undelivered
+    //      open clarifications).
+    // Best-effort + idempotent: per-row failures log and continue; the
+    // runner's `expireForDeadline` is a no-op on already-terminal rows.
+    const backgroundTaskHousekeepingTimer = await (async () => {
+        const { listOverdueClarifications, expireClarification, } = await import("../db/background-task-clarifications-store.js");
+        const { sweepPendingTimeouts } = await import("../services/browser-task/browser-task-slots.js");
+        const TICK_MS = 30_000;
+        async function tick() {
+            try {
+                const nowMs = Date.now();
+                // (1) clarification deadlines
+                for (const clar of listOverdueClarifications(db, nowMs)) {
+                    try {
+                        expireClarification(db, clar.id, nowMs);
+                        await backgroundTaskRunner.expireForDeadline(clar.taskId, "clarification_deadline");
+                    }
+                    catch (err) {
+                        logger.warn({ err, taskId: clar.taskId }, "background-task clarification-deadline action failed (continuing)");
+                    }
+                }
+                // (2) pending-queue timeouts
+                const sweep = sweepPendingTimeouts(backgroundTaskSlotStateRef.state, nowMs, config.backgroundTaskPendingQueueTimeoutMinutes);
+                backgroundTaskSlotStateRef.state = sweep.state;
+                for (const expired of sweep.expired) {
+                    try {
+                        await backgroundTaskRunner.expireForDeadline(expired.taskId, "queue_timeout", expired.waitedMs);
+                    }
+                    catch (err) {
+                        logger.warn({ err, taskId: expired.taskId }, "background-task queue-timeout action failed (continuing)");
+                    }
+                }
+                // (3) delivery recovery
+                const count = await enqueueUndeliveredBackgroundTaskDeliveries({
+                    db,
+                    eventBus,
+                    nowMs,
+                });
+                if (count > 0) {
+                    logger.debug({ count }, "background-task delivery recovery enqueued task.delivery events");
+                }
+            }
+            catch (err) {
+                logger.warn({ err }, "background-task housekeeping tick failed (continuing)");
+            }
+        }
+        const timer = setInterval(() => {
+            void tick();
+        }, TICK_MS);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        void tick();
+        return timer;
+    })();
+    // ── Background-task boot recovery (resume / re-dispatch) ──────────────
+    // BACKGROUND_TASK_RUNNER_DESIGN.md §10.2 — unlike browser_task (whose
+    // in-memory session is unrecoverable, so its rows are force-failed),
+    // background tasks survive a restart: their brief is self-contained AND
+    // (Phase 4) their SDK session id is persisted.
+    //
+    // With `backgroundTaskResumeAcrossRestart` ON (default):
+    //   - `running` rows that captured a session id  → RESUME the warm SDK
+    //     session (`resumeFromBoot`), falling back to re-dispatch on any
+    //     "couldn't load the session" signal.
+    //   - `awaiting_user` rows that captured a session id → LEFT as-is, so a
+    //     later `/clarify` reconstructs the handle and resumes (the delivery
+    //     recovery sweep re-sends the question if it never reached the owner).
+    //   - everything else (no session id, `pending`, or never-inited)
+    //     → re-dispatch from brief.
+    // With the toggle OFF: the v1 behaviour — every non-terminal row is
+    // re-dispatched from brief.
+    //
+    // Best-effort — failures log but do not abort startup.
+    void (async () => {
+        try {
+            const { resetNonTerminalForBootRedispatch, listNonTerminalBackgroundTasks, } = await import("../db/background-task-store.js");
+            if (!config.backgroundTaskResumeAcrossRestart) {
+                const reset = resetNonTerminalForBootRedispatch(db);
+                if (reset.length === 0)
+                    return;
+                logger.warn({ count: reset.length }, "background-task boot recovery — re-dispatching non-terminal tasks from brief (resume disabled)");
+                for (const { id } of reset) {
+                    void backgroundTaskRunner.runFromPost(id).catch((err) => {
+                        logger.error({ err, taskId: id }, "background-task boot re-dispatch threw (continuing)");
+                    });
+                }
+                return;
+            }
+            const rows = listNonTerminalBackgroundTasks(db);
+            if (rows.length === 0)
+                return;
+            const resumeRunning = rows.filter((r) => r.state === "running" && r.backendSessionId);
+            const leaveParked = rows.filter((r) => r.state === "awaiting_user" && r.backendSessionId);
+            // Everything not resumed and not left parked is re-dispatched: the
+            // runner's `resumeFromBoot` resets+re-runs each one (a `running` row
+            // without a session id, a `pending` row, etc.).
+            const redispatchIds = rows
+                .filter((r) => !(r.state === "running" && r.backendSessionId)
+                && !(r.state === "awaiting_user" && r.backendSessionId))
+                .map((r) => r.id);
+            logger.warn({
+                resume: resumeRunning.length,
+                leftParked: leaveParked.length,
+                redispatch: redispatchIds.length,
+            }, "background-task boot recovery — resuming / re-dispatching non-terminal tasks");
+            for (const { id } of [...resumeRunning, ...redispatchIds.map((id) => ({ id }))]) {
+                void backgroundTaskRunner.resumeFromBoot(id).catch((err) => {
+                    logger.error({ err, taskId: id }, "background-task boot resume/re-dispatch threw (continuing)");
+                });
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, "background-task boot recovery failed (continuing; rows stay non-terminal for next boot)");
+        }
+    })();
     // ── Browser-task boot-recovery DM fan-out ─────────────────────────────
     // BROWSER_TASK_REDESIGN_PLAN.md §6.5 — `initDatabase` flipped every
     // non-terminal `browser_task` row to `failed (daemon_restarted)` and
@@ -1024,6 +1259,9 @@ export async function createEventPipeline(deps) {
         browserTaskDeadlineTimer,
         browserTaskSlotStateRef,
         browserTaskRunner,
+        backgroundTaskSlotStateRef,
+        backgroundTaskRunner,
+        backgroundTaskHousekeepingTimer,
     };
 }
 /**

package/dist/bootstrap/observers.js

@@ -58,6 +58,7 @@
  */
 import { join } from "node:path";
 import { getContextDir } from "../config.js";
+import { getAgentEnabled } from "../db/agents-store.js";
 import { isSetupCompleted, isDegraded as readDegradedMode, } from "../db/runtime-state.js";
 import { getRepositoryByGithub, getRepositoryByLocalPath, listRepositories, selectGithubRepoSlugs, selectGitWatchedRepos, } from "../db/repositories-store.js";
 import { dispatchMatchingTriggers } from "../core/trigger-dispatch.js";
@@ -191,7 +192,7 @@ export async function createObservers(deps) {
             eventBus,
             // Threaded through so observations of agent-originated commits
             // flip to `actor='agent'` (C1). Without this, daemon-side
-            // commits would feed the hourly_check pending floor as user
+            // commits would feed the activity_scan pending floor as user
             // activity and re-invoke the agent in a loop.
             writeTracker,
             pushOverdueMinutes: config.gitPushOverdueMinutes,
@@ -307,8 +308,8 @@ export async function createObservers(deps) {
     }
     // Each call returns a fresh observer so the integration-lifecycle
     // helper re-registers a new instance after a mode flip — picking up
-    // any gitPollIntervalSeconds / gitPushOverdueMinutes /
-    // hourlyCheckEnabled PATCH that landed while the cron was idle.
+    // any gitPollIntervalSeconds / gitPushOverdueMinutes PATCH (or an
+    // activity-scan agent toggle) that landed while the cron was idle.
     const buildGitDelegatedCronObserver = () => new GitDelegatedCronObserver({
         db,
         eventBus,
@@ -316,7 +317,9 @@ export async function createObservers(deps) {
         githubRepos: selectGithubRepoSlugs(db),
         cadenceSeconds: config.gitPollIntervalSeconds,
         pushOverdueMinutes: config.gitPushOverdueMinutes,
-        hourlyCheckEnabled: config.hourlyCheckEnabled,
+        // Collision-avoidance hint only: the activity-scan agent row's enabled
+        // flag is the single switch (AGENTS_HUB_REDESIGN_PLAN.md §2).
+        activityScanEnabled: getAgentEnabled(db, "activity-scan", true),
     });
     if (hasActiveDelegatedGitLifecycleIntegration(db)) {
         observerManager.register(buildGitDelegatedCronObserver());
@@ -509,7 +512,7 @@ export async function createObservers(deps) {
     // ── 7.2 Observation summarizer (cost-reduction-structural §A) ──
     // Drains pending observation rows asynchronously: pre-filter →
     // per-source LLM call → `summary_text` + `novelty_score` written
-    // back to the row. The hourly_check skill consumes summaries instead
+    // back to the row. The activity_scan skill consumes summaries instead
     // of re-fetching raw content. Disabled cleanly via
     // `observationSummarizerEnabled` — when off, observations stay
     // pending and the skill drops to legacy fetch-on-doubt.
@@ -545,7 +548,7 @@ export async function createObservers(deps) {
             }
             // Codex / Gemini summarizer support is not yet implemented; the
             // worker translates `unsupported_backend` into a 'skipped' row so
-            // the hourly_check skill drops to its legacy fetch path.
+            // the activity_scan skill drops to its legacy fetch path.
             return new UnsupportedSummarizerClient(fallbackBackend, fallbackModel);
         })();
         observerManager.register(new ObservationSummarizerWorker({

package/dist/bootstrap/schedule-helpers.d.ts

@@ -25,11 +25,11 @@ export declare const WEEKLY_REVIEW_CATCHUP_DAYS_OF_WEEK: Set<number>;
 export declare function getDueCatchupRoutines(db: Database.Database, config: AgentConfig, agentDayStartUtc: string, agentDayEndUtc: string, now: Date): string[];
 /**
  * Decide whether the boot sequence should immediately fire one
- * catch-up `routine.hourly_check` (because the cron callback never ran
+ * catch-up `routine.activity_scan` (because the cron callback never ran
  * for the current slot — typically because the host was asleep / the
  * daemon was stopped during the slot window).
  *
- * Slot math mirrors `shouldFireHourlyTickAt` in `scheduler.ts` so the
+ * Slot math mirrors `shouldFireActivityScanTickAt` in `scheduler.ts` so the
  * catch-up always lands on the same slot the cron would have fired at.
  *
  * **Wrap-around active hours are NOT supported.** The active-hours
@@ -49,12 +49,12 @@ export declare function getDueCatchupRoutines(db: Database.Database, config: Age
  * config-write time, or (b) split the window into two non-wrap
  * ranges in the same call site that consumes them.
  */
-export declare function shouldCatchUpHourlyCheck(db: Database.Database, config: AgentConfig, now: Date): boolean;
+export declare function shouldCatchUpActivityScan(db: Database.Database, config: AgentConfig, now: Date): boolean;
 export declare function getProgressMinutesForHour(hour: number, dayBoundaryHour: number): number;
 export declare function hasFreshAgentDayTodayMd(todayMdPath: string, timezone: string | undefined, dayBoundaryHour: number, now?: Date): boolean;
 /**
  * Did `routine.morning_routine` complete successfully within the current
- * agent-day window? Used by the pre-routine gate that fronts hourly_check
+ * agent-day window? Used by the pre-routine gate that fronts activity_scan
  * and the review routines (evening / weekly / monthly) so they refuse to
  * run before the day has been properly opened.
  *
@@ -117,10 +117,10 @@ export interface StalledMorningRoutineWake {
  * without producing a successful `agent_actions` row. Returns the
  * offending row's metadata if stalled, null when the system is healthy.
  *
- * Pairs with `queueMorningRoutineWake` + the hourly-check pre-routine
+ * Pairs with `queueMorningRoutineWake` + the activity-scan pre-routine
  * gate. The dedup that keeps `queueMorningRoutineWake` from re-inserting
  * means a stuck wake row leaves the system in a silent freeze — the gate
- * skips `routine.hourly_check`, `routine.evening_review`, etc. forever
+ * skips `routine.activity_scan`, `routine.evening_review`, etc. forever
  * without surfacing to the user. This helper is the externally visible
  * signal the watchdog uses to break the silence.
  *
@@ -136,4 +136,102 @@ export declare function getStalledMorningRoutineWake(db: Database.Database, agen
     timezone?: string;
     dayBoundaryHour: number;
 }, thresholdMinutes: number, now?: Date): StalledMorningRoutineWake | null;
+/**
+ * Audit-row action types that count as "a morning-routine attempt started"
+ * for the missed-fire predicate below. The parent row
+ * (`routine.morning_routine`) is written when the pipeline finishes
+ * (success or failure); the Stage A row
+ * (`routine.morning_routine_today`) is written `in_progress` the moment
+ * the agent execution starts, so a hung Stage A is still visible as an
+ * attempt. The fetch-window pre-pass is deliberately NOT included — it
+ * also runs for hourly/scheduled flows, and counting it would let an
+ * unrelated pre-pass mask a dead morning pipeline.
+ */
+export declare const MORNING_ROUTINE_ATTEMPT_ACTION_TYPES: readonly ["routine.morning_routine", "routine.morning_routine_today"];
+/**
+ * Grace period after the agent-day boundary before the missed-fire
+ * self-heal may conclude the 04:00 cron tick was swallowed. Wide enough
+ * that the normal cron → queueMorningRoutineWake → ScheduleWatcher claim
+ * → Stage A start chain has long since produced either a wake row or an
+ * attempt row; short enough that a swallowed tick costs at most ~25 min
+ * (grace + one self-heal interval) once the machine is awake.
+ */
+export declare const MORNING_MISSED_FIRE_GRACE_MINUTES = 15;
+/**
+ * Epoch ms of the most recent morning-routine attempt (any result,
+ * including `in_progress`) started within the current agent-day, or null
+ * when nothing has been attempted yet. Pure read.
+ */
+export declare function getLatestMorningAttemptStartMs(db: Database.Database, agentDayConfig: {
+    timezone?: string;
+    dayBoundaryHour: number;
+}, now?: Date): number | null;
+export interface RecoverableStalledMorningWake {
+    /** agent_schedule.id of the `running` wake row to flip back to pending. */
+    id: number;
+    /** Minutes since the ScheduleWatcher claimed the row. */
+    claimedAgeMinutes: number;
+}
+/**
+ * Detect the hung-execution variant of the morning-routine silent stall:
+ * a wake row claimed to `running` at least `thresholdMinutes` ago with
+ * still no `routine.morning_routine` success for the current agent-day
+ * (machine slept mid-run and the backend stream died on the network
+ * change, the SDK call wedged, or the dispatch event was lost).
+ *
+ * `queueMorningRoutineWake`'s dedup treats a `running` row as "already
+ * in flight" and merges into it forever, so without recovery the day
+ * stays frozen until a daemon restart. The caller (scheduler self-heal
+ * tick) flips the returned row back to `pending` so the ScheduleWatcher
+ * re-claims it; the today-write-lock's wall-clock TTL guarantees a hung
+ * original cannot hold the lock against the re-run indefinitely.
+ *
+ * Staleness is measured from `task_context.claimedAt`, stamped by the
+ * ScheduleWatcher at claim time. That is the only signal that survives
+ * every confounder: `created_at` predates sleeps that delay the claim,
+ * `scheduled_for` is bumped by dedup merges, and attempt audit rows are
+ * windowed to the current agent-day (a run that started before the
+ * 04:00 boundary and hung across it has no attempt row "today").
+ * Invariants this leans on:
+ *   - boot recovery (`recoverOrphanedRunningSchedules`) clears every
+ *     `running` row at daemon start, so a live `running` row was always
+ *     claimed by the current process — which always stamps;
+ *   - `queueMorningRoutineWake`'s dedup-merge preserves unknown
+ *     task_context keys, so a 04:00 cron merge cannot strip the stamp.
+ * A row without a readable stamp (stamp UPDATE failed, malformed JSON)
+ * is left to the alert-only watchdog rather than guessed at.
+ *
+ * Pure read — the caller owns the UPDATE.
+ */
+export declare function getRecoverableStalledMorningWake(db: Database.Database, agentDayConfig: {
+    timezone?: string;
+    dayBoundaryHour: number;
+}, thresholdMinutes: number, now?: Date): RecoverableStalledMorningWake | null;
+/**
+ * Detect the missed-fire variant of the morning-routine silent stall:
+ * the machine was asleep at the day-boundary minute, node-cron silently
+ * dropped the tick (it never replays missed firings), and nothing since
+ * has re-queued the routine. Observable signature, all three at once:
+ *
+ *   1. no morning-routine attempt has *started* this agent-day (any
+ *      result — a failed/exhausted retry chain counts as attempted, so
+ *      this self-heal never resurrects a chain that
+ *      `scheduleMorningRetry` deliberately stopped after MAX_RETRIES);
+ *   2. no `pending`/`running` morning wake row exists (the cron, the
+ *      wake catch-up, and the retry chain all leave one when they are
+ *      mid-flight);
+ *   3. the agent-day is at least `graceMinutes` old, so a healthy cron
+ *      fire has had ample time to produce 1 or 2.
+ *
+ * Complements the WakeDetector: gaps shorter than its 5-min threshold
+ * that straddle the boundary minute (lid closed 03:59–04:02), or a
+ * detector failure, still converge here within one self-heal interval.
+ *
+ * Pure read — the caller routes through `queueMorningRoutineWake`,
+ * whose DB-backed dedup makes double-queueing impossible.
+ */
+export declare function shouldQueueMissedMorningFire(db: Database.Database, agentDayConfig: {
+    timezone?: string;
+    dayBoundaryHour: number;
+}, graceMinutes: number, now?: Date): boolean;
 export declare function readSkillCurationCadence(db: Database.Database): "daily" | "weekly" | "monthly";