@aitne/daemon 0.1.8 → 0.1.10

package/dist/messaging/browser-task-mcp-notifier.js

@@ -0,0 +1,164 @@
+/**
+ * Browser-task MCP-side DM dispatcher — BROWSER_TASK_REDESIGN_PLAN.md §5.
+ *
+ * The browser-task sub-agent's `ask_user` and `finish` tools call out to
+ * this surface to DM the originating channel:
+ *
+ *   - `notifyAskUser`  → "❓ Browser task <id> needs your input." with
+ *                        the question + the screenshot attached inline.
+ *   - `notifyFinish`   → the agent's markdown report + the ordered list
+ *                        of screenshots (attached inline) the user should
+ *                        review.
+ *
+ * Distinct from the runner-side `BrowserTaskNotifier` (queued / terminal
+ * structural DMs):
+ *
+ *   - The runner-side notifier covers events the sub-agent never sees
+ *     (the slot manager queued the task, the SDK loop crashed before any
+ *     tool fired, etc.). Plain templated bodies.
+ *   - This MCP-side notifier carries agent-authored prose — the
+ *     `question` / `report` strings come from the sub-agent.
+ *
+ * The two cannot collapse into one because:
+ *   - The SDK tool body needs synchronous access to a notifier (it's
+ *     invoked inside `mcp__aitne-browser__ask_user`'s handler); the
+ *     runner-side notifier is invoked from the runner's lifecycle hooks.
+ *   - The agent-authored vs. structural split keeps the redaction-
+ *     coverage guard happy: structural bodies are templated text that
+ *     the guard knows is safe; agent bodies pass the same redaction
+ *     pipeline already applied to other LLM-authored outbound text.
+ *
+ * Best-effort delivery: DM failures log + continue. The DB row for the
+ * task / clarification has already been written by the tool handler, so
+ * a DM hiccup does NOT block the parent task — the dashboard surfaces
+ * the row regardless. (See §5 ask_user "Resume — Deadline enforcement"
+ * for the deadline-driven fallback when the user never sees the DM.)
+ *
+ * No capability-symbol gate here. The structural anti-spoofing surface
+ * (B-4 purchase confirms + lite-final-confirm tokens) protects DM bodies
+ * that the agent could otherwise mint to itself; `ask_user` / `finish`
+ * bodies are intentionally agent-authored — the user is reading the
+ * agent's question / report. The only header marker we attach is for the
+ * user's benefit, not for adapter-side trust gating.
+ */
+import { createLogger } from "../logging.js";
+import { MessageDeliveryError, } from "../adapters/message-hub.js";
+import { parseChannelRef } from "../db/browser-automation-purchase-primary-channels-store.js";
+import { resolveScreenshotAttachment, } from "./browser-task-screenshot-attachment.js";
+const logger = createLogger("browser-task-mcp-notifier");
+/** Header line for ask_user DMs. Chosen so it does NOT collide with the
+ *  B-4 / lite-final-confirm markers (which carry the literal substring
+ *  "confirmation") nor with the runner's `🕒` / `🟦` queue / terminal
+ *  emojis. */
+export const ASK_USER_HEADER = "Browser task — needs your input";
+/** Header line for finish DMs. */
+export const FINISH_HEADER = "Browser task — report";
+/** Soft cap on the `finish` report body inside the DM. The agent's tool
+ *  schema already caps `report` at 8 KB; some adapters (Telegram) cap
+ *  individual messages at ~4 KB. We truncate at 3 800 chars to leave
+ *  comfortable room for headers + screenshot links and append a "[…]"
+ *  marker so the user can tell the report was cropped.
+ *  The Aitne dashboard's per-task detail page renders the full report
+ *  via `GET /api/browser-task/:id`, so truncation is purely a DM-side
+ *  ergonomic. */
+const FINISH_REPORT_DM_BODY_CAP = 3_800;
+/** Max screenshots attached to a single finish DM. The full ordered list
+ *  is preserved in the row's `report` field; this cap just keeps the DM
+ *  from ballooning with attachments. */
+const FINISH_DM_SCREENSHOT_LINK_CAP = 8;
+export function createBrowserTaskMcpNotifier(deps) {
+    const paDataDir = deps.paDataDir ?? null;
+    /** Per-channel delivery. Both surfaces receive the screenshot as actual
+     *  image bytes — never a URL:
+     *
+     *   - `dashboard`: each key is ingested into the chat `AttachmentStore`
+     *     and delivered as an `OutboundAttachmentRef`; the dashboard renders
+     *     it inline by fetching `/api/chat/attachments/:id` through its
+     *     authenticated same-origin proxy.
+     *   - messaging adapters (WhatsApp / Telegram / Slack / Discord): each
+     *     key is handed to the adapter as a trace-file `OutboundAttachmentRef`
+     *     so the adapter uploads the bytes via its native API.
+     *
+     *  Any key that cannot be resolved (file dropped by §14.7 retention,
+     *  ingest unavailable, unknown extension) is replaced by a single
+     *  "unavailable" note rather than an unreachable link. The dashboard's
+     *  `/browser-tasks/<id>` page remains the canonical full-trace view. */
+    async function dispatch(ref, head, tail, screenshotKeys) {
+        const parsed = parseChannelRef(ref);
+        if (!parsed) {
+            logger.warn({ ref }, "browser-task MCP notifier: unparseable channel ref — DM skipped");
+            return;
+        }
+        const headLines = head.filter((s) => s !== null);
+        const tailLines = tail.filter((s) => s !== null);
+        const resolved = (await Promise.all(screenshotKeys.map((key) => resolveScreenshotAttachment({
+            platform: parsed.platform,
+            key,
+            paDataDir,
+            ingestOutboundImage: deps.ingestOutboundImage,
+        })))).filter((a) => a !== null);
+        const unresolved = screenshotKeys.length - resolved.length;
+        const noteBlock = unresolved > 0
+            ? [
+                "",
+                `(${unresolved} screenshot${unresolved === 1 ? "" : "s"} could not be attached — open the browser-task detail page)`,
+            ]
+            : [];
+        const body = [...headLines, ...noteBlock, ...tailLines].join("\n");
+        const attachments = resolved.length > 0 ? resolved : undefined;
+        try {
+            await deps.messageHub.sendToPlatform(parsed.platform, parsed.channelId, body, undefined, attachments);
+        }
+        catch (err) {
+            const reason = err instanceof MessageDeliveryError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            logger.warn({ ref, reason }, "browser-task MCP notifier: DM dispatch failed (continuing)");
+        }
+    }
+    async function notifyAskUser(input) {
+        if (!input.originatingChannel) {
+            logger.warn({
+                taskId: input.taskId,
+                clarificationId: input.clarificationId,
+            }, "ask_user: no originating channel persisted — DM skipped (clarification row still written)");
+            return;
+        }
+        const screenshotKeys = input.screenshotKey ? [input.screenshotKey] : [];
+        const head = [
+            `❓ ${ASK_USER_HEADER}`,
+            `Task: ${input.taskId}`,
+            `Question: ${input.question}`,
+            `Context: ${input.contextSummary}`,
+        ];
+        const tail = [
+            ``,
+            `Reply in this DM to answer (clarification id: ${input.clarificationId}).`,
+        ];
+        await dispatch(input.originatingChannel, head, tail, screenshotKeys);
+    }
+    async function notifyFinish(input) {
+        if (!input.originatingChannel) {
+            logger.warn({ taskId: input.taskId }, "finish: no originating channel persisted — DM skipped (report still stored on the row)");
+            return;
+        }
+        const reportBody = input.report.length > FINISH_REPORT_DM_BODY_CAP
+            ? `${input.report.slice(0, FINISH_REPORT_DM_BODY_CAP)}\n\n[… truncated; open the dashboard for the full report]`
+            : input.report;
+        const keyBudget = input.screenshotKeys.slice(0, FINISH_DM_SCREENSHOT_LINK_CAP);
+        const overflowCount = Math.max(0, input.screenshotKeys.length - keyBudget.length);
+        const head = [
+            `✅ ${FINISH_HEADER}`,
+            `Task: ${input.taskId}`,
+            ``,
+            reportBody,
+        ];
+        const tail = overflowCount > 0
+            ? [``, `(+${overflowCount} more — see dashboard)`]
+            : [];
+        await dispatch(input.originatingChannel, head, tail, keyBudget);
+    }
+    return { notifyAskUser, notifyFinish };
+}

package/dist/messaging/browser-task-screenshot-attachment.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared resolver: turn a browser-task screenshot key
+ * (`/api/browser-task/<id>/screenshots/<file>`, the `apiPathForTraceFile`
+ * form the runner records) into a platform-appropriate outbound attachment.
+ *
+ * Three callers — the MCP notifier (`ask_user` / `finish`), the lite
+ * final-confirm sender, and the B-4 purchase sender — all need the SAME
+ * "deliver the screenshot as actual bytes, never a loopback URL" behaviour:
+ *
+ *   - `dashboard`: ingest the trace file into the chat `AttachmentStore` so
+ *     the dashboard fetches it by id through the authenticated same-origin
+ *     `/api/chat/attachments/:id` proxy and renders it inline. A raw `<img>`
+ *     pointed at the loopback trace URL would 401 — the bearer token is never
+ *     attached to an `<img>` request.
+ *   - messaging adapters (WhatsApp / Telegram / Slack / Discord): hand the
+ *     trace file straight to the adapter's native upload API. A loopback URL
+ *     is unreachable from a phone.
+ *
+ * Returns null when the key shape is unrecognised, paDataDir / the ingest
+ * hook is unwired, the extension is not a known image type, or the file is
+ * missing on disk (e.g. §14.7 retention dropped it). Callers degrade to a
+ * brief "unavailable" note or simply omit the image — never an unreachable
+ * link.
+ */
+import type { OutboundAttachmentRef } from "../adapters/types.js";
+/** Matches the `apiPathForTraceFile` form. Tolerates a trailing query / hash
+ *  (none today, but keeps the parse robust if the URL shape ever grows one). */
+export declare const SCREENSHOT_KEY_PATTERN: RegExp;
+/** Ingest a resolved trace screenshot into the chat `AttachmentStore`,
+ *  minting a fetchable id. Supplied by the daemon bootstrap (closure over the
+ *  store); returns null on ingest failure. */
+export type IngestOutboundImage = (input: {
+    absPath: string;
+    mimeType: string;
+    originalFilename: string;
+}) => Promise<OutboundAttachmentRef | null>;
+/** Resolve a screenshot key to its on-disk trace location + image MIME, or
+ *  null when paDataDir is absent, the key shape is unrecognised, the path
+ *  normaliser rejects the inputs (defence against escapes), or the extension
+ *  is not a known image type. Pure — `resolveTraceFilePath` is path math. */
+export declare function resolveTraceImage(paDataDir: string | null, key: string): {
+    absPath: string;
+    fileName: string;
+    mimeType: string;
+} | null;
+/** Messaging path: hand the trace file directly to the adapter's native
+ *  upload API. Null when the file is missing on disk (the caller emits an
+ *  "unavailable" note rather than a loopback URL a phone cannot reach). */
+export declare function buildTraceAttachment(paDataDir: string | null, key: string): Promise<OutboundAttachmentRef | null>;
+/** Dashboard path: ingest the trace file into the `AttachmentStore` so the
+ *  dashboard can fetch it inline by id. Null when paDataDir / the ingest hook
+ *  is unwired or ingest fails. */
+export declare function buildStoreAttachment(paDataDir: string | null, ingestOutboundImage: IngestOutboundImage | undefined, key: string): Promise<OutboundAttachmentRef | null>;
+/** Resolve a single screenshot key to a platform-appropriate outbound
+ *  attachment: ingested store attachment for `dashboard`, native trace-file
+ *  attachment for every messaging adapter. */
+export declare function resolveScreenshotAttachment(params: {
+    platform: string;
+    key: string;
+    paDataDir: string | null;
+    ingestOutboundImage?: IngestOutboundImage;
+}): Promise<OutboundAttachmentRef | null>;

package/dist/messaging/browser-task-screenshot-attachment.js

@@ -0,0 +1,115 @@
+/**
+ * Shared resolver: turn a browser-task screenshot key
+ * (`/api/browser-task/<id>/screenshots/<file>`, the `apiPathForTraceFile`
+ * form the runner records) into a platform-appropriate outbound attachment.
+ *
+ * Three callers — the MCP notifier (`ask_user` / `finish`), the lite
+ * final-confirm sender, and the B-4 purchase sender — all need the SAME
+ * "deliver the screenshot as actual bytes, never a loopback URL" behaviour:
+ *
+ *   - `dashboard`: ingest the trace file into the chat `AttachmentStore` so
+ *     the dashboard fetches it by id through the authenticated same-origin
+ *     `/api/chat/attachments/:id` proxy and renders it inline. A raw `<img>`
+ *     pointed at the loopback trace URL would 401 — the bearer token is never
+ *     attached to an `<img>` request.
+ *   - messaging adapters (WhatsApp / Telegram / Slack / Discord): hand the
+ *     trace file straight to the adapter's native upload API. A loopback URL
+ *     is unreachable from a phone.
+ *
+ * Returns null when the key shape is unrecognised, paDataDir / the ingest
+ * hook is unwired, the extension is not a known image type, or the file is
+ * missing on disk (e.g. §14.7 retention dropped it). Callers degrade to a
+ * brief "unavailable" note or simply omit the image — never an unreachable
+ * link.
+ */
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { createLogger } from "../logging.js";
+import { resolveTraceFilePath } from "../services/browser-history/automation/trace-store-paths.js";
+const logger = createLogger("browser-task-screenshot-attachment");
+/** Matches the `apiPathForTraceFile` form. Tolerates a trailing query / hash
+ *  (none today, but keeps the parse robust if the URL shape ever grows one). */
+export const SCREENSHOT_KEY_PATTERN = /^\/api\/browser-task\/([a-f0-9-]{36})\/screenshots\/([^/?#]+)$/i;
+const IMAGE_MIME_BY_EXT = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+};
+/** Extract a log-safe message from an unknown thrown value. */
+function toErrMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Resolve a screenshot key to its on-disk trace location + image MIME, or
+ *  null when paDataDir is absent, the key shape is unrecognised, the path
+ *  normaliser rejects the inputs (defence against escapes), or the extension
+ *  is not a known image type. Pure — `resolveTraceFilePath` is path math. */
+export function resolveTraceImage(paDataDir, key) {
+    if (!paDataDir)
+        return null;
+    const match = SCREENSHOT_KEY_PATTERN.exec(key);
+    if (!match)
+        return null;
+    const taskId = match[1];
+    const fileName = match[2];
+    const absPath = resolveTraceFilePath(paDataDir, taskId, fileName);
+    if (absPath === null)
+        return null;
+    const ext = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase();
+    const mimeType = IMAGE_MIME_BY_EXT[ext];
+    if (mimeType === undefined)
+        return null;
+    return { absPath, fileName: basename(fileName), mimeType };
+}
+/** Messaging path: hand the trace file directly to the adapter's native
+ *  upload API. Null when the file is missing on disk (the caller emits an
+ *  "unavailable" note rather than a loopback URL a phone cannot reach). */
+export async function buildTraceAttachment(paDataDir, key) {
+    const resolved = resolveTraceImage(paDataDir, key);
+    if (resolved === null)
+        return null;
+    let sizeBytes;
+    try {
+        sizeBytes = (await stat(resolved.absPath)).size;
+    }
+    catch (err) {
+        logger.warn({ key, err: toErrMsg(err) }, "browser-task screenshot: trace file missing — omitted");
+        return null;
+    }
+    return {
+        id: key,
+        path: resolved.absPath,
+        originalFilename: resolved.fileName,
+        mimeType: resolved.mimeType,
+        sizeBytes,
+    };
+}
+/** Dashboard path: ingest the trace file into the `AttachmentStore` so the
+ *  dashboard can fetch it inline by id. Null when paDataDir / the ingest hook
+ *  is unwired or ingest fails. */
+export async function buildStoreAttachment(paDataDir, ingestOutboundImage, key) {
+    const resolved = resolveTraceImage(paDataDir, key);
+    if (resolved === null)
+        return null;
+    if (!ingestOutboundImage)
+        return null;
+    try {
+        return await ingestOutboundImage({
+            absPath: resolved.absPath,
+            mimeType: resolved.mimeType,
+            originalFilename: resolved.fileName,
+        });
+    }
+    catch (err) {
+        logger.warn({ key, err: toErrMsg(err) }, "browser-task screenshot: dashboard ingest failed");
+        return null;
+    }
+}
+/** Resolve a single screenshot key to a platform-appropriate outbound
+ *  attachment: ingested store attachment for `dashboard`, native trace-file
+ *  attachment for every messaging adapter. */
+export async function resolveScreenshotAttachment(params) {
+    return params.platform === "dashboard"
+        ? buildStoreAttachment(params.paDataDir, params.ingestOutboundImage, params.key)
+        : buildTraceAttachment(params.paDataDir, params.key);
+}

package/dist/messaging/constants.d.ts

@@ -30,4 +30,3 @@ export declare function getConversationScope(params: {
     scope: string;
     scopeKey: string;
 };
-//# sourceMappingURL=constants.d.ts.map

package/dist/messaging/constants.js

@@ -49,4 +49,3 @@ export function getConversationScope(params) {
         scopeKey: `${params.platform}:${params.channel}:${params.threadId ?? ""}`,
     };
 }
-//# sourceMappingURL=constants.js.map

package/dist/messaging/final-confirm-system-message-sender.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Lite-final-confirm DM dispatcher — BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11.
+ *
+ * Parallel to `purchase-system-message-sender.ts` (B-4 purchase
+ * confirmations). The two coexist because:
+ *
+ *  - B-4 dispatches "Aitne purchase confirmation" templates gated by a
+ *    per-site config + amount + currency.
+ *  - The lite path dispatches a narrower "Aitne confirmation required"
+ *    template for any irreversible action the browser-task sub-agent
+ *    flagged via the final-confirm gate — no purchase amount, no
+ *    currency, no per-site B-4 config.
+ *
+ * Both share the `!~xxxxxxxx` envelope so the messaging adapter's
+ * inbound jti-prefix dispatcher (§14.11 Q#6) can route a single reply
+ * to whichever store holds the matching token. The DM header text
+ * intentionally differs ("Aitne confirmation required" vs "Aitne
+ * purchase confirmation") so the outbound purchase-guard's marker set
+ * does not falsely flag the lite path, and so the user can tell the two
+ * apart at a glance.
+ *
+ * Structural anti-spoofing mirrors B-4: every exported method asserts
+ * the unforgeable capability symbol minted in `final-confirm-handler.ts`
+ * — an agent tool that somehow obtains a reference to this sender still
+ * cannot mint the symbol and the dispatch throws.
+ */
+import { type MessageHub } from "../adapters/message-hub.js";
+import { type IngestOutboundImage } from "./browser-task-screenshot-attachment.js";
+import { type FinalConfirmSystemMessageSender } from "../services/browser-history/automation/final-confirm-handler.js";
+import type { LiteFinalConfirmCancelReason } from "../db/browser-task-final-confirm-tokens-store.js";
+/** Header marker line distinct from B-4's `PURCHASE_CONFIRMATION_HEADER`
+ *  so the agent-facing outbound guard's deny-list cannot collide. */
+export declare const FINAL_CONFIRM_REQUEST_HEADER = "Aitne confirmation required";
+export interface CreateFinalConfirmSenderDeps {
+    messageHub: MessageHub;
+    /** Daemon data directory (`PA_DATA_DIR`). Resolves the pre-confirm
+     *  screenshot key to its on-disk trace file so the bytes are attached
+     *  inline (messaging native upload / dashboard ingest) rather than sent
+     *  as a loopback URL the user cannot reach. */
+    paDataDir?: string;
+    /** Ingest hook for the `dashboard` platform — see
+     *  `browser-task-screenshot-attachment.ts`. */
+    ingestOutboundImage?: IngestOutboundImage;
+    /** Override for tests; production uses Date.now. */
+    nowFn?: () => number;
+}
+export declare function createFinalConfirmSystemMessageSender(deps: CreateFinalConfirmSenderDeps): FinalConfirmSystemMessageSender;
+/**
+ * Human-readable cancel-reason renderer for the lite path. Mirrors
+ * `describeCancelReason` in `purchase-system-message-sender.ts` so the
+ * user sees consistent vocabulary across both surfaces.
+ */
+export declare function describeLiteFinalConfirmCancelReason(reason: LiteFinalConfirmCancelReason): string;

package/dist/messaging/final-confirm-system-message-sender.js

@@ -0,0 +1,165 @@
+/**
+ * Lite-final-confirm DM dispatcher — BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11.
+ *
+ * Parallel to `purchase-system-message-sender.ts` (B-4 purchase
+ * confirmations). The two coexist because:
+ *
+ *  - B-4 dispatches "Aitne purchase confirmation" templates gated by a
+ *    per-site config + amount + currency.
+ *  - The lite path dispatches a narrower "Aitne confirmation required"
+ *    template for any irreversible action the browser-task sub-agent
+ *    flagged via the final-confirm gate — no purchase amount, no
+ *    currency, no per-site B-4 config.
+ *
+ * Both share the `!~xxxxxxxx` envelope so the messaging adapter's
+ * inbound jti-prefix dispatcher (§14.11 Q#6) can route a single reply
+ * to whichever store holds the matching token. The DM header text
+ * intentionally differs ("Aitne confirmation required" vs "Aitne
+ * purchase confirmation") so the outbound purchase-guard's marker set
+ * does not falsely flag the lite path, and so the user can tell the two
+ * apart at a glance.
+ *
+ * Structural anti-spoofing mirrors B-4: every exported method asserts
+ * the unforgeable capability symbol minted in `final-confirm-handler.ts`
+ * — an agent tool that somehow obtains a reference to this sender still
+ * cannot mint the symbol and the dispatch throws.
+ */
+import { createLogger } from "../logging.js";
+import { MessageDeliveryError, } from "../adapters/message-hub.js";
+import { resolveScreenshotAttachment, } from "./browser-task-screenshot-attachment.js";
+import { parseChannelRef } from "../db/browser-automation-purchase-primary-channels-store.js";
+import { __aitneFinalConfirm_getCapability, } from "../services/browser-history/automation/final-confirm-handler.js";
+import { redactToken } from "../services/browser-history/automation/lite-final-confirm-tokens.js";
+const logger = createLogger("final-confirm-system-message-sender");
+/** Header marker line distinct from B-4's `PURCHASE_CONFIRMATION_HEADER`
+ *  so the agent-facing outbound guard's deny-list cannot collide. */
+export const FINAL_CONFIRM_REQUEST_HEADER = "Aitne confirmation required";
+function formatExpiry(expiresAtMs, nowMs) {
+    const remainingMs = Math.max(0, expiresAtMs - nowMs);
+    const minutes = Math.floor(remainingMs / 60000);
+    const seconds = Math.floor((remainingMs % 60000) / 1000);
+    return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+}
+export function createFinalConfirmSystemMessageSender(deps) {
+    const expected = __aitneFinalConfirm_getCapability();
+    const now = deps.nowFn ?? (() => Date.now());
+    const paDataDir = deps.paDataDir ?? null;
+    function assertCapability(received) {
+        if (received !== expected) {
+            throw new Error("final-confirm-system-message-sender: capability mismatch — refusing dispatch");
+        }
+    }
+    // The pre-confirm screenshot is delivered as actual image bytes — native
+    // upload for messaging adapters, AttachmentStore ingest for the dashboard —
+    // never a loopback trace URL (a phone cannot reach it; a raw dashboard
+    // <img> cannot authenticate it). See `browser-task-screenshot-attachment`.
+    async function dispatch(ref, text, screenshotKey) {
+        const parsed = parseChannelRef(ref);
+        if (!parsed)
+            return { ok: false, reason: "invalid_ref" };
+        let attachments;
+        if (screenshotKey) {
+            const att = await resolveScreenshotAttachment({
+                platform: parsed.platform,
+                key: screenshotKey,
+                paDataDir,
+                ingestOutboundImage: deps.ingestOutboundImage,
+            });
+            if (att)
+                attachments = [att];
+        }
+        try {
+            await deps.messageHub.sendToPlatform(parsed.platform, parsed.channelId, text, undefined, attachments);
+            return { ok: true };
+        }
+        catch (err) {
+            const reason = err instanceof MessageDeliveryError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            logger.warn({ ref, reason }, "lite-final-confirm system DM dispatch failed");
+            return { ok: false, reason };
+        }
+    }
+    return {
+        async deliverConfirmRequest(capability, input) {
+            assertCapability(capability);
+            const lines = [
+                `🔐 ${FINAL_CONFIRM_REQUEST_HEADER}`,
+                `Task: ${input.taskId}`,
+                `Action: ${input.actionSummary}`,
+                `Expires in ${formatExpiry(input.expiresAt, now())} — reply with the exact token below to confirm.`,
+                ``,
+                input.token,
+                ``,
+                `jti=${input.jti}`,
+            ].join("\n");
+            const screenshotKey = input.preScreenshotPath || undefined;
+            const delivered = [];
+            const failed = [];
+            for (const ref of input.channels) {
+                const result = await dispatch(ref, lines, screenshotKey);
+                if (result.ok)
+                    delivered.push(ref);
+                else
+                    failed.push(ref);
+            }
+            logger.info({
+                jti: input.jti,
+                taskId: input.taskId,
+                tokenRedacted: redactToken(input.token),
+                deliveredCount: delivered.length,
+                failedCount: failed.length,
+            }, "lite-final-confirm request DM dispatched");
+            return { delivered, failed };
+        },
+        async deliverPostConsumeFollowup(capability, input) {
+            assertCapability(capability);
+            const consumedMsg = `✅ Confirmed. Aitne is proceeding with the action now. jti=${input.jti}`;
+            const otherMsg = (consumedOn) => `✅ Confirmed on ${consumedOn} at ${new Date(now()).toISOString()}. No action needed here. jti=${input.jti}`;
+            for (const ref of input.deliveredChannels) {
+                const text = ref === input.consumedChannel
+                    ? consumedMsg
+                    : otherMsg(input.consumedChannel);
+                const result = await dispatch(ref, text);
+                if (!result.ok) {
+                    logger.warn({ jti: input.jti, ref, reason: result.reason }, "lite-final-confirm post-consume follow-up dispatch failed (continuing)");
+                }
+            }
+        },
+        async deliverCancellationFollowup(capability, input) {
+            assertCapability(capability);
+            const text = `⚠️ Confirmation cancelled (${describeLiteFinalConfirmCancelReason(input.reason)}). The pending action was NOT taken. jti=${input.jti}`;
+            for (const ref of input.deliveredChannels) {
+                const result = await dispatch(ref, text);
+                if (!result.ok) {
+                    logger.warn({ jti: input.jti, ref, reason: result.reason }, "lite-final-confirm cancellation follow-up dispatch failed (continuing)");
+                }
+            }
+        },
+    };
+}
+/**
+ * Human-readable cancel-reason renderer for the lite path. Mirrors
+ * `describeCancelReason` in `purchase-system-message-sender.ts` so the
+ * user sees consistent vocabulary across both surfaces.
+ */
+export function describeLiteFinalConfirmCancelReason(reason) {
+    switch (reason) {
+        case "user_reply":
+            return "you replied with non-token content";
+        case "wrong_token":
+            return "the token did not match";
+        case "wrong_channel":
+            return "the token was typed on a non-delivered channel";
+        case "timeout":
+            return "the 5-minute confirmation window elapsed";
+        case "explicit":
+            return "you issued an explicit cancel";
+        case "task_cancelled":
+            return "the parent task was cancelled or completed";
+        case "dashboard_cancel":
+            return "you clicked Cancel in the dashboard";
+    }
+}

package/dist/messaging/magic-phrase.d.ts

@@ -29,4 +29,3 @@ export declare function buildPhraseMatcher(phrase: string): (text: string) => bo
  * hint, not "phrase + one extra letter" fuzzing attempts.
  */
 export declare function isPhraseWrappedInExtraText(phrase: string, candidate: string): boolean;
-//# sourceMappingURL=magic-phrase.d.ts.map

package/dist/messaging/magic-phrase.js

@@ -53,11 +53,16 @@ const WORDS = [
     "rain", "snow", "wind", "fire",
     "wave", "hill", "rock", "dust",
 ];
+// Compile-time-ish guard: if anyone edits the word list and breaks the
+// entropy assumption above, we want to know immediately at startup. The
+// body is unreachable from tests by design — the runtime invariant is
+// the point — so mark the throw as ignored for v8 coverage rather than
+// constructing a fake-import test that doesn't add signal.
+/* c8 ignore start */
 if (WORDS.length !== 64) {
-    // Compile-time-ish guard: if anyone edits the word list and breaks the
-    // entropy assumption above, we want to know immediately at startup.
     throw new Error(`magic-phrase word list must contain exactly 64 entries (got ${WORDS.length})`);
 }
+/* c8 ignore stop */
 const PHRASE_WORD_COUNT = 4;
 /**
  * Generate a random `apple-banana-cherry-date`-style phrase. Uses
@@ -153,4 +158,3 @@ export function isPhraseWrappedInExtraText(phrase, candidate) {
         return false;
     return normalised.includes(expected);
 }
-//# sourceMappingURL=magic-phrase.js.map

package/dist/messaging/owner-channels.d.ts

@@ -40,5 +40,20 @@ export declare function getOwnerChannel(db: Database.Database, platform: string)
  *    which preserves the canonical-order tie-break
  */
 export declare function selectFirstPairedPlatform(db: Database.Database, eligible: readonly string[]): string | null;
+/**
+ * Resolve the owner's most-recently-active DM channel as
+ * `{ platform, channelId }`, or null when no owner channel is paired.
+ *
+ * Used by the browser-task originating-channel resolver as a fallback when
+ * no B-4 primary channel is registered (the common case — B-4 is opt-in /
+ * default-off): the sub-agent's `ask_user` / `finish` DMs then land on
+ * whichever channel the owner last messaged from — in practice the channel
+ * that triggered the task, since the triggering inbound DM stamps
+ * `last_inbound_at`. Ordering: most recent inbound, then most recent
+ * outbound, then earliest-paired (`rowid`) as a stable tiebreak.
+ */
+export declare function selectDefaultOwnerChannel(db: Database.Database): {
+    platform: string;
+    channelId: string;
+} | null;
 export {};
-//# sourceMappingURL=owner-channels.d.ts.map

package/dist/messaging/owner-channels.js

@@ -76,4 +76,24 @@ export function selectFirstPairedPlatform(db, eligible) {
     }
     return eligible[0];
 }
-//# sourceMappingURL=owner-channels.js.map
+/**
+ * Resolve the owner's most-recently-active DM channel as
+ * `{ platform, channelId }`, or null when no owner channel is paired.
+ *
+ * Used by the browser-task originating-channel resolver as a fallback when
+ * no B-4 primary channel is registered (the common case — B-4 is opt-in /
+ * default-off): the sub-agent's `ask_user` / `finish` DMs then land on
+ * whichever channel the owner last messaged from — in practice the channel
+ * that triggered the task, since the triggering inbound DM stamps
+ * `last_inbound_at`. Ordering: most recent inbound, then most recent
+ * outbound, then earliest-paired (`rowid`) as a stable tiebreak.
+ */
+export function selectDefaultOwnerChannel(db) {
+    const row = db
+        .prepare(`SELECT platform, channel_id
+         FROM owner_channels
+        ORDER BY COALESCE(last_inbound_at, last_outbound_at, '') DESC, rowid ASC
+        LIMIT 1`)
+        .get();
+    return row ? { platform: row.platform, channelId: row.channel_id } : null;
+}