@aitne/daemon 0.1.8 → 0.1.10

package/dist/api/routes/books.js

@@ -45,11 +45,11 @@ export function parseKindleClippings(text) {
                 highlightedAt = null;
             }
         }
-        // Line 2 is blank, content starts at line 3
         const content = lines.slice(3).join("\n").trim();
         if (!content)
             continue;
-        // Skip bookmarks (they have no content or are just location markers)
+        // Skip bookmarks — Kindle exports them as entries with the same shape
+        // as highlights but no body, only a location marker.
         if (metaLine.includes("Bookmark"))
             continue;
         highlights.push({ bookKey, content, location, highlightedAt });
@@ -232,7 +232,6 @@ export function createBookRoutes(deps) {
        FROM books ${where}
        ORDER BY COALESCE(completed_at, started_at, created_at) DESC
        LIMIT ? OFFSET ?`).all(...params, limit, offset);
-        // Attach highlight count per book
         const bookIds = rows.map((r) => r.id);
         const highlightCounts = new Map();
         if (bookIds.length > 0) {
@@ -350,6 +349,9 @@ export function createBookRoutes(deps) {
             if (body.status === "completed") {
                 updates.push("completed_at = datetime('now')");
             }
+            else {
+                updates.push("completed_at = NULL");
+            }
         }
         if (body.rating !== undefined) {
             updates.push("rating = ?");
@@ -405,13 +407,11 @@ export function createBookRoutes(deps) {
             ]);
         }
         const { books: bookMap, highlights } = parseKindleClippings(body.data);
-        // Upsert books
         const insertHighlight = db.prepare(`INSERT INTO reading_highlights (book_id, content, location, highlighted_at)
        VALUES (?, ?, ?, ?)`);
         let booksCreated = 0;
         let highlightsInserted = 0;
         const importAll = db.transaction(() => {
-            // Map bookKey → book id
             const bookIdMap = new Map();
             for (const [key, { title, author }] of bookMap) {
                 // Use COALESCE to match the UNIQUE index on (title, COALESCE(author, ''))
@@ -427,12 +427,12 @@ export function createBookRoutes(deps) {
                     booksCreated++;
                 }
             }
-            // Insert highlights (check for duplicates by content + book_id)
             for (const h of highlights) {
                 const bookId = bookIdMap.get(h.bookKey);
                 if (!bookId)
                     continue;
-                // Simple dedup: check if identical content exists for this book
+                // Dedup by exact content match within the same book — Kindle
+                // exports duplicate every highlight on each re-export.
                 const exists = db.prepare(`SELECT 1 FROM reading_highlights WHERE book_id = ? AND content = ?`).get(bookId, h.content);
                 if (exists)
                     continue;
@@ -504,4 +504,3 @@ export function createBookRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=books.js.map

package/dist/api/routes/browser-automation-purchase.d.ts

@@ -0,0 +1,31 @@
+/**
+ * /api/browser-automation/purchase-tokens/* + /api/browser-automation/b4/*
+ * — Phase B-4 experimental purchase surface.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §17.10 / §13 step 55.
+ *
+ * Routes:
+ *   GET    /purchase-tokens                       — list pending + recent (Approve)
+ *   DELETE /purchase-tokens/:jti                  — cancel a pending token (Approve)
+ *   GET    /b4/enabled                            — global master toggle status (Autonomous)
+ *   POST   /b4/enabled                            — flip the master toggle (Approve, with body { enabled: bool, acknowledge: true })
+ *   GET    /b4/site-configs                       — per-site B-4 config rows (Autonomous)
+ *   PATCH  /sites/:siteKey/b4-config              — update per-site config (Approve)
+ *   GET    /b4/primary-channels                   — list primary channels (Autonomous)
+ *   PATCH  /channels/:platform/:channelId/primary — set/unset (Approve)
+ *
+ * The dashboard does NOT have an issuance form — tokens are issued by
+ * the daemon when a B-4 workflow is invoked, and delivered to DM
+ * channels, not the dashboard. The dashboard role is configuration +
+ * audit (§17.8). The raw `!~xxxxxxxx` token NEVER leaves the
+ * `purchase_tokens` table; the wire shapes carry only the server-side
+ * `jti` + the delivery state, so even an attacker who briefly
+ * compromises dashboard credentials cannot extract live tokens.
+ *
+ * Excluded from the 100% coverage gate — the file is route glue; the
+ * pure decision logic lives in `purchase-tokens.ts` and the DB CAS
+ * predicates in the stores.
+ */
+import { Hono } from "hono";
+import type { ApiDependencies } from "../server.js";
+export declare function createBrowserAutomationPurchaseRoutes(deps: ApiDependencies): Hono;

package/dist/api/routes/browser-automation-purchase.js

@@ -0,0 +1,251 @@
+/**
+ * /api/browser-automation/purchase-tokens/* + /api/browser-automation/b4/*
+ * — Phase B-4 experimental purchase surface.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §17.10 / §13 step 55.
+ *
+ * Routes:
+ *   GET    /purchase-tokens                       — list pending + recent (Approve)
+ *   DELETE /purchase-tokens/:jti                  — cancel a pending token (Approve)
+ *   GET    /b4/enabled                            — global master toggle status (Autonomous)
+ *   POST   /b4/enabled                            — flip the master toggle (Approve, with body { enabled: bool, acknowledge: true })
+ *   GET    /b4/site-configs                       — per-site B-4 config rows (Autonomous)
+ *   PATCH  /sites/:siteKey/b4-config              — update per-site config (Approve)
+ *   GET    /b4/primary-channels                   — list primary channels (Autonomous)
+ *   PATCH  /channels/:platform/:channelId/primary — set/unset (Approve)
+ *
+ * The dashboard does NOT have an issuance form — tokens are issued by
+ * the daemon when a B-4 workflow is invoked, and delivered to DM
+ * channels, not the dashboard. The dashboard role is configuration +
+ * audit (§17.8). The raw `!~xxxxxxxx` token NEVER leaves the
+ * `purchase_tokens` table; the wire shapes carry only the server-side
+ * `jti` + the delivery state, so even an attacker who briefly
+ * compromises dashboard credentials cannot extract live tokens.
+ *
+ * Excluded from the 100% coverage gate — the file is route glue; the
+ * pure decision logic lives in `purchase-tokens.ts` and the DB CAS
+ * predicates in the stores.
+ */
+import { z } from "zod";
+import { Hono } from "hono";
+import { cancelPurchaseToken, getPurchaseTokenByJti, listPendingPurchaseTokens, listRecentPurchaseTokens, } from "../../db/browser-automation-purchase-tokens-store.js";
+import { getB4Enabled, listSiteB4Configs, setB4Enabled, upsertSiteB4Config, } from "../../db/browser-automation-b4-config-store.js";
+import { clearPrimaryChannel, countPrimaryChannels, listPrimaryChannels, setPrimaryChannel, } from "../../db/browser-automation-purchase-primary-channels-store.js";
+import { createLogger } from "../../logging.js";
+import { readJsonBody } from "../json-body.js";
+const logger = createLogger("browser-automation-purchase-routes");
+/** Wire shape projected from the DB row. NEVER includes the raw
+ *  `token` string — the dashboard sees only the jti + state. */
+function toPurchaseTokenWire(row) {
+    return {
+        jti: row.jti,
+        workflowInvocationId: row.workflowInvocationId,
+        siteKey: row.siteKey,
+        status: row.status,
+        maxAmountMinor: row.maxAmountMinor,
+        currency: row.currency,
+        notesForUser: row.notesForUser,
+        preScreenshotPath: row.preScreenshotPath,
+        postScreenshotPath: row.postScreenshotPath,
+        deliveredChannels: row.deliveredChannels,
+        issuedAt: row.issuedAt,
+        expiresAt: row.expiresAt,
+        consumedAt: row.consumedAt,
+        consumedViaChannel: row.consumedViaChannel,
+        cancelledAt: row.cancelledAt,
+        cancelReason: row.cancelReason,
+        confirmedAmountMinor: row.confirmedAmountMinor,
+        orderId: row.orderId,
+    };
+}
+// ── Request / response Zod schemas ──────────────────────────────────────
+const enableToggleBodySchema = z.object({
+    enabled: z.boolean(),
+    /**
+     * Plan §17.8 — flipping enabled=true requires the user to explicitly
+     * acknowledge the experimental nature. The dashboard's modal sets
+     * this when the user clicks through; an automated caller cannot
+     * forge it because the dashboard's enable flow is the only legitimate
+     * caller and the modal is structurally part of the user flow.
+     */
+    acknowledge: z.boolean().optional(),
+});
+const siteB4ConfigPatchSchema = z.object({
+    enabled: z.boolean(),
+    currency: z.string().length(3),
+    dailyTokenCap: z.number().int().min(1).max(100).optional(),
+    dailySpendCapMinor: z.number().int().min(0).optional(),
+    perTxCapMinorOverride: z.number().int().min(0).nullable().optional(),
+});
+const primaryChannelPatchSchema = z.object({
+    primary: z.boolean(),
+});
+// ────────────────────────────────────────────────────────────────────────
+export function createBrowserAutomationPurchaseRoutes(deps) {
+    const app = new Hono();
+    // ── GET /purchase-tokens ──
+    app.get("/browser-automation/purchase-tokens", (c) => {
+        const now = Date.now();
+        const pending = listPendingPurchaseTokens(deps.db, now, 32);
+        const recent = listRecentPurchaseTokens(deps.db, 50);
+        return c.json({
+            pending: pending.map(toPurchaseTokenWire),
+            recent: recent.map(toPurchaseTokenWire),
+            now,
+        });
+    });
+    // ── DELETE /purchase-tokens/:jti — Approve, dashboard "Cancel pending" ──
+    app.delete("/browser-automation/purchase-tokens/:jti", async (c) => {
+        const jti = c.req.param("jti");
+        if (!jti || !/^[a-f0-9-]{36}$/i.test(jti)) {
+            return c.json({ error: "invalid_jti" }, 400);
+        }
+        const before = getPurchaseTokenByJti(deps.db, jti);
+        if (!before)
+            return c.json({ error: "not_found" }, 404);
+        if (before.status !== "pending") {
+            return c.json({ error: "not_pending", currentStatus: before.status }, 409);
+        }
+        // The dashboard cancel path uses `dashboard_cancel` as the reason
+        // so the audit row distinguishes a user-initiated cancellation
+        // from the workflow-internal `playwright_error` cancellations.
+        if (deps.purchaseHandler) {
+            const row = await deps.purchaseHandler.cancel(jti, "dashboard_cancel");
+            if (!row)
+                return c.json({ error: "cas_missed" }, 409);
+            return c.json({ token: toPurchaseTokenWire(row) });
+        }
+        // Fallback when the handler is not wired — direct DB cancel. The
+        // user does not get the follow-up DM, but the token is invalidated.
+        const row = cancelPurchaseToken(deps.db, {
+            jti,
+            reason: "dashboard_cancel",
+            cancelledAt: Date.now(),
+            onlyIfPending: true,
+        });
+        if (!row)
+            return c.json({ error: "cas_missed" }, 409);
+        logger.warn({ jti }, "dashboard cancel ran without PurchaseHandler — follow-up DM skipped");
+        return c.json({ token: toPurchaseTokenWire(row) });
+    });
+    // ── GET /b4/enabled ──
+    app.get("/browser-automation/b4/enabled", (c) => {
+        return c.json({
+            enabled: getB4Enabled(deps.db),
+            primaryChannelCount: countPrimaryChannels(deps.db),
+        });
+    });
+    // ── POST /b4/enabled — Approve ──
+    app.post("/browser-automation/b4/enabled", async (c) => {
+        const body = await readJsonBody(c);
+        if (!body.ok)
+            return body.response;
+        const parsed = enableToggleBodySchema.safeParse(body.body);
+        if (!parsed.success) {
+            return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
+        }
+        if (parsed.data.enabled) {
+            if (!parsed.data.acknowledge) {
+                return c.json({
+                    error: "acknowledgement_required",
+                    detail: "Enabling B-4 requires acknowledge=true (user clicked through " +
+                        "the experimental-danger modal). Replay the request with " +
+                        "{ enabled: true, acknowledge: true }.",
+                }, 400);
+            }
+            if (countPrimaryChannels(deps.db) === 0) {
+                return c.json({
+                    error: "no_primary_channels",
+                    detail: "At least one primary channel must be configured before B-4 " +
+                        "can be enabled. See §17.8.",
+                }, 400);
+            }
+        }
+        setB4Enabled(deps.db, parsed.data.enabled);
+        logger.warn({ enabled: parsed.data.enabled }, parsed.data.enabled
+            ? "B-4 master toggle flipped ON via dashboard"
+            : "B-4 master toggle flipped OFF via dashboard");
+        return c.json({
+            enabled: parsed.data.enabled,
+            primaryChannelCount: countPrimaryChannels(deps.db),
+        });
+    });
+    // ── GET /b4/site-configs ──
+    app.get("/browser-automation/b4/site-configs", (c) => {
+        return c.json({ rows: listSiteB4Configs(deps.db) });
+    });
+    // ── PATCH /sites/:siteKey/b4-config — Approve ──
+    app.patch("/browser-automation/sites/:siteKey/b4-config", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!siteKey || !/^[a-z][a-z0-9_]*$/.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        const body = await readJsonBody(c);
+        if (!body.ok)
+            return body.response;
+        const parsed = siteB4ConfigPatchSchema.safeParse(body.body);
+        if (!parsed.success) {
+            return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
+        }
+        const row = upsertSiteB4Config(deps.db, {
+            siteKey,
+            enabled: parsed.data.enabled,
+            currency: parsed.data.currency.toUpperCase(),
+            dailyTokenCap: parsed.data.dailyTokenCap,
+            dailySpendCapMinor: parsed.data.dailySpendCapMinor,
+            perTxCapMinorOverride: parsed.data.perTxCapMinorOverride,
+            updatedAt: Date.now(),
+        });
+        logger.info({ siteKey, enabled: row.enabled, currency: row.currency }, "B-4 site config updated");
+        return c.json({ row });
+    });
+    // ── GET /b4/primary-channels ──
+    app.get("/browser-automation/b4/primary-channels", (c) => {
+        return c.json({ rows: listPrimaryChannels(deps.db) });
+    });
+    // ── PATCH /channels/:platform/:channelId/primary — Approve ──
+    app.patch("/browser-automation/channels/:platform/:channelId/primary", async (c) => {
+        const platform = c.req.param("platform");
+        const channelId = c.req.param("channelId");
+        if (!platform || !channelId) {
+            return c.json({ error: "invalid_channel_ref" }, 400);
+        }
+        if (!/^[a-z][a-z0-9_-]*$/i.test(platform)) {
+            return c.json({ error: "invalid_platform" }, 400);
+        }
+        if (channelId.length > 256) {
+            return c.json({ error: "channel_id_too_long" }, 400);
+        }
+        const body = await readJsonBody(c);
+        if (!body.ok)
+            return body.response;
+        const parsed = primaryChannelPatchSchema.safeParse(body.body);
+        if (!parsed.success) {
+            return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
+        }
+        if (parsed.data.primary) {
+            setPrimaryChannel(deps.db, {
+                platform,
+                channelId,
+                setAt: Date.now(),
+            });
+        }
+        else {
+            // Refuse to clear the LAST primary channel while B-4 is enabled —
+            // doing so would leave the master toggle on with no recipient
+            // for the confirmation DM, structurally guaranteed to fail
+            // every issuance. The user should turn the master toggle off
+            // first.
+            if (getB4Enabled(deps.db) && countPrimaryChannels(deps.db) <= 1) {
+                return c.json({
+                    error: "would_leave_zero_primary",
+                    detail: "Cannot clear the last primary channel while B-4 is enabled. " +
+                        "Disable B-4 first via /b4/enabled.",
+                }, 409);
+            }
+            clearPrimaryChannel(deps.db, platform, channelId);
+        }
+        return c.json({ primary: parsed.data.primary });
+    });
+    return app;
+}

package/dist/api/routes/browser-automation-sites.d.ts

@@ -0,0 +1,22 @@
+/**
+ * /api/browser-automation/sites/* — Phase B-2.5 per-site sign-in surface.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §16.9.
+ *
+ * Routes:
+ *   GET    /sites                          — list registered sites + per-site state
+ *   POST   /sites/:siteKey/connect         — start sign-in (spawn UI Chromium)
+ *   GET    /sites/:siteKey/status          — poll connection state during bootstrap
+ *   POST   /sites/:siteKey/finalize        — confirm signed-in, kill UI window
+ *   POST   /sites/:siteKey/reauth          — re-spawn UI Chromium reusing profile
+ *   POST   /sites/:siteKey/disconnect      — kill processes + delete profile dir
+ *
+ * Risk-tier enforcement is centralised in `risk-classifier.ts`; this
+ * module validates request shapes, defers to the bootstrap module, and
+ * shapes the Zod-validated response. The runtime workflow-execution layer
+ * (Playwright CDP probe) is excluded from coverage — this thin handler
+ * matches the same exclusion rationale as `browser-history-managed.ts`.
+ */
+import { Hono } from "hono";
+import type { ApiDependencies } from "../server.js";
+export declare function createBrowserAutomationSitesRoutes(deps: ApiDependencies): Hono;

package/dist/api/routes/browser-automation-sites.js

@@ -0,0 +1,238 @@
+/**
+ * /api/browser-automation/sites/* — Phase B-2.5 per-site sign-in surface.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §16.9.
+ *
+ * Routes:
+ *   GET    /sites                          — list registered sites + per-site state
+ *   POST   /sites/:siteKey/connect         — start sign-in (spawn UI Chromium)
+ *   GET    /sites/:siteKey/status          — poll connection state during bootstrap
+ *   POST   /sites/:siteKey/finalize        — confirm signed-in, kill UI window
+ *   POST   /sites/:siteKey/reauth          — re-spawn UI Chromium reusing profile
+ *   POST   /sites/:siteKey/disconnect      — kill processes + delete profile dir
+ *
+ * Risk-tier enforcement is centralised in `risk-classifier.ts`; this
+ * module validates request shapes, defers to the bootstrap module, and
+ * shapes the Zod-validated response. The runtime workflow-execution layer
+ * (Playwright CDP probe) is excluded from coverage — this thin handler
+ * matches the same exclusion rationale as `browser-history-managed.ts`.
+ */
+import { browserAutomationSiteActionResponseSchema, browserAutomationSitesResponseSchema, browserAutomationSiteStatusResponseSchema, } from "@aitne/shared";
+import { Hono } from "hono";
+import { readManagedChromiumState } from "../../db/managed-chromium-state.js";
+import { readSiteBootstrap, readSiteConnection, } from "../../db/managed-chromium-sites-store.js";
+import { createLogger } from "../../logging.js";
+import { getSite, listSites, resolveSiteSurface, } from "../../services/browser-history/automation/site-registry.js";
+import { disconnectSite, finalizeSiteBootstrap, getSiteBootstrapStatus, startSiteBootstrap, } from "../../services/browser-history/managed-chromium/site-bootstrap.js";
+import { createHostProfile } from "../../services/browser-history/lifecycle/platform.js";
+const logger = createLogger("browser-automation-sites-routes");
+const SITE_KEY_REGEX = /^[a-z][a-z0-9_]*$/;
+/** Map a `StartSiteBootstrapResult.reason` / similar code into the
+ *  shared wire-level enum used by every site action response. */
+function reasonToWire(reason) {
+    return reason;
+}
+export function createBrowserAutomationSitesRoutes(deps) {
+    const app = new Hono();
+    const host = createHostProfile();
+    const paDataDir = deps.config.dataDir;
+    // ── GET /sites ──
+    app.get("/browser-automation/sites", (c) => {
+        const now = Date.now();
+        const sites = listSites().map((site) => {
+            const conn = readSiteConnection(deps.db, site.siteKey);
+            const bootstrap = readSiteBootstrap(deps.db, site.siteKey);
+            const surface = resolveSiteSurface({
+                site,
+                connection: conn
+                    ? {
+                        connectedAt: conn.connectedAt,
+                        accountLabel: conn.accountLabel,
+                        lastWorkflowAt: conn.lastWorkflowAt,
+                    }
+                    : null,
+                bootstrapRunning: bootstrap !== null && bootstrap.deadlineAt > now,
+                nowMs: now,
+            });
+            return {
+                siteKey: site.siteKey,
+                displayName: site.displayName,
+                state: surface.state,
+                accountLabel: surface.accountLabel,
+                connectedAt: surface.connectedAt,
+                lastWorkflowAt: surface.lastWorkflowAt,
+                sessionMaxAgeDays: site.sessionMaxAgeDays,
+            };
+        });
+        return c.json(browserAutomationSitesResponseSchema.parse({ sites }));
+    });
+    // ── POST /sites/:siteKey/connect ──
+    app.post("/browser-automation/sites/:siteKey/connect", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!SITE_KEY_REGEX.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        const managed = readManagedChromiumState(deps.db);
+        if (!managed.enabled) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: currentSurfaceState(deps, siteKey),
+                reason: "managed_chromium_disabled",
+            }), 409);
+        }
+        if (!getSite(siteKey)) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: "not_connected",
+                reason: "unknown_site",
+            }), 404);
+        }
+        const result = await startSiteBootstrap({ db: deps.db, host, paDataDir }, { siteKey, reauth: false });
+        return c.json(browserAutomationSiteActionResponseSchema.parse({
+            ok: result.ok,
+            siteKey,
+            state: currentSurfaceState(deps, siteKey),
+            reason: result.ok ? undefined : reasonToWire(result.reason),
+        }), result.ok ? 200 : 409);
+    });
+    // ── GET /sites/:siteKey/status ──
+    app.get("/browser-automation/sites/:siteKey/status", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!SITE_KEY_REGEX.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        if (!getSite(siteKey)) {
+            return c.json({ error: "unknown_site" }, 404);
+        }
+        const status = await getSiteBootstrapStatus({ db: deps.db, paDataDir }, siteKey);
+        if (status.state === "idle") {
+            return c.json(browserAutomationSiteStatusResponseSchema.parse({
+                siteKey,
+                bootstrapRunning: false,
+                pid: null,
+                deadlineAt: null,
+                signedIn: false,
+                accountLabel: null,
+            }));
+        }
+        return c.json(browserAutomationSiteStatusResponseSchema.parse({
+            siteKey,
+            bootstrapRunning: true,
+            pid: status.pid,
+            deadlineAt: status.deadlineAt,
+            signedIn: status.signedIn,
+            // Prefer the *live probe's* extracted label so the dashboard
+            // shows "Detected as Alice — click Finalize" before the user
+            // commits. Fall back to the persisted connection row (relevant
+            // only on a re-auth bootstrap where the previous connection
+            // already wrote a label). Probe cap of 120 chars matches the
+            // schema's accountLabel max.
+            accountLabel: status.signedIn
+                ? status.accountLabel
+                    ?? readSiteConnection(deps.db, siteKey)?.accountLabel
+                    ?? null
+                : null,
+        }));
+    });
+    // ── POST /sites/:siteKey/finalize ──
+    app.post("/browser-automation/sites/:siteKey/finalize", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!SITE_KEY_REGEX.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        if (!getSite(siteKey)) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: "not_connected",
+                reason: "unknown_site",
+            }), 404);
+        }
+        const result = await finalizeSiteBootstrap({ db: deps.db, host, paDataDir }, { siteKey });
+        return c.json(browserAutomationSiteActionResponseSchema.parse({
+            ok: result.ok,
+            siteKey,
+            state: currentSurfaceState(deps, siteKey),
+            reason: result.ok ? undefined : reasonToWire(result.reason),
+        }), result.ok ? 200 : 409);
+    });
+    // ── POST /sites/:siteKey/reauth ──
+    app.post("/browser-automation/sites/:siteKey/reauth", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!SITE_KEY_REGEX.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        const managed = readManagedChromiumState(deps.db);
+        if (!managed.enabled) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: currentSurfaceState(deps, siteKey),
+                reason: "managed_chromium_disabled",
+            }), 409);
+        }
+        if (!getSite(siteKey)) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: "not_connected",
+                reason: "unknown_site",
+            }), 404);
+        }
+        const result = await startSiteBootstrap({ db: deps.db, host, paDataDir }, { siteKey, reauth: true });
+        return c.json(browserAutomationSiteActionResponseSchema.parse({
+            ok: result.ok,
+            siteKey,
+            state: currentSurfaceState(deps, siteKey),
+            reason: result.ok ? undefined : reasonToWire(result.reason),
+        }), result.ok ? 200 : 409);
+    });
+    // ── POST /sites/:siteKey/disconnect ──
+    app.post("/browser-automation/sites/:siteKey/disconnect", async (c) => {
+        const siteKey = c.req.param("siteKey");
+        if (!SITE_KEY_REGEX.test(siteKey)) {
+            return c.json({ error: "invalid_site_key" }, 400);
+        }
+        if (!getSite(siteKey)) {
+            return c.json(browserAutomationSiteActionResponseSchema.parse({
+                ok: false,
+                siteKey,
+                state: "not_connected",
+                reason: "unknown_site",
+            }), 404);
+        }
+        await disconnectSite({ db: deps.db, host, paDataDir }, { siteKey });
+        logger.info({ siteKey }, "site disconnected (UI window killed + profile dir removed)");
+        return c.json(browserAutomationSiteActionResponseSchema.parse({
+            ok: true,
+            siteKey,
+            state: "not_connected",
+        }));
+    });
+    return app;
+}
+/** Lookup the current surface state for a site without re-running the
+ *  full status probe — used by route handlers to render a consistent
+ *  state value after a mutation. */
+function currentSurfaceState(deps, siteKey) {
+    const site = getSite(siteKey);
+    if (!site)
+        return "not_connected";
+    const now = Date.now();
+    const conn = readSiteConnection(deps.db, siteKey);
+    const bootstrap = readSiteBootstrap(deps.db, siteKey);
+    return resolveSiteSurface({
+        site,
+        connection: conn
+            ? {
+                connectedAt: conn.connectedAt,
+                accountLabel: conn.accountLabel,
+                lastWorkflowAt: conn.lastWorkflowAt,
+            }
+            : null,
+        bootstrapRunning: bootstrap !== null && bootstrap.deadlineAt > now,
+        nowMs: now,
+    }).state;
+}

package/dist/api/routes/browser-history-managed.d.ts

@@ -0,0 +1,23 @@
+/**
+ * /api/browser-history/managed/* — dashboard control surface for the
+ * managed Chromium Instance S.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §7.7.
+ *
+ * Routes:
+ *   GET  /status         — full state-machine snapshot for the dashboard
+ *   POST /setup          — start interactive sign-in (spawn UI Chromium)
+ *   GET  /setup-status   — poll bootstrap progress (signed-in yet?)
+ *   POST /setup-finish   — finalise bootstrap (quit UI Chromium)
+ *   POST /reconnect      — re-spawn UI Chromium reusing the profile dir
+ *   POST /disconnect     — stop, delete profile dir, mark disconnected
+ *   POST /enable         — toggle master enable / unsandboxedOptIn
+ *
+ * Risk-tier enforcement is centralised in `risk-classifier.ts`; this
+ * module only needs to validate request bodies, route to the
+ * supervisor / bootstrap modules, and shape the Zod-validated
+ * response.
+ */
+import { Hono } from "hono";
+import type { ApiDependencies } from "../server.js";
+export declare function createBrowserHistoryManagedRoutes(deps: ApiDependencies): Hono;