@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/dispatcher-types.d.ts

@@ -51,7 +51,27 @@ export interface IDashboardStream {
 }
 /** Interface for ContextBuilder — implemented in Phase 1D */
 export interface IContextBuilder {
-    build(event: Event): Promise<string>;
+    build(event: Event, opts?: {
+        /**
+         * Suppress the active-session `<conversation_history>` block
+         * when the caller knows the cross-session bridge will cover the
+         * same rows. See `ContextBuilder.build` for the full rationale
+         * (DM-HISTORY-CONTINUITY-FIX H-3).
+         */
+        skipActiveHistoryBlock?: boolean;
+    }): Promise<string>;
+    /**
+     * Narrow companion to `build()` used by the dispatcher's resume
+     * branch when there are proactive forwards that landed in this
+     * scope *after* the SDK session was started. Returns the minimal
+     * `<proactive_forwards_since_last_turn>` block, or `null` when no
+     * such forwards exist. The full context block must NOT be appended
+     * to a resume payload — the SDK session already holds the cached
+     * system prompt; re-injecting it bills `<management_rules>`,
+     * `<today>`, the entire `<conversation_history>` etc. against the
+     * user turn instead of the cache (DM-HISTORY-CONTINUITY-FIX H-2).
+     */
+    buildResumeCatchupContext(event: Event, sessionStartedAtMs: number): Promise<string | null>;
 }
 /** Function type for resolving task flow templates by event type */
 export type GetTaskFlow = (eventType: string, backendId?: string, integrations?: Partial<Record<IntegrationKey, IntegrationState>>) => string;
@@ -137,6 +157,24 @@ export interface ISessionManager {
         id: number;
     } | null>;
     updateSession(id: number, sessionId: string, model: string, backend?: BackendId): Promise<void>;
+    /**
+     * Refresh `started_at` to the current wall clock. Called from the
+     * fresh-execute branch of the dispatcher right before
+     * `contextBuilder.build()` so the row's `started_at` matches the
+     * `<today snapshot_at="...">` timestamp baked into THIS turn's
+     * system prompt.
+     *
+     * Background: pre-existing design comment in dispatcher-message-
+     * handler.ts says "started_at is the moment <today> was captured".
+     * That invariant only held by coincidence — every conversation_sessions
+     * row was previously INSERTed by the same fresh-execute that built
+     * the prompt. Post-H-1 (scheduler.handleDirectDm inserts rows
+     * out-of-band) and post-reset-in-place (H-3 path keeps the row but
+     * blanks backend_session_id), started_at can lag the actual SDK-
+     * session-bind time by hours, causing the H-2 catchup builder to
+     * re-emit forwards the SDK already has.
+     */
+    markFreshExecuteStart(id: number): void;
     touchSession(id: number): void;
     closeSession(id: number): void;
     /**
@@ -155,7 +193,6 @@ export interface ISessionManager {
      * event.channel captured when the user POSTed their message.
      */
     getActiveChannelIdForSession(sessionId: number): string | null;
-    isCloseCommand(content: string): boolean;
     getDmPlatformsWithNewMessages(): string[];
     getUnsummarizedDmMessages(platform: string): {
         role: string;
@@ -186,6 +223,38 @@ export interface IMessageRecorder {
         notificationDispatchId?: string | null;
     }): boolean;
 }
+/**
+ * `agent_actions.detail.dailyWrite` shape — see
+ * `docs/design/appendices/daily-journal-daemon-write.md` §4.3.
+ *
+ * Persisted on the Stage B (`routine.morning_routine_journal`) row both
+ * on the success path (`audit.logAction(.., dailyWrite)`) and on the
+ * failure path (`audit.logError(.., { dailyWrite })`) so downstream
+ * readers — `agent-journal-appender.formatJournalLine`, the §4.7b
+ * partial-extract streak detector — can branch on `detail.dailyWrite.ok`
+ * for a single source of truth.
+ *
+ * Discriminated union on `ok`:
+ *   - `"complete"` — both XML blocks extracted, frontmatter parsed,
+ *     daily file written.
+ *   - `"partial"` — body extracted but frontmatter parsing failed; the
+ *     daily file IS on disk with empty projects/people/tags arrays.
+ *     `partialReason` identifies which sub-shape failed.
+ *   - `false` — no daily file written. `reason` identifies why.
+ */
+export type DailyWriteAuditDetail = {
+    ok: "complete";
+    bytesWritten: number;
+    wroteMode: "put" | "append_revision";
+} | {
+    ok: "partial";
+    bytesWritten: number;
+    wroteMode: "put" | "append_revision";
+    partialReason: "frontmatter_tag_missing" | "frontmatter_invalid_json" | "frontmatter_schema_invalid";
+} | {
+    ok: false;
+    reason: "stage_b_null" | "empty_output" | "body_tag_missing" | "write_failed";
+};
 /** Interface for AuditLogger — implemented in Phase 1D */
 export interface IAuditLogger {
     logAction(params: {
@@ -226,7 +295,7 @@ export interface IAuditLogger {
             triggerMatched: boolean;
         };
         /**
-         * PRE_PASS_FAN_OUT_DESIGN.md §7.1 — fan-out sub-session telemetry.
+         * docs/design/appendices/pre-pass-fan-out.md §7.1 — fan-out sub-session telemetry.
          * Present only on routine.fetch_window rows emitted by the coordinator.
          *
          * `retriedFromAttempt` is the index of the prior attempt that this row
@@ -241,7 +310,7 @@ export interface IAuditLogger {
             /**
              * §7.3 metric aggregation key — `routine.<name>` matching the
              * parent routine that triggered the fan-out (e.g.
-             * `routine.morning_routine_initial`). Carried explicitly so the
+             * `routine.morning_routine`). Carried explicitly so the
              * `/metrics/pre-pass` SQL aggregator can group by routine without
              * a join back to the parent's agent_actions row.
              */
@@ -281,6 +350,22 @@ export interface IAuditLogger {
              */
             requestedBackend?: BackendId;
         };
+        /**
+         * docs/design/appendices/daily-journal-daemon-write.md §4.11 — daily
+         * journal compose outcome for `routine.morning_routine_journal`
+         * (Stage B) rows. The orchestrator threads it through
+         * `persistStageAuditRows` so `detail.dailyWrite` lands on the same
+         * INSERT/UPSERT as the row's terminal `result` — no post-UPDATE
+         * needed. `agent-journal-appender.formatJournalLine` reads
+         * `detail.dailyWrite.ok` to render the "complete" / "partial" /
+         * "failed" verbs without grepping the fs.
+         *
+         * Shape mirrors `DailyJournalComposeResult` — we copy it inline
+         * rather than importing the morning module to keep audit decoupled
+         * from the morning pipeline's import graph (audit is at the bottom
+         * of the dep stack).
+         */
+        dailyWrite?: DailyWriteAuditDetail | null;
     }): void;
     logSkip(event: Event, reason: string, trigger: "reactive" | "autonomous"): void;
     logError(event: Event, error: Error, trigger: "reactive" | "autonomous", context?: {
@@ -315,6 +400,14 @@ export interface IAuditLogger {
             fallbackTriggered?: boolean;
             requestedBackend?: BackendId;
         };
+        /**
+         * See `logAction.dailyWrite` JSDoc. Mirrored on the failure path
+         * so a Stage B `recordStageFailure` row also carries the
+         * dailyWrite outcome — useful for the §4.7b streak detector when
+         * Stage B's session threw but a prior attempt's daily file is on
+         * disk.
+         */
+        dailyWrite?: DailyWriteAuditDetail | null;
     }): void;
     /**
      * Chat-attachments Phase 1 — log an inbound (user→agent) or outbound
@@ -336,6 +429,27 @@ export interface IAuditLogger {
      * non-bang DMs. See docs/design/backlog/messaging-bang-commands.md §6.6.
      */
     logBangCommand(event: MessageEvent, detail: BangCommandDetail): void;
+    /**
+     * morning-routine-optimization.md Phase 6 — pre-insert a sentinel
+     * `result='in_progress'` row keyed `(event_id=correlationId,
+     * action_type)` BEFORE spawning a session that needs to call
+     * `PATCH /api/agent-actions/self` mid-run. The agent's PATCH resolves
+     * the in-progress row by `(event_id, action_type, result='in_progress')`
+     * and writes structured metadata that daemon-side consumers
+     * (`AgentJournalAppender`, anomaly surfacing) read after the session
+     * settles. The subsequent `logAction` call UPSERTs the same row to
+     * its terminal state, preserving the metadata column.
+     *
+     * Returns the inserted rowid (`-1` on SQL failure — caller still
+     * proceeds; `logAction` falls back to its legacy fresh-INSERT path).
+     */
+    insertInProgressRow(args: {
+        correlationId: string | null;
+        actionType: string;
+        trigger: "reactive" | "autonomous";
+        backend?: string;
+        modelId?: string;
+    }): number;
 }
 /**
  * Audit detail for `bang_command` rows. `status` distinguishes:
@@ -350,10 +464,17 @@ export interface IAuditLogger {
  */
 export interface BangCommandDetail {
     command: string;
-    status: "ok" | "skipped" | "unknown" | "invalid_args" | "paused_decline";
+    /**
+     * `paused_blocked` distinguishes "recognised command refused because the
+     * agent is paused" from `paused_decline` ("non-command DM while paused"
+     * — generic notice path). The former lets us attribute the user's
+     * intent to a specific command in `agent_actions` instead of folding it
+     * into the generic decline.
+     */
+    status: "ok" | "skipped" | "unknown" | "invalid_args" | "paused_decline" | "paused_blocked";
     [extra: string]: unknown;
 }
-export type TriggerHourlyCheckSkipReason = "morning_routine_active" | "hourly_check_in_progress" | "below_threshold" | "setup_incomplete" | "setup_in_progress" | "vault_degraded" | "user_paused" | "gate_stage0_silent" | "gate_stage2_log_only";
+export type TriggerHourlyCheckSkipReason = "morning_routine_active" | "hourly_check_in_progress" | "below_threshold" | "setup_incomplete" | "setup_in_progress" | "vault_degraded" | "user_paused" | "morning_routine_pending_for_today" | "gate_stage0_silent" | "gate_stage2_log_only";
 export type SetupMode = "initial" | "update";
 /**
  * Unwrap the partial-run context the audit logger needs for a failed
@@ -382,15 +503,22 @@ export interface TriggerHourlyCheckResult {
     minObservations: number;
     forced: boolean;
     /**
-     * cost-reduction-structural §B — populated whenever the gate ran
-     * (any mode). Mirrors what was logged to `agent_actions` so the
-     * cron caller's metrics path can attribute without a re-read.
+     * cost-reduction-structural §B — populated whenever the gate ran.
+     * Mirrors what was logged to `agent_actions` so the cron caller's
+     * metrics path can attribute without a re-read.
      */
     gateStage?: "stage0_silent" | "stage2" | "stage3";
-    /** Effective stage actually executed when mode!=off. */
-    appliedStage?: "stage0_silent" | "stage2_log_only" | "stage3" | "stage3_shadow";
-    gateMode?: "off" | "shadow" | "live";
+    /** Effective stage actually executed. */
+    appliedStage?: "stage0_silent" | "stage2_log_only" | "stage3";
     gateReason?: string;
+    /**
+     * HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.5 — true when pre-pass for
+     * any non-direct integration failed during `harvestForGate` and the
+     * gate force-escalated to `stage3` regardless of the signal verdict.
+     * Surfaces in the audit row so dashboards can flag tickets where the
+     * Stage 3 run was a cautious escalate vs. a real signal.
+     */
+    cautiousEscalate?: boolean;
 }
 /**
  * cost-reduction-structural §B — extract the JSON verdict from a
@@ -408,4 +536,3 @@ export interface InFlightExecutionInfo {
     taskType?: string;
     detail?: string;
 }
-//# sourceMappingURL=dispatcher-types.d.ts.map

package/dist/core/dispatcher-types.js

@@ -103,4 +103,3 @@ export function parseStage2Verdict(output) {
         return action;
     return "failed";
 }
-//# sourceMappingURL=dispatcher-types.js.map

package/dist/core/dispatcher.d.ts

@@ -11,11 +11,13 @@ import type { RoadmapWriteLockManager } from "./roadmap-write-lock.js";
 import type { AgentWriteTracker } from "../safety/agent-write-tracker.js";
 import type { AttachmentStore } from "../services/attachments/store.js";
 import type { VoiceTranscriber } from "../services/voice/transcriber.js";
+import type { AgentExecutionTracker } from "./agents/agent-execution-tracker.js";
 export type { IAgentCore, StreamCallbacks } from "./agent-core.js";
 export type { IAgentRouter } from "./backends/backend-router.js";
-import { parseStage2Verdict, type ReplyActivityHandle, type IDashboardStream, type IContextBuilder, type GetTaskFlow, type INotificationManager, type ISessionManager, type IMessageRecorder, type IAuditLogger, type BangCommandDetail, type TriggerHourlyCheckSkipReason, type SetupMode, type TriggerHourlyCheckOptions, type TriggerHourlyCheckResult, type InFlightExecutionInfo } from "./dispatcher-types.js";
+import { parseStage2Verdict, type ReplyActivityHandle, type IDashboardStream, type IContextBuilder, type GetTaskFlow, type INotificationManager, type ISessionManager, type IMessageRecorder, type IAuditLogger, type BangCommandDetail, type DailyWriteAuditDetail, type TriggerHourlyCheckSkipReason, type SetupMode, type TriggerHourlyCheckOptions, type TriggerHourlyCheckResult, type InFlightExecutionInfo } from "./dispatcher-types.js";
 export { parseStage2Verdict, };
-export type { ReplyActivityHandle, IDashboardStream, IContextBuilder, GetTaskFlow, INotificationManager, ISessionManager, IMessageRecorder, IAuditLogger, BangCommandDetail, TriggerHourlyCheckSkipReason, SetupMode, TriggerHourlyCheckOptions, TriggerHourlyCheckResult, InFlightExecutionInfo, };
+export type { ReplyActivityHandle, IDashboardStream, IContextBuilder, GetTaskFlow, INotificationManager, ISessionManager, IMessageRecorder, IAuditLogger, BangCommandDetail, DailyWriteAuditDetail, TriggerHourlyCheckSkipReason, SetupMode, TriggerHourlyCheckOptions, TriggerHourlyCheckResult, InFlightExecutionInfo, };
+import type { QueueMorningRoutineWake } from "./dispatcher-hourly-check.js";
 import { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS } from "./dispatcher-scheduled-tasks.js";
 export { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS };
 export declare class EventDispatcher {
@@ -60,6 +62,45 @@ export declare class EventDispatcher {
      * Spec: docs/design/backlog/messaging-bang-commands.md
      */
     private bangCommandRegistry;
+    /**
+     * Phase B-4 — DM-issued purchase confirmation handler. Wired at
+     * daemon startup from `index.ts` via `setPurchaseHandler`. Null
+     * when B-4 is not enabled at startup; the dispatcher's inbound
+     * classifier no-ops in that case and the workflow runner refuses
+     * `variant: "purchase"` calls with `purchase_b4_disabled`.
+     *
+     * Spec: MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17 / §13 step 50.
+     */
+    private purchaseHandler;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 — lite-final-confirm
+     * handler. Wired at daemon startup from `bootstrap/event-pipeline.ts`
+     * via `setFinalConfirmHandler`. The inbound classifier (§14.11 Q#6)
+     * routes `!~xxxxxxxx` replies between this handler and
+     * `purchaseHandler` by querying both stores via `lookupByRaw` and
+     * dispatching to whichever returned a row.
+     */
+    private finalConfirmHandler;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — Phase 3 wiring. The
+     * dispatcher routes `scheduled.browser_task` events to the runner.
+     * Wired at daemon startup from `bootstrap/event-pipeline.ts` via
+     * `setBrowserTaskRunner`. Null when the runner factory has not yet
+     * landed (test harness or stripped-down boot path) — the dispatch
+     * branch flips the `agent_schedule` row to `failed
+     * (runner_unavailable)` in that case so the row doesn't park.
+     */
+    private browserTaskRunner;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §7 — "the user is DMed" on fire-time
+     * dispatch failure (`site_unregistered`, `allowlist_rejected`,
+     * `runner_unavailable`). The runner's own `notifier.notifyTerminal`
+     * only fires when the runner is reached, which is exactly NOT the
+     * case for these pre-runner failure paths. Wired from `event-pipeline.ts`
+     * alongside the runner factory so a fire-time failure DMs the owner
+     * instead of leaving the row silently flipped to `failed` in the DB.
+     */
+    private browserTaskTerminalNotifier;
     /**
      * Current setup mode — scope-agnostic flag that survives internal
      * direct-message session refresh (day boundary, stale flag, etc). Previously this
@@ -90,6 +131,37 @@ export declare class EventDispatcher {
     private lastRoadmapRefreshEmitMs;
     private morningRoutineInProgress;
     private hourlyCheckInProgress;
+    /**
+     * Wall-clock timestamp (ms since epoch) of the most recent flip of
+     * `hourlyCheckInProgress` to `true`, or `null` when the flag is false.
+     *
+     * Paired with `HOURLY_CHECK_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`.
+     *
+     * Read side (`isHourlyCheckInProgress` 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.
+     */
+    private hourlyCheckInProgressAt;
+    /**
+     * Upper bound for how long `hourlyCheckInProgress=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
+     * ~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.
+     */
+    private static readonly HOURLY_CHECK_FLAG_MAX_AGE_MS;
     /**
      * P22 §3.4 — wired by `index.ts` after the daemon's data dir + skills root
      * are known. Returns a `{runId, runToken, workdirPath, targetSkills}` tuple
@@ -129,6 +201,14 @@ export declare class EventDispatcher {
      *  `docs/design/appendices/delegated-sync-opt-in.md` and the worker's
      *  `runDisabledCadencesForHourlyCheck` method. */
     private delegatedSyncRefresh;
+    /**
+     * Injected lazily via `setQueueMorningRoutineWake` (wired in `index.ts`
+     * after `AgentScheduler` is constructed). The pre-routine morning_routine
+     * gate uses this to enqueue a recovery wake when the current agent-day's
+     * morning_routine has not run yet — typical cause: macOS App Nap / sleep
+     * suspended node-cron through the 04:00 tick. See `morningRoutineRanToday`
+     * in `bootstrap/schedule-helpers.ts` for the authoritative predicate. */
+    private queueMorningRoutineWake;
     /** Injected lazily via `setVoiceTranscriber` — optional. When null,
      *  inbound audio attachments fall back to the path-only prompt block
      *  exactly as they did before the local-Whisper layer landed. See
@@ -149,6 +229,16 @@ export declare class EventDispatcher {
      * carried on the default `event` SSE channel.
      */
     private eventBroadcaster;
+    /**
+     * AGENT_DEFINITIONS_DESIGN.md §8 — per-firing execution recorder. Wired
+     * post-construction via {@link setAgentExecutionTracker} (the recorder +
+     * contextDir + SSE deps only exist after the event-pipeline factory runs).
+     * `null` in tests / pre-wire → no execution rows are written, preserving the
+     * legacy dispatch shape. The ResultProcessor reaches it through a call-time
+     * closure (see the constructor's `recordExecutionOutcome` dep) so it stays
+     * live even though the tracker is set after the processor is built.
+     */
+    private agentExecutionTracker;
     /**
      * Notify-dedup tracking — set of correlationIds for in-flight events
      * that have already invoked `POST /api/notify` from inside the agent
@@ -211,7 +301,7 @@ export declare class EventDispatcher {
      * pre-existing C1 atomic check-and-set semantics survive the split.
      */
     /**
-     * ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D1 — shared pre-pass
+     * docs/design/appendices/routine-data-acquisition.md Phase 4 / D1 — shared pre-pass
      * runner for `routine.fetch_window`. Injected into HourlyCheckCoordinator
      * (D3), MorningRoutineRunner (D2), and ScheduledTaskRunner (D4) so
      * every routine that has rows in `ROUTINE_WINDOWS` gets the same
@@ -255,6 +345,43 @@ export declare class EventDispatcher {
     private loadPersistedSetupMode;
     /** Set the SignalDetector for implicit feedback collection from user messages. */
     setSignalDetector(detector: SignalDetector): void;
+    /**
+     * Wire the B-4 purchase-confirmation handler. Called once at startup
+     * from `index.ts` after the messaging hub is up — the handler's
+     * `sender` dependency requires a live MessageHub for outbound DMs.
+     * Calling more than once replaces the prior reference (used by the
+     * dashboard's "Disable B-4" flow which can later re-enable).
+     */
+    setPurchaseHandler(handler: import("../services/browser-history/automation/purchase-handler.js").PurchaseHandler | null): void;
+    /** Read accessor — used by the route layer's wiring to thread the
+     *  same instance into `ApiDependencies.purchaseHandler` without a
+     *  parallel construction path. */
+    getPurchaseHandler(): import("../services/browser-history/automation/purchase-handler.js").PurchaseHandler | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 — wire the lite-final-
+     * confirm handler. Mirrors `setPurchaseHandler` so the inbound `!~`
+     * classifier and the route layer share one instance via the
+     * dispatcher.
+     */
+    setFinalConfirmHandler(handler: import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null): void;
+    getFinalConfirmHandler(): import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — wire the browser-task
+     * runner so the `scheduled.browser_task` dispatch branch can hand
+     * fire-time events to it. Pairs with the `event-pipeline.ts`
+     * `createBrowserTaskRunner` factory call (Phase 3).
+     */
+    setBrowserTaskRunner(runner: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null): void;
+    getBrowserTaskRunner(): import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §7 — wire the terminal-state DM
+     * emitter used by the `scheduled.browser_task` failure paths (see
+     * `browserTaskTerminalNotifier` field doc). `event-pipeline.ts` passes
+     * the same `BrowserTaskNotifier` instance that's threaded into the
+     * runner so a single DM-emission contract covers both pre-runner
+     * fire-time failures and the runner's own non-completed terminals.
+     */
+    setBrowserTaskTerminalNotifier(notifier: import("../services/browser-task/browser-task-runner.js").BrowserTaskNotifier | null): void;
     /** Set the dashboard stream adapter for real-time response streaming. */
     setDashboardStream(adapter: IDashboardStream): void;
     /**
@@ -287,6 +414,15 @@ export declare class EventDispatcher {
      * pre-injection behaviour.
      */
     setDelegatedSyncRefresh(fn: (() => Promise<void>) | null): void;
+    /**
+     * Wire the scheduler's `queueMorningRoutineWake` so the pre-routine
+     * gate (hourly_check + 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
+     * routine — the daemon does not "silently" run a stale review.
+     */
+    setQueueMorningRoutineWake(fn: QueueMorningRoutineWake | null): void;
     /**
      * Wire the dashboard SSE broadcaster so routine-start / routine-complete
      * progress events flow to subscribed clients. Optional — when unset,
@@ -297,6 +433,21 @@ export declare class EventDispatcher {
     setEventBroadcaster(broadcaster: {
         broadcastEvent: (data: unknown) => void;
     } | null): void;
+    /**
+     * Wire the per-firing execution tracker (AGENT_DEFINITIONS_DESIGN.md §8).
+     * Optional — when unset, no `agent_executions` rows are written and dispatch
+     * behaves exactly as before. Set once at boot from the event-pipeline factory.
+     */
+    setAgentExecutionTracker(tracker: AgentExecutionTracker): void;
+    /**
+     * 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
+     * records an execution. Reactive DMs resolve to no Agent (no routine / no
+     * schedule row / no `task_context.agent_id`) and are a near-free no-op.
+     */
+    private beginAgentExecution;
+    /** Classify an execution's trigger for the rollup row (§5.2). */
+    private resolveExecutionTrigger;
     /**
      * Internal helper: broadcast `routine_started` or `routine_completed` for
      * the given routine event. Centralised so the JSON shape and failure
@@ -379,7 +530,7 @@ export declare class EventDispatcher {
      * scheduled wake tasks, startup catchup, calendar-poller reactive events).
      *
      * Two layers:
-     *  - **Cold gate**: `rules/management.md` must exist. Before initial setup
+     *  - **Cold gate**: `policies/management.md` must exist. Before initial setup
      *    there is no policy document, no user/profile.md, no today.md — running
      *    routines would produce garbage AND, crucially, any loud prompt-context
      *    write from such a routine can trigger
@@ -440,8 +591,47 @@ export declare class EventDispatcher {
      * `docs/design/09-safety-cost.md` §9.5.4.
      */
     isMorningRoutineActive(): boolean;
+    /**
+     * Release a claimed `agent_schedule` row back to `pending` when an
+     * autonomous scheduled event is short-circuited before its dispatch
+     * branch can run (setup gate or autonomous cost cap). The ScheduleWatcher
+     * claims the row as `running` and hands the event to the EventBus before
+     * these gates are evaluated, so a silent skip would otherwise leave the
+     * row stuck in `running` forever — blocking both boot recovery (there is
+     * none for stuck `running` schedule rows) and the recurring
+     * `NOT EXISTS(status IN pending/running)` reconcile guard. Reverting to
+     * `pending` (rather than `failed`/`skipped`) is correct because the skip
+     * is transient: once the cost-cap window rolls over or setup completes,
+     * the next ScheduleWatcher tick should re-evaluate and fire the row. This
+     * matches the quiet-hours deferral precedent in the scheduler. The
+     * `WHERE ... status = 'running'` clause keeps it idempotent — a no-op for
+     * non-scheduled events or already-terminal rows.
+     */
+    private releaseClaimedSchedule;
     private dispatchSafe;
     private dispatch;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — dispatch branch for
+     * `scheduled.browser_task`. Defers the heavy lifting to
+     * `handleScheduledBrowserTask` (validation + row creation + runner
+     * handoff) and translates the discriminated outcome into the
+     * `agent_schedule.status` write so the row lifecycle stays in sync.
+     *
+     * Outcomes map to:
+     *   - `dispatched` / `row_already_exists` → `agent_schedule` row
+     *     `completed` (the dispatch itself succeeded; the `browser_task`
+     *     row's own state machine tracks the long-running outcome).
+     *   - `site_unregistered` / `allowlist_rejected` / `task_context_invalid`
+     *     / `runner_unavailable` → `agent_schedule` row `failed` (the
+     *     dispatch could not proceed).
+     *
+     * A throw escapes upward into the `dispatch()` try/catch, where
+     * `errorRouter.handleError` flips the schedule row to `failed` via
+     * the existing `isScheduledEvent(event) && event.scheduleId` branch
+     * (defence-in-depth — the explicit `failed` writes here cover every
+     * normal-path failure so the error route never has to).
+     */
+    private handleScheduledBrowserTaskDispatch;
     private getMessageExecutionKey;
     private runWithSessionGate;
     /**
@@ -508,4 +698,3 @@ export declare class EventDispatcher {
         bypassDedup?: boolean;
     }): void;
 }
-//# sourceMappingURL=dispatcher.d.ts.map