@aitne/daemon 0.1.8 → 0.1.9

package/dist/bootstrap/event-pipeline.js

@@ -78,8 +78,10 @@
  *    hot-register / morning-routine gate / roadmap-refresh test matrix.
  */
 import { join } from "node:path";
+import { createReadStream } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { getContextDir, isRoadmapStale } from "../config.js";
+import { resolveUserSkillsRoot } from "../core/user-skills-root.js";
 import { isUserPaused } from "../db/runtime-state.js";
 import { readIntegrations } from "../db/integrations-store.js";
 import { selectGithubRepoSlugs } from "../db/repositories-store.js";
@@ -108,9 +110,12 @@ import { AuthHealthMonitor, AUTH_PROBE_NOTIFICATION_CATEGORY, } from "../core/ba
 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.js";
+import { validateBuiltinSkillSourceTree } from "../core/skills-compiler-variants.js";
 // Audit / safety / messaging
 import { AuditLogger } from "../safety/audit.js";
+import { AgentExecutionRecorder } from "../core/agent-execution-recorder.js";
+import { AgentExecutionTracker } from "../core/agents/agent-execution-tracker.js";
+import { loadAgentSuccessCriteria } from "../core/agents/definition-criteria.js";
 import { NotificationManager } from "../adapters/notification-manager.js";
 import { DocsQAAdapter } from "../adapters/docs-qa-adapter.js";
 import { CompositeDashboardStream } from "../adapters/composite-dashboard-stream.js";
@@ -172,7 +177,7 @@ export async function createEventPipeline(deps) {
         },
     });
     // ── Notification + auth telemetry + shared notifier factory ────────────
-    // P2-16: sweep stale `batched` rows from a prior crash before the new
+    // Sweep stale `batched` rows from a prior crash before the new
     // dispatcher starts producing notifications. A queued (status='batched')
     // row whose flush timer didn't fire (process killed) would otherwise
     // linger forever and confuse the dashboard's notification feed.
@@ -217,7 +222,7 @@ 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, join(config.dataDir, "skills"));
+        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
@@ -243,6 +248,29 @@ export async function createEventPipeline(deps) {
         // the audit layer.
         onRowInserted: (row) => eventBroadcaster.broadcastEvent(row),
     });
+    // ── Agent execution recorder + tracker (AGENT_DEFINITIONS_DESIGN.md §8) ─
+    // The recorder owns the `agent_executions` row lifecycle + the agent-day
+    // `{date}` label; the tracker owns the per-firing begin/complete keyed by
+    // event correlationId, success-criteria evaluation, and the SSE feed. Both
+    // are wired into the dispatcher (+ the audit `agent_id` resolver) below.
+    const agentExecutionRecorder = new AgentExecutionRecorder({
+        db,
+        timezone: config.timezone || undefined,
+        dayBoundaryHour: config.dayBoundaryHour,
+    });
+    const agentExecutionTracker = new AgentExecutionTracker({
+        db,
+        recorder: agentExecutionRecorder,
+        contextDir: getContextDir(config, db),
+        emitSse: (event, payload) => eventBroadcaster.broadcastEvent({
+            kind: event,
+            ...payload,
+        }),
+        loadCriteria: loadAgentSuccessCriteria,
+    });
+    // Stamp `agent_actions.agent_id` for every row produced by the in-flight
+    // firing — the tracker holds the resolved slug for the run's correlationId.
+    auditLogger.setAgentIdResolver((event) => agentExecutionTracker.currentAgentId(event.correlationId));
     // ── DM workdir re-materialization (shared by mail scope + mode flips) ─
     const rematerializeActiveDmWorkdirs = (reason) => {
         const sessions = sessionManager.listActiveDmSessions();
@@ -326,6 +354,7 @@ export async function createEventPipeline(deps) {
     dispatcher.setDashboardStream(new CompositeDashboardStream([dashboardAdapter, docsQAAdapter]));
     dispatcher.setAttachmentStore(attachmentStore);
     dispatcher.setEventBroadcaster(eventBroadcaster);
+    dispatcher.setAgentExecutionTracker(agentExecutionTracker);
     // Voice transcription. See docs/design/appendices/voice-transcription.md.
     // Env vars stay live for advanced operators; `enabled` falls back to the
     // `voiceTranscriptionEnabled` runtime setting via a getter so the
@@ -391,9 +420,9 @@ export async function createEventPipeline(deps) {
         });
     }, 24 * 60 * 60 * 1000);
     keepaliveTimer.unref?.();
-    // Phase 5/6: Interactive auth recovery manager. Uses the same notifier
-    // sink as the AuthHealthMonitor so recovery DMs flow through the same
-    // notification pipeline with the same anti-spam guarantees.
+    // Interactive auth recovery manager. Uses the same notifier sink as the
+    // AuthHealthMonitor so recovery DMs flow through the same notification
+    // pipeline with the same anti-spam guarantees.
     const authRecovery = new AuthRecovery(db, authTelemetry, authHealthMonitor, makeAuthNotifier("auth-recovery"), {
         claudeRecoveryTimeoutMin: 10,
         codexRecoveryTimeoutMin: 15,
@@ -441,6 +470,474 @@ export async function createEventPipeline(deps) {
     // Messaging bang-commands (`!stop`/`!start`/`!cost`/`!report`) — owner
     // DM chokepoint that runs ahead of every other interceptor.
     dispatcher.setBangCommandRegistry(createDefaultBangCommandRegistry());
+    // Browser-task screenshots (ask_user / finish / lite-final-confirm / B-4
+    // purchase confirmations) are delivered to the dashboard as real chat
+    // attachments — fetched by id through the authenticated /api proxy —
+    // instead of loopback trace URLs a raw <img> cannot authenticate. This
+    // hook ingests a trace-store PNG/JPEG into the AttachmentStore to mint a
+    // fetchable id; messaging adapters take the trace file directly via their
+    // native upload API and never reach it. Best-effort: an ingest failure
+    // (disallowed mime, missing file) returns null and the caller omits the
+    // image. Shared by the MCP notifier + both confirm senders.
+    const ingestBrowserTaskScreenshot = async (input) => {
+        try {
+            const result = await attachmentStore.ingestStream({
+                stream: createReadStream(input.absPath),
+                declaredMimeType: input.mimeType,
+                originalFilename: input.originalFilename,
+                direction: "outbound",
+                provenance: "agent",
+                maxSizeBytes: 5 * 1024 * 1024,
+            });
+            return {
+                id: result.id,
+                path: result.path,
+                originalFilename: result.originalFilename,
+                mimeType: result.mimeType,
+                sizeBytes: result.sizeBytes,
+            };
+        }
+        catch (err) {
+            logger.warn({ err }, "browser-task screenshot ingest failed (omitting)");
+            return null;
+        }
+    };
+    // ── Phase B-4 purchase handler ────────────────────────────────────────
+    // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 / §13 step 50.
+    //
+    // The handler holds the unforgeable capability that gates
+    // `sendSystemMessage` — see `purchase-handler.ts`. The system-message
+    // sender uses the existing MessageHub to dispatch DMs; we construct
+    // it here once the hub is available, then thread the handler into
+    // the dispatcher (for the inbound classifier hook on `!~xxxxxxxx` /
+    // `!verify` / `!cancel-purchase`). The API server picks up the same
+    // instance via `dispatcher.getPurchaseHandler()` at startup-api.ts.
+    //
+    // Wired unconditionally — every install gets a handler even when the
+    // master toggle is OFF, because the inbound classifier still needs
+    // to recognise + reject token-shaped replies that the user might
+    // send by mistake (and to write the audit row). The handler refuses
+    // issuance internally via `getB4Enabled` so cost is bounded.
+    {
+        const { createPurchaseHandler } = await import("../services/browser-history/automation/purchase-handler.js");
+        const { createPurchaseSystemMessageSender } = await import("../messaging/purchase-system-message-sender.js");
+        const sender = createPurchaseSystemMessageSender({
+            messageHub,
+            paDataDir: config.dataDir,
+            ingestOutboundImage: ingestBrowserTaskScreenshot,
+        });
+        const purchaseHandler = createPurchaseHandler({
+            db,
+            sender,
+        });
+        dispatcher.setPurchaseHandler(purchaseHandler);
+        // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 "Daemon crash during
+        // the 5-min window" — on supervisor restart, sweep both flavours of
+        // orphaned token. (a) Pre-consume rows whose 5-min TTL has elapsed
+        // are flipped to `expired` with reason=timeout; (b) post-consume
+        // rows where the click never landed (the previous daemon process
+        // died after the user typed the token but before finalize) are
+        // flipped to `cancelled` with reason=supervisor_orphan_sweep.
+        // Without this the rows sit stranded until the daily retention
+        // sweep. Best-effort: a failure logs but does not abort startup —
+        // the retention sweep is the long-running safety net.
+        try {
+            const { expireStalePurchaseTokens, sweepOrphanedConsumedPurchaseTokens, } = await import("../db/browser-automation-purchase-tokens-store.js");
+            const now = Date.now();
+            const expired = expireStalePurchaseTokens(db, now);
+            // 10-min grace mirrors the retention sweep — anything consumed
+            // more than 10 min ago without a finalize must have been
+            // orphaned by a previous daemon process (the workflow's own
+            // perWorkflowTimeoutMs is 6 min).
+            const orphaned = sweepOrphanedConsumedPurchaseTokens(db, now - 10 * 60 * 1000);
+            if (expired.length > 0 || orphaned.length > 0) {
+                logger.info({ expired: expired.length, orphaned: orphaned.length }, "B-4 boot-time orphan recovery: cleaned up stranded purchase tokens");
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, "B-4 boot-time orphan recovery failed (retention sweep will retry)");
+        }
+        // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 row 7 — SIGKILL
+        // every orphan A-purchase Chromium process whose `--user-data-dir`
+        // points at `chromium-automation-purchase/<siteKey>/`. The DB sweep
+        // above flips the token rows to cancelled but the Chromium process
+        // could survive the parent daemon's death (Chromium spawns helper
+        // children; `detached: false` is a best-effort, not a hard
+        // guarantee, and a `nohup` / suspended-launcher path leaves the
+        // child alive with the user's authenticated cart context and an
+        // open CDP debug port on localhost). The kill is OS-agnostic via
+        // the HostProfile abstraction, runs unconditionally regardless of
+        // whether any rows were swept (the DB and the process state can
+        // diverge — e.g. a daemon crash AFTER finalize but before SIGTERM
+        // would leave the process alive without a corresponding pending
+        // row), and is best-effort: a missing `chromium-automation-purchase/`
+        // directory, missing Chromium binary, or a `ps` shell-out failure
+        // is silent.
+        try {
+            const { createHostProfile } = await import("../services/browser-history/lifecycle/platform.js");
+            const { killOrphanedPurchaseChromium } = await import("../services/browser-history/managed-chromium/setup-bootstrap.js");
+            const host = createHostProfile();
+            const { killedPids } = await killOrphanedPurchaseChromium(host, config.dataDir);
+            if (killedPids.length > 0) {
+                logger.warn({ killedPids }, "B-4 boot-time recovery: killed orphan A-purchase Chromium processes");
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, "B-4 boot-time orphan-Chromium kill failed (process may persist until next OS-level cleanup)");
+        }
+    }
+    // ── Browser-task lite-final-confirm handler ───────────────────────────
+    // BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 (Q#6 MVP blocker).
+    //
+    // Parallel to the B-4 purchase handler block above. Same anti-spoofing
+    // capability pattern — the sender mints its credential from
+    // `final-confirm-handler`'s module-private getter, so an agent tool
+    // that imports the sender still cannot dispatch DMs. The dispatcher
+    // holds the canonical instance via `setFinalConfirmHandler`; the
+    // inbound `!~xxxxxxxx` classifier in `dispatcher-message-handler.ts`
+    // queries both stores by raw token and routes to whichever returns a
+    // row (jti-prefix dispatch in practice — both jtis are uuid v4, so
+    // collision is bounded by uuid uniqueness).
+    //
+    // Wired unconditionally so the inbound classifier can still write
+    // the strict-cancel-on-non-token-reply audit row even when no tokens
+    // are currently outstanding. Phase 2 plumbs the same handler instance
+    // into the browser-task driver (`DriverDeps.finalConfirmHandler`) so
+    // the sub-agent's final-confirm gate issues + awaits via the canonical
+    // surface — sharing a single instance is what makes the §14.11 Q#6
+    // jti-prefix dispatch deterministic.
+    const { createFinalConfirmHandler } = await import("../services/browser-history/automation/final-confirm-handler.js");
+    const { createFinalConfirmSystemMessageSender } = await import("../messaging/final-confirm-system-message-sender.js");
+    const finalConfirmSender = createFinalConfirmSystemMessageSender({
+        messageHub,
+        paDataDir: config.dataDir,
+        ingestOutboundImage: ingestBrowserTaskScreenshot,
+    });
+    const finalConfirmHandler = createFinalConfirmHandler({
+        db,
+        sender: finalConfirmSender,
+    });
+    dispatcher.setFinalConfirmHandler(finalConfirmHandler);
+    // ── Browser-task slot manager + runner + driver ───────────────────────
+    // BROWSER_TASK_REDESIGN_PLAN.md §5 / §5.1 — wire the in-memory slot
+    // state + the Phase 2 driver so `POST /api/browser-task` runs the
+    // real Playwright + Claude SDK loop.
+    //
+    // Two notifiers, one runner:
+    //  - `notifier` (structural): runner-side. Fans "queued" /
+    //    non-completed-terminal intents into MessageHub DMs. Stays terse
+    //    + templated.
+    //  - `driver.notifier` (MCP-side): the `mcp__aitne-browser__ask_user`
+    //    and `mcp__aitne-browser__finish` tool handlers DM through this
+    //    notifier so agent-authored prose lands on the originating channel.
+    //
+    // Both round-trip via `parseChannelRef` for the §14.8 attestation —
+    // unparseable refs log + skip rather than fan out to all primary
+    // channels (the originating value was already attestation-validated
+    // at task-creation time).
+    const { createBrowserTaskRunner, createSlotStateRef } = await import("../services/browser-task/browser-task-runner.js");
+    // BROWSER_TASK_REDESIGN_PLAN.md §9a.5 Shape B — the same emitter
+    // instance threads through runner + driver + tools so a single
+    // `browser_task` SSE event fans out on every state transition.
+    const { createBrowserTaskTransitionEmitter: createBrowserTaskTransitionEmitterAtBoot } = await import("../services/browser-task/browser-task-transition-events.js");
+    const browserTaskTransitionEmitter = createBrowserTaskTransitionEmitterAtBoot(eventBroadcaster);
+    const { parseChannelRef: parseBrowserTaskChannelRef } = await import("../db/browser-automation-purchase-primary-channels-store.js");
+    const { createHostProfile: createBrowserTaskHostProfile } = await import("../services/browser-history/lifecycle/platform.js");
+    const { createBrowserTaskMcpNotifier } = await import("../messaging/browser-task-mcp-notifier.js");
+    const browserTaskSlotStateRef = createSlotStateRef(config.browserTaskMaxConcurrent);
+    const browserTaskMcpNotifier = createBrowserTaskMcpNotifier({
+        messageHub,
+        paDataDir: config.dataDir,
+        ingestOutboundImage: ingestBrowserTaskScreenshot,
+    });
+    const browserTaskHostProfile = createBrowserTaskHostProfile();
+    // Hoisted out of the `createBrowserTaskRunner({ notifier: ... })` arg
+    // so the same instance can also wire into the dispatcher's
+    // `scheduled.browser_task` fire-time-failure path (see
+    // BROWSER_TASK_REDESIGN_PLAN.md §7). One DM-emission contract covers
+    // both the runner's own non-completed terminals and the pre-runner
+    // dispatch failures (`site_unregistered`, `allowlist_rejected`,
+    // `runner_unavailable`) that the runner never sees.
+    const browserTaskTerminalNotifier = {
+        async notifyQueued(input) {
+            const ref = input.originatingChannel;
+            if (!ref)
+                return;
+            const parsed = parseBrowserTaskChannelRef(ref);
+            if (!parsed) {
+                logger.warn({ taskId: input.taskId, ref }, "browser-task notifyQueued: unparseable channel ref — skipping DM");
+                return;
+            }
+            try {
+                await messageHub.sendToPlatform(parsed.platform, parsed.channelId, `🕒 Browser task ${input.taskId} is queued behind ${input.blockedCount} task(s). Aitne will start it once the slot opens.`);
+            }
+            catch (err) {
+                logger.warn({ err, taskId: input.taskId, ref }, "browser-task queue DM dispatch failed (continuing)");
+            }
+        },
+        async notifyTerminal(input) {
+            // §5 "Reporting": on the success path the sub-agent's own
+            // `finish({ report, screenshotKeys })` tool fans the
+            // user-facing DM via the driver-side MCP notifier above. The
+            // structural notifier here is the FALLBACK signal — it covers
+            // every non-completed terminal (failures, timeouts,
+            // cancellations, abandons) where the agent never reached
+            // `finish` and the user would otherwise be left waiting.
+            if (input.state === "completed")
+                return;
+            const ref = input.originatingChannel;
+            if (!ref)
+                return;
+            const parsed = parseBrowserTaskChannelRef(ref);
+            if (!parsed) {
+                logger.warn({ taskId: input.taskId, ref }, "browser-task notifyTerminal: unparseable channel ref — skipping DM");
+                return;
+            }
+            const detail = input.outcomeDetail ?? input.state;
+            try {
+                await messageHub.sendToPlatform(parsed.platform, parsed.channelId, `🟦 Browser task ${input.taskId} ended: ${input.state} (${detail}).`);
+            }
+            catch (err) {
+                logger.warn({ err, taskId: input.taskId, ref }, "browser-task terminal DM dispatch failed (continuing)");
+            }
+        },
+    };
+    const { compileUserHostnameDenylist } = await import("../services/browser-history/automation/egress-denylist.js");
+    const browserTaskRunner = createBrowserTaskRunner({
+        db,
+        slotStateRef: browserTaskSlotStateRef,
+        notifier: browserTaskTerminalNotifier,
+        transitionEmitter: browserTaskTransitionEmitter,
+        driver: {
+            db,
+            paDataDir: config.dataDir,
+            workspaceDir: config.workspaceDir,
+            hostProfile: browserTaskHostProfile,
+            finalConfirmHandler,
+            notifier: browserTaskMcpNotifier,
+            transitionEmitter: browserTaskTransitionEmitter,
+            // User-curated hostname denylist for the browser-task CDP route
+            // handler + §14.7 screenshot retention check. Passed as a thunk
+            // (not a precompiled array) so a Dashboard PATCH /api/config —
+            // which mutates `config.browserTaskHostnameDenylist` in place via
+            // `applyConfigUpdates` — takes effect on the **next** task without
+            // a daemon restart. Recompilation per task is cheap (max 500
+            // entries × tiny regex).
+            getHostnameDenylist: () => compileUserHostnameDenylist(config.browserTaskHostnameDenylist ?? []),
+        },
+    });
+    // BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — Phase 3 wiring. The
+    // dispatcher's `scheduled.browser_task` branch reaches the runner
+    // through this setter. Wired right after the factory call so a
+    // fire-time event that races startup still finds the runner instead
+    // of falling through to `runner_unavailable`.
+    dispatcher.setBrowserTaskRunner(browserTaskRunner);
+    // BROWSER_TASK_REDESIGN_PLAN.md §7 — wire the same DM emitter the
+    // runner uses into the dispatcher so fire-time failures
+    // (`site_unregistered`, `allowlist_rejected`, `runner_unavailable`)
+    // that never reach the runner still notify the owner. Without this
+    // a user-scheduled task can silently fail at fire time hours/days
+    // after the user issued it.
+    dispatcher.setBrowserTaskTerminalNotifier(browserTaskTerminalNotifier);
+    // ── 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
+    // both sweeps so the daemon has one mental model for time-based
+    // browser-task housekeeping (cadence preserved from the retired B-3
+    // approval-tokens supervisor; see browser-task-deadline-scanner.ts).
+    // The tick:
+    //   1. lists overdue clarifications (resolved=0 AND deadline_at < now)
+    //   2. asks the slot manager to sweep pending-queue timeouts
+    //   3. folds the two lists via `decideDeadlineActions`
+    //   4. for each action, writes the terminal transition + releases the
+    //      slot (clarifications also expire the clarification row so the
+    //      `awaiting_user → abandoned` edge is recorded)
+    //   5. DMs the originating channel once per affected task
+    //
+    // The tick is best-effort: it logs and continues on per-row failures
+    // so a single bad row cannot wedge the timer. Cleared during graceful
+    // shutdown alongside the keepalive timer (see
+    // BootstrapEventPipelineResult.browserTaskDeadlineTimer).
+    //
+    // Phase 2 — both branches delegate to `browserTaskRunner.expireForDeadline`
+    // so a parked Playwright handle gets `releaseDriverHandle`'d alongside
+    // the terminal DB write (clarification-deadline path) and the SSE +
+    // slot-manager fan-out stays consistent with the runner's own
+    // terminal-write paths. The runner method is idempotent on
+    // already-terminal rows, so a concurrent /cancel race is safe.
+    const browserTaskDeadlineTimer = await (async () => {
+        const { decideDeadlineActions, DEADLINE_SCAN_INTERVAL_MS, } = await import("../services/browser-task/browser-task-deadline-scanner.js");
+        const { sweepPendingTimeouts } = await import("../services/browser-task/browser-task-slots.js");
+        const { listOverdueClarifications, expireClarification, } = await import("../db/browser-task-clarifications-store.js");
+        // `parseBrowserTaskChannelRef` is the same `parseChannelRef` hoisted
+        // above for the runner notifier; reuse it so the deadline tick and
+        // the runner share one channel-parse contract.
+        async function tick() {
+            try {
+                const now = Date.now();
+                const overdue = listOverdueClarifications(db, now);
+                const sweep = sweepPendingTimeouts(browserTaskSlotStateRef.state, now, config.browserTaskPendingQueueTimeoutMinutes);
+                // Apply the pending-queue removals to the shared slot ref so a
+                // subsequent route-layer queueState read does not still see
+                // expired entries.
+                browserTaskSlotStateRef.state = sweep.state;
+                const actions = decideDeadlineActions({
+                    overdueClarifications: overdue,
+                    expiredPending: sweep.expired,
+                    nowMs: now,
+                });
+                if (actions.length === 0)
+                    return;
+                for (const action of actions) {
+                    try {
+                        if (action.kind === "abandon_clarification") {
+                            // Mark the clarification row expired first so the
+                            // dashboard's clarification list reflects the deadline
+                            // miss even if `expireForDeadline` hits a CAS race below.
+                            expireClarification(db, action.clarificationId, action.nowMs);
+                            // Delegate the parent-task transition to the runner so
+                            // the parked Playwright handle is released alongside the
+                            // terminal DB write — without this, every overdue
+                            // clarification leaks a Chromium process + workdir.
+                            // `expireForDeadline` is idempotent on already-terminal
+                            // rows, so a concurrent cancel-race is safe.
+                            const result = await browserTaskRunner.expireForDeadline(action.taskId, "clarification_deadline");
+                            if (result.state === "abandoned") {
+                                const row = (await import("../db/browser-task-store.js"))
+                                    .getBrowserTask(db, action.taskId);
+                                await sendDeadlineDm(row?.originatingChannel ?? null, `⏰ Browser task ${action.taskId}: the 5-minute clarification window elapsed without a reply. Task abandoned.`);
+                            }
+                        }
+                        else {
+                            // Queue-timeout — the pending row never acquired a slot,
+                            // so no Playwright handle exists to release. Still route
+                            // through the runner so the slot-manager / DB / SSE
+                            // emission stay coordinated; `expireForDeadline` flips
+                            // the row to `failed (queue_timeout)` and is a no-op on
+                            // the slot manager (the pending FIFO entry was already
+                            // removed by `sweepPendingTimeouts` above).
+                            const result = await browserTaskRunner.expireForDeadline(action.taskId, "queue_timeout", action.waitedMs);
+                            const terminal = result.state === "failed"
+                                ? (await import("../db/browser-task-store.js"))
+                                    .getBrowserTask(db, action.taskId)
+                                : null;
+                            if (terminal) {
+                                // BROWSER_TASK_REDESIGN_PLAN.md §5.1 + §13 — the
+                                // pending-queue timeout transition is the one slot-
+                                // manager telemetry row the plan's test list pins
+                                // explicitly ("emits agent_actions.queue.timeout + DM
+                                // intent"). The DM intent is the sendDeadlineDm below;
+                                // this writes the paired audit row so the operator can
+                                // diagnose saturation episodes without dumping the
+                                // in-memory slot map. The remaining queue.* events
+                                // (enter / promote / release) power the dashboard
+                                // "queue health" surface flagged as §9a future work and
+                                // are deferred with the rest of that surface.
+                                try {
+                                    db.prepare(`INSERT INTO agent_actions
+                       (action_type, detail, result, started_at, completed_at)
+                     VALUES (?, ?, 'success', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`).run("browser_task.queue.timeout", JSON.stringify({
+                                        taskId: action.taskId,
+                                        siteKey: action.siteKey,
+                                        waitedMs: action.waitedMs,
+                                    }));
+                                }
+                                catch (err) {
+                                    /* c8 ignore next 5 */
+                                    logger.warn({ err, taskId: action.taskId }, "browser-task queue.timeout audit insert failed (continuing)");
+                                }
+                                await sendDeadlineDm(terminal.originatingChannel, `⏰ Browser task ${action.taskId}: queued for ${Math.round(action.waitedMs / 60000)} min behind a parked task and exceeded the pending-queue timeout. Task failed.`);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger.warn({ err, action }, "browser-task deadline action failed (continuing)");
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn({ err }, "browser-task deadline tick failed (continuing)");
+            }
+        }
+        async function sendDeadlineDm(ref, text) {
+            if (!ref)
+                return;
+            const parsed = parseBrowserTaskChannelRef(ref);
+            if (!parsed) {
+                // Persisted via the §14.8-attested channel set, so an
+                // unparseable value here means a value drifted past the
+                // attestation — flag visibly even though we cannot deliver.
+                logger.warn({ ref }, "browser-task deadline DM: unparseable channel ref — skipping");
+                return;
+            }
+            try {
+                await messageHub.sendToPlatform(parsed.platform, parsed.channelId, text);
+            }
+            catch (err) {
+                logger.warn({ err, ref }, "browser-task deadline DM dispatch failed (continuing)");
+            }
+        }
+        const timer = setInterval(() => {
+            void tick();
+        }, DEADLINE_SCAN_INTERVAL_MS);
+        // Allow the daemon to exit cleanly if every other timer has unrefed;
+        // a 30 s tick is housekeeping, not load-bearing for liveness.
+        if (typeof timer.unref === "function")
+            timer.unref();
+        return timer;
+    })();
+    // ── 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
+    // wrote `agent_actions(action_type='browser_task.boot_recovery')` rows
+    // (deferred DM dispatch because the messaging adapters were still
+    // constructing). Now that `messageHub` exists, scan the audit log for
+    // un-DM'd recovery rows and fan them out once. A per-row marker on
+    // `agent_actions.metadata` ensures a second boot cannot double-DM.
+    //
+    // Best-effort: failures log but do not abort startup. The audit log
+    // remains the source of truth — an operator can re-fan by running the
+    // same SQL manually if all DMs fail.
+    void (async () => {
+        try {
+            const rows = db
+                .prepare(`SELECT id, detail FROM agent_actions
+            WHERE action_type = 'browser_task.boot_recovery'
+              AND (metadata IS NULL
+                OR json_extract(metadata, '$.dmSentAt') IS NULL)
+            ORDER BY id ASC`)
+                .all();
+            if (rows.length === 0)
+                return;
+            const markDmSent = db.prepare(`UPDATE agent_actions
+            SET metadata = json_set(COALESCE(metadata, '{}'), '$.dmSentAt', ?)
+          WHERE id = ?`);
+            for (const row of rows) {
+                try {
+                    const detail = JSON.parse(row.detail);
+                    const taskId = detail.taskId ?? "<unknown>";
+                    const ref = detail.originatingChannel;
+                    if (ref) {
+                        const parsed = parseBrowserTaskChannelRef(ref);
+                        if (parsed) {
+                            await messageHub.sendToPlatform(parsed.platform, parsed.channelId, `♻️ Browser task ${taskId} was running when the daemon restarted and could not resume. The task is marked failed; re-issue the request if you still want it run.`);
+                        }
+                        else {
+                            logger.warn({ taskId, ref }, "browser-task boot-recovery DM: unparseable channel ref — skipping");
+                        }
+                    }
+                    markDmSent.run(new Date().toISOString(), row.id);
+                }
+                catch (err) {
+                    logger.warn({ err, auditId: row.id }, "browser-task boot-recovery DM failed (continuing; row stays unmarked for next-boot retry)");
+                }
+            }
+            logger.info({ count: rows.length }, "browser-task boot-recovery: fanned DMs for restarted tasks");
+        }
+        catch (err) {
+            logger.warn({ err }, "browser-task boot-recovery DM fan-out failed (continuing)");
+        }
+    })();
     // P22 — wire the optimizer-workdir hooks. The `materialize` callback
     // captures db, dataDir, workspaceDir, contextDir, and secretStore so
     // the dispatcher branch can invoke it without importing the workdir
@@ -524,6 +1021,9 @@ export async function createEventPipeline(deps) {
         handleGoogleServicesReady,
         handlePromptContextChanged,
         keepaliveTimer,
+        browserTaskDeadlineTimer,
+        browserTaskSlotStateRef,
+        browserTaskRunner,
     };
 }
 /**
@@ -651,7 +1151,7 @@ export function createGoogleServicesReadyHandler(deps) {
         // (same logic as runCatchup, ensures schedule generation after first
         // auth).
         const contextDir = getContextDir(config);
-        const todayMdPath = join(contextDir, "today.md");
+        const todayMdPath = join(contextDir, "state", "today.md");
         const needsMorning = !hasFreshAgentDayTodayMd(todayMdPath, config.timezone || undefined, config.dayBoundaryHour);
         if (needsMorning) {
             // Morning routine's post-completion hook will also check roadmap staleness.
@@ -701,4 +1201,3 @@ export function createPromptContextChangedHandler(deps) {
         }
     };
 }
-//# sourceMappingURL=event-pipeline.js.map

package/dist/bootstrap/managed-chromium.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Boot-time wiring for the managed Chromium supervisor.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §7.1.
+ *
+ * - Reads the persisted `enabled` flag from runtime_state.
+ * - Resolves the host's sandbox primitive + Chromium binary.
+ * - Registers `ManagedChromiumSupervisor` with the daemon's
+ *   ObserverManager so it ticks alongside the other observers.
+ *
+ * Idempotent: if managed mode is disabled, this is a no-op. If enabled
+ * but the binary or sandbox is unavailable, the supervisor still
+ * registers (so the dashboard can surface the diagnostic) and writes
+ * the appropriate state-machine value into runtime_state.
+ */
+import type Database from "better-sqlite3";
+import type { AgentConfig } from "../config.js";
+import type { MessageHub } from "../adapters/message-hub.js";
+import type { ObserverManager } from "../observers/manager.js";
+export interface ManagedChromiumBootDeps {
+    db: Database.Database;
+    config: AgentConfig;
+    observerManager: ObserverManager;
+    messageHub: MessageHub | null;
+}
+export declare function maybeRegisterManagedChromium(deps: ManagedChromiumBootDeps): Promise<void>;