@aitne/daemon 0.1.10 → 0.1.11

package/dist/api/routes/background-task.js

@@ -0,0 +1,338 @@
+/**
+ * /api/background-task/* — BACKGROUND_TASK_RUNNER_DESIGN.md §7.
+ *
+ * The generic detached-task surface. The DM agent POSTs a self-contained
+ * brief, acks, and ends its turn; the runner runs the worker detached and
+ * writes an artifact; the delivery boundary surfaces it. GET /:id returns
+ * the artifact (the DM agent's "read the result" affordance for precise
+ * follow-ups). /clarify relays the owner's answer; /cancel aborts.
+ *
+ * Routes (§7):
+ *   POST   /api/background-task            spawn (or schedule via scheduleAt)
+ *   GET    /api/background-task            list
+ *   GET    /api/background-task/:id        the artifact (full detail)
+ *   POST   /api/background-task/:id/clarify  answer a pending clarification
+ *   POST   /api/background-task/:id/cancel   abort in-flight task
+ *
+ * Excluded from the 100% coverage gate — route glue. The pure pieces
+ * (budget envelope, slot manager) are 100%-covered peers.
+ */
+import { randomUUID } from "node:crypto";
+import { Hono } from "hono";
+import { z } from "zod";
+import { formatSqliteDatetime } from "@aitne/shared";
+import { countBackgroundTasks, createBackgroundTask, findRecentDuplicateBackgroundTask, getBackgroundTask, listBackgroundTasks, markTerminal, } from "../../db/background-task-store.js";
+import { getOpenClarificationForTask, listClarificationsForTask, resolveClarification, } from "../../db/background-task-clarifications-store.js";
+import { listPrimaryChannels, channelRef, } from "../../db/browser-automation-purchase-primary-channels-store.js";
+import { selectDefaultOwnerChannel } from "../../messaging/owner-channels.js";
+import { createBackgroundTaskTransitionEmitter } from "../../services/background-task/background-task-transition-events.js";
+import { createLogger } from "../../logging.js";
+import { readJsonBody } from "../json-body.js";
+const logger = createLogger("background-task-routes");
+const postBodySchema = z.object({
+    brief: z.string().min(1).max(16_384),
+    title: z.string().min(1).max(200).optional(),
+    notificationPolicy: z
+        .enum(["always", "if_significant", "silent"])
+        .optional()
+        .default("always"),
+    // Phase 4 if_significant criteria DSL (§4.3) — optional structured
+    // conditions the worker checks one-by-one. Each is a concrete, atomic
+    // condition ("any repo's main build is red"); the worker sets
+    // notify=true iff ANY is met. Up to 12, each ≤500 chars.
+    significanceCriteria: z
+        .array(z.string().min(1).max(500))
+        .max(12)
+        .optional(),
+    tier: z.enum(["lite", "medium", "high"]).optional(),
+    maxBudgetUsd: z.number().positive().max(15).optional(),
+    originatingChannel: z.string().optional(),
+    correlationId: z.string().optional(),
+    scheduleAt: z.string().datetime({ offset: true }).optional(),
+});
+const clarifyBodySchema = z.object({
+    clarificationId: z.string().uuid().optional(),
+    answer: z.string().min(1).max(8192),
+});
+const cancelBodySchema = z
+    .object({ reason: z.string().max(256).optional() })
+    .optional();
+function toWire(row) {
+    return {
+        id: row.id,
+        brief: row.brief,
+        title: row.title,
+        state: row.state,
+        notificationPolicy: row.notificationPolicy,
+        significanceCriteria: row.significanceCriteria,
+        report: row.report,
+        draft: row.draft,
+        notify: row.notify,
+        significance: row.significance,
+        artifactPath: row.artifactPath,
+        outcomeDetail: row.outcomeDetail,
+        originatingChannel: row.originatingChannel,
+        correlationId: row.correlationId,
+        scheduleRowId: row.scheduleRowId,
+        tier: row.tier,
+        maxBudgetUsd: row.maxBudgetUsd,
+        createdAt: row.createdAt,
+        startedAt: row.startedAt,
+        finishedAt: row.finishedAt,
+        deliveredAt: row.deliveredAt,
+    };
+}
+/** Resolve the originating channel: header / body preferred, intersected
+ *  with the primary set ∪ the owner's most-recent DM channel. A null
+ *  result files the artifact but cannot DM it. */
+function resolveOriginatingChannel(deps, headerChannel, bodyChannel) {
+    const requested = headerChannel ?? bodyChannel ?? null;
+    const primary = listPrimaryChannels(deps.db).map((row) => channelRef(row.platform, row.channelId));
+    const ownerDefault = selectDefaultOwnerChannel(deps.db);
+    const ownerDefaultRef = ownerDefault
+        ? channelRef(ownerDefault.platform, ownerDefault.channelId)
+        : null;
+    if (requested) {
+        if (primary.includes(requested))
+            return requested;
+        return primary[0] ?? ownerDefaultRef;
+    }
+    return primary[0] ?? ownerDefaultRef;
+}
+export function createBackgroundTaskRoutes(deps) {
+    const app = new Hono();
+    const transitionEmitter = createBackgroundTaskTransitionEmitter(deps.eventBroadcaster ?? null);
+    // ── POST /api/background-task ─────────────────────────────────────────
+    app.post("/background-task", async (c) => {
+        const body = await readJsonBody(c);
+        if (!body.ok)
+            return body.response;
+        const parsed = postBodySchema.safeParse(body.body);
+        if (!parsed.success) {
+            return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
+        }
+        const input = parsed.data;
+        const resolvedChannel = resolveOriginatingChannel(deps, c.req.header("x-pa-channel-ref"), input.originatingChannel);
+        if (resolvedChannel === null) {
+            logger.warn({}, "background-task: no originating channel resolvable — the result will be filed but cannot be DMed");
+        }
+        const id = randomUUID();
+        const title = input.title ?? null;
+        // ── Scheduled path ──────────────────────────────────────────────
+        if (input.scheduleAt !== undefined) {
+            const scheduledAtMs = Date.parse(input.scheduleAt);
+            if (!Number.isFinite(scheduledAtMs)) {
+                return c.json({ error: "invalid_schedule_at", detail: "scheduleAt must parse as ISO 8601." }, 400);
+            }
+            const nowMs = Date.now();
+            if (scheduledAtMs < nowMs - 60_000) {
+                return c.json({
+                    error: "schedule_at_in_past",
+                    detail: `scheduleAt resolves to more than 60s in the past (delta=${nowMs - scheduledAtMs}ms).`,
+                }, 400);
+            }
+            const scheduleContext = {
+                preGeneratedTaskId: id,
+                brief: input.brief,
+                title,
+                notificationPolicy: input.notificationPolicy,
+                significanceCriteria: input.significanceCriteria ?? null,
+                tier: input.tier ?? null,
+                maxBudgetUsd: input.maxBudgetUsd ?? null,
+                originatingChannel: resolvedChannel,
+            };
+            const correlationId = input.correlationId ?? randomUUID();
+            const label = title ?? input.brief.slice(0, 200);
+            const insertResult = deps.db
+                .prepare(`INSERT INTO agent_schedule
+             (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+           VALUES (?, 'background_task', ?, ?, ?, ?, NULL, 'pending')`)
+                .run(formatSqliteDatetime(new Date(scheduledAtMs)), label, input.brief, JSON.stringify(scheduleContext), correlationId);
+            const scheduleRowId = Number(insertResult.lastInsertRowid);
+            logger.info({ taskId: id, scheduleRowId, scheduledAt: input.scheduleAt }, "background-task scheduled — fire-time row creation deferred to dispatcher");
+            return c.json({ taskId: id, status: "scheduled", scheduledFor: scheduledAtMs, scheduleRowId }, 202);
+        }
+        // ── Brief-dedup (§10.3 / Phase 4) ───────────────────────────────
+        // A replayed trigger (the RESEARCH_CLUSTER_COST_FIX_PLAN runaway
+        // class) or an over-eager agent POSTing the same brief repeatedly
+        // within minutes would otherwise spawn N detached workers. Collapse
+        // onto the first still-relevant identical task. `0` disables.
+        const dedupWindowMinutes = deps.config?.backgroundTaskDedupWindowMinutes ?? 0;
+        if (dedupWindowMinutes > 0) {
+            const existing = findRecentDuplicateBackgroundTask(deps.db, {
+                brief: input.brief,
+                tier: input.tier ?? null,
+                sinceMs: Date.now() - dedupWindowMinutes * 60_000,
+            });
+            if (existing) {
+                logger.info({
+                    taskId: existing.id,
+                    state: existing.state,
+                    windowMinutes: dedupWindowMinutes,
+                }, "background-task dedup — identical brief within window; returning existing task instead of spawning a duplicate");
+                return c.json({
+                    taskId: existing.id,
+                    status: existing.state,
+                    deduplicated: true,
+                    row: toWire(existing),
+                }, 202);
+            }
+        }
+        const createdAt = Date.now();
+        const row = createBackgroundTask(deps.db, {
+            id,
+            brief: input.brief,
+            title,
+            notificationPolicy: input.notificationPolicy,
+            significanceCriteria: input.significanceCriteria ?? null,
+            originatingChannel: resolvedChannel,
+            correlationId: input.correlationId ?? null,
+            scheduleRowId: null,
+            tier: input.tier ?? null,
+            maxBudgetUsd: input.maxBudgetUsd ?? null,
+            createdAt,
+        });
+        transitionEmitter.emitFromRow(row, createdAt);
+        if (deps.backgroundTaskRunner) {
+            void deps.backgroundTaskRunner.runFromPost(id).catch((err) => {
+                logger.error({ err, taskId: id }, "background-task runner threw on dispatch — task left in pending state");
+            });
+        }
+        else {
+            // No runner wired (tests / lite installs) — synthetic terminal so
+            // the row doesn't hang in pending.
+            const finishedAt = Date.now();
+            const terminal = markTerminal(deps.db, {
+                id,
+                state: "failed",
+                outcomeDetail: "runner_unavailable",
+                finishedAt,
+            });
+            transitionEmitter.emitFromRow(terminal, finishedAt);
+        }
+        const postDispatchRow = getBackgroundTask(deps.db, id) ?? row;
+        return c.json({ taskId: id, status: postDispatchRow.state, row: toWire(postDispatchRow) }, 202);
+    });
+    // ── GET /api/background-task ──────────────────────────────────────────
+    app.get("/background-task", (c) => {
+        const stateQuery = c.req.query("state");
+        const states = stateQuery
+            ? stateQuery.split(",").filter((s) => s.length > 0)
+            : undefined;
+        // §10.5 — the filed-results digest / "did that monitor run?" pull:
+        // `notify=false` + `sinceHours=N` narrows to recently-filed results.
+        const notifyQuery = c.req.query("notify");
+        const notify = notifyQuery === "true" || notifyQuery === "1"
+            ? true
+            : notifyQuery === "false" || notifyQuery === "0"
+                ? false
+                : undefined;
+        const sinceHours = Number(c.req.query("sinceHours"));
+        const finishedSinceMs = Number.isFinite(sinceHours) && sinceHours > 0
+            ? Date.now() - sinceHours * 3_600_000
+            : undefined;
+        const limit = Math.min(200, Math.max(0, Number(c.req.query("limit")) || 50));
+        const offset = Math.max(0, Number(c.req.query("offset")) || 0);
+        const filter = { states, notify, finishedSinceMs };
+        const rows = listBackgroundTasks(deps.db, { ...filter, limit, offset });
+        const total = countBackgroundTasks(deps.db, filter);
+        return c.json({ tasks: rows.map(toWire), total, limit, offset });
+    });
+    // ── GET /api/background-task/:id (the artifact) ───────────────────────
+    app.get("/background-task/:id", (c) => {
+        const id = c.req.param("id");
+        const row = getBackgroundTask(deps.db, id);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({
+            ...toWire(row),
+            clarifications: listClarificationsForTask(deps.db, id),
+        });
+    });
+    // ── POST /api/background-task/:id/clarify ─────────────────────────────
+    app.post("/background-task/:id/clarify", async (c) => {
+        const id = c.req.param("id");
+        const body = await readJsonBody(c);
+        if (!body.ok)
+            return body.response;
+        const parsed = clarifyBodySchema.safeParse(body.body);
+        if (!parsed.success) {
+            return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
+        }
+        const row = getBackgroundTask(deps.db, id);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        if (row.state !== "awaiting_user") {
+            return c.json({ error: "not_awaiting_user", currentState: row.state }, 409);
+        }
+        // Resolve the explicit clarificationId, or the single open one.
+        const clarificationId = parsed.data.clarificationId
+            ?? getOpenClarificationForTask(deps.db, id)?.id
+            ?? null;
+        if (!clarificationId) {
+            return c.json({ error: "no_open_clarification" }, 409);
+        }
+        const resolved = resolveClarification(deps.db, {
+            id: clarificationId,
+            answer: parsed.data.answer,
+            answeredAt: Date.now(),
+        });
+        if (!resolved.ok) {
+            const status = resolved.reason === "not_found"
+                ? 404
+                : resolved.reason === "expired"
+                    ? 410
+                    : 409;
+            return c.json({ error: resolved.reason ?? "clarify_failed" }, status);
+        }
+        if (deps.backgroundTaskRunner) {
+            void deps.backgroundTaskRunner
+                .resumeAfterClarification({
+                taskId: id,
+                clarificationId,
+                answer: parsed.data.answer,
+            })
+                .catch((err) => {
+                logger.error({ err, taskId: id, clarificationId }, "background-task resumeAfterClarification threw — task left parked");
+            });
+        }
+        else {
+            logger.warn({ taskId: id, clarificationId }, "background-task clarify recorded but no runner wired — task cannot resume.");
+        }
+        return c.json({ ok: true, clarification: resolved.row });
+    });
+    // ── POST /api/background-task/:id/cancel ──────────────────────────────
+    app.post("/background-task/:id/cancel", async (c) => {
+        const id = c.req.param("id");
+        const body = await readJsonBody(c);
+        const rawBody = body.ok ? body.body : undefined;
+        const parsed = cancelBodySchema.safeParse(rawBody);
+        const reason = parsed.success ? parsed.data?.reason ?? "user_cancel" : "user_cancel";
+        const row = getBackgroundTask(deps.db, id);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        if (row.state === "completed"
+            || row.state === "failed"
+            || row.state === "timeout"
+            || row.state === "cancelled") {
+            return c.json({ error: "already_terminal", currentState: row.state }, 409);
+        }
+        if (deps.backgroundTaskRunner) {
+            await deps.backgroundTaskRunner.cancel(id, reason);
+        }
+        else {
+            const finishedAt = Date.now();
+            const updated = markTerminal(deps.db, {
+                id,
+                state: "cancelled",
+                outcomeDetail: reason,
+                finishedAt,
+            });
+            transitionEmitter.emitFromRow(updated, finishedAt);
+            return c.json({ ok: true, row: updated ? toWire(updated) : null });
+        }
+        const after = getBackgroundTask(deps.db, id);
+        return c.json({ ok: true, row: after ? toWire(after) : null });
+    });
+    return app;
+}

package/dist/api/routes/browser-history.js

@@ -63,10 +63,18 @@ export function createBrowserHistoryRoutes(deps) {
             return c.json({ error: "not_found" }, 404);
         }
         const days = listClusterDailyDeltas(deps.db, detail.rootTaskId, agentDayBoundary(deps), { dayLimit: 31 });
+        // RESEARCH_CLUSTER_COST_FIX_PLAN rev5 — stamp each bucket with
+        // whether its agent day has ended. The current agent day's bucket is
+        // still accumulating (a day-boundary or wake-catch-up run fires
+        // mid-day, so the bucket only covers visits up to "now"); consumers
+        // that persist day entries (the append-only research journal) must
+        // skip incomplete buckets or they freeze an undercounted day forever.
+        // ISO agent-day strings compare lexically = chronologically.
+        const today = todayKey(deps);
         return c.json(browserHistoryClusterDeltaResponseSchema.parse({
             slug,
             generatedAt: new Date().toISOString(),
-            days,
+            days: days.map((day) => ({ ...day, complete: day.date < today })),
         }));
     });
     app.get("/browser-history/research-clusters/:slug", (c) => {

package/dist/api/routes/context/permissions.js

@@ -52,8 +52,9 @@ export const CONTEXT_WRITE_PERMISSIONS = {
     "policies/management-captures/*": ["PUT", "PATCH"],
     "policies/routines/_index": ["PUT", "PATCH"],
     "policies/routines/*": ["PUT", "PATCH"],
-    // Custom routines support DELETE so the agent can retire a routine
-    // when the user asks via DM.
+    // Legacy custom-routine files (inert since the Agents-hub redesign —
+    // recurring work is an Agent now). Writes stay validated and DELETE
+    // remains so the agent can clean a leftover file up when the user asks.
     "policies/routines/custom/*": ["PUT", "PATCH", "DELETE"],
     // User Agent definitions (AGENT_DEFINITIONS_DESIGN.md §9.5 / §3.3). The
     // dashboard's "+ New Agent" scaffold and the YAML editor write user Agents

package/dist/api/routes/context/snapshots.js

@@ -186,9 +186,6 @@ export function registerSnapshotsRoutes(app, ctx) {
             if (shouldRefreshPromptContext(path, "PUT")) {
                 notifyPromptContextChanged(deps, path, `context_restore_snapshot:${path}`, { path, method: "RESTORE" });
             }
-            if (path.startsWith("policies/routines/custom/")) {
-                deps.onCustomRoutinesChanged?.();
-            }
             const writtenStat = statSync(fullPath);
             logger.info({
                 path,

package/dist/api/routes/context/write.js

@@ -320,9 +320,6 @@ export function registerWriteRoutes(app, ctx) {
             if (shouldRefreshPromptContext(path, "PUT")) {
                 notifyPromptContextChanged(deps, path, `context_put:${path}`, { path, method: "PUT" });
             }
-            if (path.startsWith("policies/routines/custom/")) {
-                deps.onCustomRoutinesChanged?.();
-            }
             const writtenStat = statSync(fullPath);
             logger.info({
                 path,
@@ -530,9 +527,6 @@ export function registerWriteRoutes(app, ctx) {
                         previousContent: fileContent,
                     });
                 }
-                if (path.startsWith("policies/routines/custom/")) {
-                    deps.onCustomRoutinesChanged?.();
-                }
                 logger.info({ path, method: "PATCH", mode }, "Content appended to file");
                 return c.json({ status: "appended" });
             }
@@ -608,9 +602,6 @@ export function registerWriteRoutes(app, ctx) {
                         previousContent: fileContent,
                     });
                 }
-                if (path.startsWith("policies/routines/custom/")) {
-                    deps.onCustomRoutinesChanged?.();
-                }
                 logger.info({ path, method: "PATCH", mode }, "Frontmatter merged");
                 return c.json({ status: "merged" });
             }
@@ -724,9 +715,6 @@ export function registerWriteRoutes(app, ctx) {
                     previousContent: fileContent,
                 });
             }
-            if (path.startsWith("policies/routines/custom/")) {
-                deps.onCustomRoutinesChanged?.();
-            }
             deps.onIndexableContextChange?.(`${path}${target.ext}`);
             const resultStatus = mode === "append" ? "appended" : mode === "replace" ? "replaced" : "cleared";
             logger.info({ path, method: "PATCH", section, mode, removedCount, trimmedCount }, "Context section " + resultStatus);
@@ -735,8 +723,9 @@ export function registerWriteRoutes(app, ctx) {
     });
     // DELETE /context/* — File delete (currently limited to `routines/custom/*`
     // via the write-permission whitelist). B-007 §5.8 Q3: the agent retires a
-    // custom routine after the user confirms. The scheduler listens via
-    // `onCustomRoutinesChanged` and unregisters the cron job on reload.
+    // custom routine after the user confirms. (Legacy path — custom routines
+    // no longer fire; they were converted to user Agents at the Agents-hub
+    // redesign. The delete surface stays so leftover files can be removed.)
     app.delete("/context/*", (c) => {
         const path = normalizeContextPath(c.req.path.replace("/api/context/", ""));
         const contextDir = getCurrentContextDir();
@@ -770,9 +759,6 @@ export function registerWriteRoutes(app, ctx) {
             const existing = readFileSync(fullPath, "utf-8");
             const snapshotId = saveSnapshot(path, existing, "api_delete", true);
             unlinkSync(fullPath);
-            if (path.startsWith("policies/routines/custom/")) {
-                deps.onCustomRoutinesChanged?.();
-            }
             deps.onIndexableContextChange?.(path);
             logger.info({ path, method: "DELETE", snapshotId: snapshotId ?? undefined }, "Context file deleted");
             return c.json({ status: "deleted", snapshotId: snapshotId ?? 0 });

package/dist/api/routes/dashboard/config.js

@@ -4,6 +4,7 @@ import { EDITABLE_RUNTIME_KEY_TUPLE, getBackendIds, normalizeAgentDisplayName, }
 import { applyConfigUpdates } from "../../env-writer.js";
 import { runDefaultSchedulesReconciler } from "../../../core/context/default-schedules-runner.js";
 import { syncDmSessionTimesToQuietHours } from "../../../core/quiet-hours-sync.js";
+import { retimeDeferredDmRows, retimeDeferredRunRows, } from "../../../db/deferred-dm.js";
 import { getContextDir } from "../../../config.js";
 import { CONTEXT_RELATIVE_PATHS } from "../../../core/context-paths.js";
 import { createLogger, toSafeErrorMessage } from "../../../logging.js";
@@ -31,13 +32,13 @@ const PUBLIC_CONFIG_RUNTIME_KEYS = [
     "sessionTimeoutDashboardMinutes",
     "timezone",
     "dayBoundaryHour",
-    // Monthly Review kill switch — default off; see runtime-settings.ts.
-    "monthlyReviewEnabled",
-    "hourlyCheckEnabled",
-    "hourlyCheckIntervalMinutes",
-    "hourlyCheckActiveStartHour",
-    "hourlyCheckActiveEndHour",
-    "hourlyCheckMinObservations",
+    // The legacy activity-scan / monthly-review gate + cadence keys
+    // (activityScanEnabled, activityScanIntervalMinutes, activityScanActive*,
+    // activityScanMinObservations, monthlyReviewEnabled) left this surface at
+    // the Agents-hub redesign: `agents.enabled` + the activity-scan row's
+    // runtime_window own them now (PATCH /api/agents/activity-scan). The keys
+    // remain valid in runtimeSettingsSchema as resolver fallbacks
+    // (AGENTS_HUB_REDESIGN_PLAN.md §2).
     "authProbeDisabled",
     "authPreflightFreshnessMs",
     "maxNotificationsPerHour",
@@ -303,14 +304,18 @@ export function registerConfigRoutes(app, deps) {
         if (Object.keys(result.errors).length > 0 && result.updated.length === 0) {
             return c.json({ error: "validation_failed", details: result.errors }, 400);
         }
-        // Hot-reload cron schedules when schedule-related config changes
+        // Hot-reload cron schedules when schedule-related config changes.
+        // The activityScan* entries are legacy-API back-compat only: the dashboard
+        // no longer surfaces them (agent-row runtime_window owns the cadence), but
+        // a direct PATCH of the deprecated keys must still rebuild the cron so the
+        // resolver fallback change takes effect.
         const SCHEDULE_KEYS = [
             "dayBoundaryHour",
             "timezone",
-            "hourlyCheckEnabled",
-            "hourlyCheckIntervalMinutes",
-            "hourlyCheckActiveStartHour",
-            "hourlyCheckActiveEndHour",
+            "activityScanEnabled",
+            "activityScanIntervalMinutes",
+            "activityScanActiveStartHour",
+            "activityScanActiveEndHour",
         ];
         if (result.updated.some((k) => SCHEDULE_KEYS.includes(k))) {
             deps.onScheduleConfigChanged?.();
@@ -342,6 +347,37 @@ export function registerConfigRoutes(app, deps) {
                 logger.warn({ err }, "syncDmSessionTimesToQuietHours threw after dashboard config PATCH");
             }
         }
+        // QUIET_HOURS_HARDENING_PLAN.md Phase 1 follow-up — pending
+        // quiet-hours-deferred DM rows (`task_context.deferred_from`) were
+        // stamped with the *old* window's end; retime them so a widened
+        // window doesn't fire them inside the new quiet hours and a
+        // narrowed one doesn't hold them past the new edge. Phase 2's
+        // deferred RUN rows (`task_context.quiet_hours_deferred` — agent.task
+        // opt-in + browser_task) get the same treatment; for them only the
+        // narrowed/disabled direction matters (a widened window re-defers at
+        // claim time anyway). `timezone` is in the trigger set because the
+        // window's *absolute* position is tz-relative — an unchanged
+        // "22:00→08:00" still moves on the UTC axis when the tz changes, and
+        // deferred DM rows are delivered by `handleDirectDm`, which skips the
+        // quiet-hours check by design.
+        if ((result.updated.includes("quietHoursEnd")
+            || result.updated.includes("quietHoursStart")
+            || result.updated.includes("timezone"))
+            && /^\d{2}:\d{2}$/.test(config.quietHoursStart)
+            && /^\d{2}:\d{2}$/.test(config.quietHoursEnd)) {
+            const window = {
+                start: config.quietHoursStart,
+                end: config.quietHoursEnd,
+                timezone: config.timezone || undefined,
+            };
+            try {
+                retimeDeferredDmRows(db, window);
+                retimeDeferredRunRows(db, window);
+            }
+            catch (err) {
+                logger.warn({ err }, "Retiming quiet-hours-deferred rows threw after dashboard config PATCH");
+            }
+        }
         // Hot-refresh DM session skill dirs when enabledMailProviders changes
         // through the generic config PATCH. The per-endpoint `PATCH /mail/providers`
         // handler already drives this through MailAccountRegistry.onScopeChanged,

package/dist/api/routes/dashboard/cost-approvals.js

@@ -143,6 +143,10 @@ export function aggregateByBilledModel(rows) {
         .map(([model, v]) => ({ model, ...v }))
         .sort((a, b) => b.total_cost - a.total_cost);
 }
+// Today's spend-driver list is intentionally capped: beyond the top 15 the
+// rows are long-tail noise (the by-process panel covers aggregate share),
+// and an uncapped list would grow unbounded on chatty days.
+const TODAY_TOP_ACTIONS_LIMIT = 15;
 // `bucketExpr` takes a single shift-modifier parameter (e.g. "+300 minutes")
 // so each query binds it explicitly — see COST_QUERIES for the rationale.
 const COST_PERIOD_SPECS = {
@@ -211,6 +215,61 @@ export function registerCostApprovalsRoutes(app, deps) {
          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
            AND cost_usd IS NOT NULL`)
             .get(bounds.start, bounds.end);
+        // ── Today's spend drivers ──
+        // All scoped to the same agent-day bounds as the Today card so the
+        // numbers reconcile: Σ byEventType.total_cost === today.costUsd.
+        // The windowed byEventType above answers "what cost money this month";
+        // these answer "what is costing money *right now*" — the question the
+        // owner asks when the Today card looks unexpectedly high.
+        const todayTopActions = db
+            .prepare(`SELECT id, event_id, action_type, trigger, model_used, model_usage_json, cost_usd,
+                tokens_input, tokens_output,
+                cache_creation_tokens, cache_read_tokens,
+                duration_ms, num_turns,
+                result, detail, started_at, completed_at, error
+           FROM agent_actions
+          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+            AND cost_usd IS NOT NULL AND cost_usd > 0
+          ORDER BY cost_usd DESC, datetime(started_at) DESC
+          LIMIT ${TODAY_TOP_ACTIONS_LIMIT}`)
+            .all(bounds.start, bounds.end);
+        const todayByEventType = db
+            .prepare(`SELECT action_type as event_type,
+                SUM(cost_usd) as total_cost,
+                COUNT(*) as session_count
+           FROM agent_actions
+          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+            AND cost_usd IS NOT NULL
+          GROUP BY action_type
+          ORDER BY total_cost DESC`)
+            .all(bounds.start, bounds.end);
+        const todayByTrigger = db
+            .prepare(`SELECT COALESCE(trigger, 'unknown') as trigger,
+                SUM(cost_usd) as total_cost,
+                COUNT(*) as session_count
+           FROM agent_actions
+          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+            AND cost_usd IS NOT NULL
+          GROUP BY 1
+          ORDER BY total_cost DESC`)
+            .all(bounds.start, bounds.end);
+        const todayTokens = db
+            .prepare(`SELECT COALESCE(SUM(tokens_input), 0) as input,
+                COALESCE(SUM(tokens_output), 0) as output,
+                COALESCE(SUM(cache_read_tokens), 0) as cacheRead,
+                COALESCE(SUM(cache_creation_tokens), 0) as cacheCreation
+           FROM agent_actions
+          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+            AND cost_usd IS NOT NULL`)
+            .get(bounds.start, bounds.end);
+        const todayFailed = db
+            .prepare(`SELECT COALESCE(SUM(cost_usd), 0) as cost,
+                COUNT(*) as sessions
+           FROM agent_actions
+          WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+            AND cost_usd IS NOT NULL
+            AND result = 'failed'`)
+            .get(bounds.start, bounds.end);
         return c.json({
             period,
             today: { costUsd: today.cost, sessions: today.sessions },
@@ -219,6 +278,13 @@ export function registerCostApprovalsRoutes(app, deps) {
             byEventType,
             byBackend,
             byBackendPeriod,
+            todayBreakdown: {
+                topActions: todayTopActions,
+                byEventType: todayByEventType,
+                byTrigger: todayByTrigger,
+                tokens: todayTokens,
+                failed: { costUsd: todayFailed.cost, sessions: todayFailed.sessions },
+            },
         });
     });
     // ── Approvals API ──