@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/bang-commands/commands-research.js

@@ -0,0 +1,284 @@
+/**
+ * `!research` family — owner-facing bang commands for the browser
+ * history research cluster surface (BROWSER_HISTORY_INTEGRATION_PLAN
+ * §5.F1, P3 phasing).
+ *
+ * Subcommand grammar:
+ *   !research                            list active + dormant clusters
+ *   !research <slug>                     show cluster detail
+ *   !research accept <slug>              dispatch routine.research_dispatch
+ *   !research wiki <slug>                dispatch routine.research_wiki_summary
+ *   !research decline <slug>             silence offers for 14 days
+ *   !research mute <slug>                mark status=muted (offers off)
+ *   !research unmute <slug>              restore status=active
+ *   !research rename <slug> <new name>   rename display_name
+ *   !research conclude <slug>            mark status=concluded
+ *
+ * All dispatch paths route through the EventBus via
+ * `enqueueBrowserResearchEvent` on `BangCommandContext` so the bang
+ * handler stays narrow (parse → DB stamp → enqueue). The handler does
+ * NOT compose DM prose; the agent or the templated offer DM owns
+ * messaging.
+ */
+import { BangArgError } from "./registry.js";
+import { clearClusterOfferStamps, deletePendingOffersForCluster, getResearchClusterDetail, listBrowserResearchClusters, renameResearchCluster, setResearchClusterStatus, stampClusterDmFields, } from "../../db/browser-history-store.js";
+import { createResearchCommandEvent } from "../browser-history/research-events.js";
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,118}[a-z0-9]$/;
+export function parseResearchArgs(rest) {
+    const trimmed = rest.trim();
+    if (trimmed.length === 0) {
+        return { subcommand: "list", slug: null, payload: "" };
+    }
+    const firstSpace = trimmed.indexOf(" ");
+    const head = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+    const remainder = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
+    switch (head) {
+        case "accept":
+        case "wiki":
+        case "decline":
+        case "mute":
+        case "unmute":
+        case "conclude": {
+            // `String.prototype.split(/\s+/)` always returns ≥1 element (the
+            // empty string for an empty remainder), so `[0]` is never undefined.
+            const slug = remainder.split(/\s+/)[0];
+            if (!slug || !SLUG_PATTERN.test(slug)) {
+                throw new BangArgError(`Usage: \`!research ${head} <slug>\` — slug must be lowercase letters, digits, and hyphens.`);
+            }
+            return { subcommand: head, slug, payload: "" };
+        }
+        case "rename": {
+            // `!research rename <slug> <new name…>` — the new name is the
+            // remainder after the slug, free-form prose up to 120 chars.
+            const tokens = remainder.split(/\s+/);
+            const slug = tokens[0]; // split always yields ≥1 element
+            const newName = tokens.slice(1).join(" ").trim();
+            if (!slug || !SLUG_PATTERN.test(slug)) {
+                throw new BangArgError("Usage: `!research rename <slug> <new name>` — slug must be lowercase letters, digits, and hyphens.");
+            }
+            if (newName.length === 0) {
+                throw new BangArgError("Usage: `!research rename <slug> <new name>` — new name required.");
+            }
+            if (newName.length > 120) {
+                throw new BangArgError("New name must be 120 characters or fewer.");
+            }
+            return { subcommand: "rename", slug, payload: newName };
+        }
+        default: {
+            // Either `!research <slug>` (show) or an unknown subcommand.
+            if (!SLUG_PATTERN.test(head)) {
+                throw new BangArgError(`Unknown subcommand \`${head}\`. Try \`!research\` (list), \`!research <slug>\` (show), or \`!research help\`.`);
+            }
+            return { subcommand: "show", slug: head, payload: "" };
+        }
+    }
+}
+async function enqueueOrSkip(ctx, event) {
+    if (!ctx.enqueueBrowserResearchEvent) {
+        await ctx.notify("Browser-history dispatch is not wired in this daemon process.");
+        return false;
+    }
+    await ctx.enqueueBrowserResearchEvent(event);
+    return true;
+}
+async function handleList(ctx) {
+    const { clusters } = listBrowserResearchClusters(ctx.db);
+    if (clusters.length === 0) {
+        await ctx.notify("No active or dormant research clusters yet. Browse the web for a few days on a topic — Aitne will notice and surface a cluster here.");
+        return;
+    }
+    const lines = [`Research clusters (${clusters.length}):`];
+    for (const cluster of clusters.slice(0, 12)) {
+        const hours = (cluster.meaningfulForegroundSecTotal / 3600).toFixed(1);
+        lines.push(`- \`${cluster.slug}\` — ${cluster.displayName} `
+            + `(${cluster.meaningfulVisitsTotal} visits, ${hours}h, ${cluster.distinctMeaningfulDomains} domains, ${cluster.status})`);
+    }
+    if (clusters.length > 12) {
+        lines.push(`… and ${clusters.length - 12} more. Open the dashboard for the full list.`);
+    }
+    await ctx.notify(lines.join("\n"));
+}
+async function handleShow(ctx, slug) {
+    const detail = getResearchClusterDetail(ctx.db, slug);
+    if (!detail) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    const hours = (detail.meaningfulForegroundSecTotal / 3600).toFixed(1);
+    const startedDate = new Date(detail.startedAt).toISOString().slice(0, 10);
+    const lastDate = new Date(detail.lastActivityAt).toISOString().slice(0, 10);
+    await ctx.notify([
+        `\`${detail.slug}\` — ${detail.displayName} (${detail.status})`,
+        `- ${detail.meaningfulVisitsTotal} meaningful visits, ${hours}h foreground, ${detail.distinctMeaningfulDomains} domains`,
+        `- started ${startedDate}, last activity ${lastDate}`,
+        detail.researchOfferAcceptedAt
+            ? `- research_assist accepted: ${new Date(detail.researchOfferAcceptedAt).toISOString().slice(0, 10)}`
+            : null,
+        detail.wikiSummaryWrittenAt
+            ? `- wiki summary written: ${new Date(detail.wikiSummaryWrittenAt).toISOString().slice(0, 10)}`
+            : null,
+    ]
+        .filter((line) => line !== null)
+        .join("\n"));
+}
+async function handleAccept(ctx, slug) {
+    const detail = getResearchClusterDetail(ctx.db, slug);
+    if (!detail) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    // Enqueue BEFORE stamping. If the bus isn't wired (test fixture or
+    // pre-EventBus-boot path) `enqueueOrSkip` already notified — bailing
+    // here leaves the cluster row untouched so the next poller cycle can
+    // re-emit the same offer cleanly. Stamping before the enqueue used to
+    // leak state on this path (acceptedAt set, no agent session ever
+    // runs).
+    const event = createResearchCommandEvent({
+        processKey: "routine.research_dispatch",
+        slug,
+        sourceEvent: ctx.event,
+    });
+    const enqueued = await enqueueOrSkip(ctx, event);
+    if (!enqueued)
+        return;
+    const now = Date.now();
+    stampClusterDmFields(ctx.db, slug, { researchOfferAcceptedAt: now });
+    // BROWSER_HISTORY_INTEGRATION_PLAN seventh-pass — clear ALL pending
+    // rows for the slug. The seventh-pass poller inserts kind='offered'
+    // (two-option flow); deleting only the 'research_assist' row would
+    // leave the 'offered' row orphaned and silence the cluster for the
+    // 14-day TTL. P3b-era rows (kind='research_assist' / 'wiki_summary')
+    // are also cleared, matching the "acceptance closes the cycle"
+    // semantic.
+    deletePendingOffersForCluster(ctx.db, slug);
+    await ctx.notify(`Accepted research dispatch for \`${slug}\`. I'll run a parallel research dive and DM a summary when it lands.`);
+}
+async function handleWiki(ctx, slug) {
+    const detail = getResearchClusterDetail(ctx.db, slug);
+    if (!detail) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    // Stamp ordering: enqueue first (same rationale as handleAccept).
+    //
+    // We deliberately do NOT stamp `wikiSummaryWrittenAt` here. That column
+    // is the agent's "wiki note already exists" gate
+    // (`routine.research_wiki_summary.md` step 3 — "If wikiSummaryWrittenAt
+    // is present AND delta shows no new buckets since that timestamp,
+    // reply skipped"). Pre-stamping it on acceptance made the agent skip
+    // the very write the user just asked for; the actual "wiki note exists"
+    // signal is stamped by the agent itself via /wiki-written after a
+    // successful write.
+    const event = createResearchCommandEvent({
+        processKey: "routine.research_wiki_summary",
+        slug,
+        sourceEvent: ctx.event,
+    });
+    const enqueued = await enqueueOrSkip(ctx, event);
+    if (!enqueued)
+        return;
+    // BROWSER_HISTORY_INTEGRATION_PLAN seventh-pass — clear ALL pending
+    // rows for the slug (see handleAccept for the rationale; same reasoning
+    // applies to the wiki path).
+    deletePendingOffersForCluster(ctx.db, slug);
+    // Clear `lastWikiOfferAt` so the rate-limit gate's decline_backoff
+    // (which trips when BOTH options' lastXxxOfferAt are set AND neither
+    // is accepted within 30d) does not falsely silence the cluster if
+    // the wiki write fails or the agent skips the /wiki-written stamp.
+    // Mirrors the API accept handler's wiki_summary branch — both entry
+    // points must apply the same fix so natural-language and bang
+    // acceptance behave identically. See `clearClusterOfferStamps` JSDoc.
+    clearClusterOfferStamps(ctx.db, slug, { lastWikiOfferAt: true });
+    await ctx.notify(`Queued wiki summary for \`${slug}\`. I'll write it to Obsidian (or Notion / local context, whichever you have) and DM the destination.`);
+}
+async function handleDecline(ctx, slug) {
+    const detail = getResearchClusterDetail(ctx.db, slug);
+    if (!detail) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    const now = Date.now();
+    stampClusterDmFields(ctx.db, slug, {
+        lastResearchOfferAt: now,
+        lastWikiOfferAt: now,
+    });
+    deletePendingOffersForCluster(ctx.db, slug);
+    await ctx.notify(`Got it — silencing offers for \`${slug}\` for 14 days. Cluster journal updates continue silently; the cluster will re-qualify after another 14 days of activity.`);
+}
+async function handleMute(ctx, slug) {
+    const updated = setResearchClusterStatus(ctx.db, slug, "muted");
+    if (!updated) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    deletePendingOffersForCluster(ctx.db, slug);
+    await ctx.notify(`Muted \`${slug}\`. No more DM offers; \`!research unmute ${slug}\` to restore.`);
+}
+async function handleUnmute(ctx, slug) {
+    const updated = setResearchClusterStatus(ctx.db, slug, "active");
+    if (!updated) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    await ctx.notify(`Unmuted \`${slug}\`. Normal offer cadence restored.`);
+}
+async function handleConclude(ctx, slug) {
+    const updated = setResearchClusterStatus(ctx.db, slug, "concluded");
+    if (!updated) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    deletePendingOffersForCluster(ctx.db, slug);
+    await ctx.notify(`Concluded \`${slug}\`. The cluster journal at \`context/research/${slug}.md\` is preserved.`);
+}
+async function handleRename(ctx, slug, newName) {
+    const updated = renameResearchCluster(ctx.db, slug, newName);
+    if (!updated) {
+        await ctx.notify(`No cluster \`${slug}\` found.`);
+        return;
+    }
+    await ctx.notify(`Renamed \`${slug}\` → ${newName}.`);
+}
+export const researchCommand = {
+    prefix: "!research",
+    title: "Research clusters",
+    describe: "manage browser-history research clusters (list / show / accept / wiki / decline / mute / unmute / rename / conclude)",
+    details: [
+        "Subcommands:",
+        "- `!research` — list active clusters",
+        "- `!research <slug>` — show cluster detail",
+        "- `!research accept <slug>` — agree to a research_assist offer",
+        "- `!research wiki <slug>` — agree to a wiki summary offer",
+        "- `!research decline <slug>` — silence offers for 14 days",
+        "- `!research mute <slug>` — silence all offers (until unmute)",
+        "- `!research unmute <slug>` — restore offers",
+        "- `!research rename <slug> <new name>` — change display name",
+        "- `!research conclude <slug>` — mark cluster concluded",
+    ],
+    parseArgs(rest) {
+        return parseResearchArgs(rest);
+    },
+    async handler(ctx, rawArgs) {
+        const args = rawArgs;
+        switch (args.subcommand) {
+            case "list":
+                return handleList(ctx);
+            case "show":
+                return handleShow(ctx, args.slug);
+            case "accept":
+                return handleAccept(ctx, args.slug);
+            case "wiki":
+                return handleWiki(ctx, args.slug);
+            case "decline":
+                return handleDecline(ctx, args.slug);
+            case "mute":
+                return handleMute(ctx, args.slug);
+            case "unmute":
+                return handleUnmute(ctx, args.slug);
+            case "rename":
+                return handleRename(ctx, args.slug, args.payload);
+            case "conclude":
+                return handleConclude(ctx, args.slug);
+        }
+    },
+};

package/dist/core/bang-commands/commands-stop-start.d.ts

@@ -1,4 +1,3 @@
 import type { BangCommand } from "./registry.js";
 export declare const stopCommand: BangCommand;
 export declare const startCommand: BangCommand;
-//# sourceMappingURL=commands-stop-start.d.ts.map

package/dist/core/bang-commands/commands-stop-start.js

@@ -87,4 +87,3 @@ export const startCommand = {
         ].join("\n"));
     },
 };
-//# sourceMappingURL=commands-stop-start.js.map

package/dist/core/bang-commands/commands-wiki.d.ts

@@ -72,4 +72,3 @@ export declare const connectCommand: BangPrefixCommand;
  */
 export declare function formatCompilePreview(preview: import("@aitne/shared").WikiCompilePreview): string;
 export {};
-//# sourceMappingURL=commands-wiki.d.ts.map

package/dist/core/bang-commands/commands-wiki.js

@@ -179,12 +179,23 @@ export const compileCommand = {
                 await ctx.notify(renderCompileInProgressDm(lock.holder, workspace.name));
                 return;
             }
-            const queued = await enqueueOrNotify(ctx, createWikiCommandEvent({
-                processKey: "wiki.compile",
-                workspace: workspace.name,
-                sourceEvent: ctx.event,
-                data: { mode: "incremental" },
-            }));
+            let queued = false;
+            try {
+                queued = await enqueueOrNotify(ctx, createWikiCommandEvent({
+                    processKey: "wiki.compile",
+                    workspace: workspace.name,
+                    sourceEvent: ctx.event,
+                    data: { mode: "incremental" },
+                }));
+            }
+            catch (err) {
+                // Any throw here (event bus full, notify failure) leaves the
+                // dispatcher's `finally` unreached because no event ever
+                // enqueued. Without this release, the lock TTL of 1h blocks all
+                // subsequent compiles for the workspace.
+                releaseWikiCompileLock(workspace.name);
+                throw err;
+            }
             if (queued) {
                 await ctx.notify(`Queued incremental wiki compile for workspace \`${workspace.name}\`.`);
             }
@@ -276,9 +287,20 @@ export const compileCommand = {
         // attribution map before GitWatcher's next poll cycle observes it
         // (C1) — closes the daemon-side self-trigger loop where the wiki
         // pre-compile commit would otherwise feed back as user activity.
-        const gitOutcome = await runGitPreCompile(workspace, {
-            writeTracker: ctx.writeTracker,
-        });
+        //
+        // From here on we hold the compile lock; any throw before the event
+        // is enqueued must release it (the dispatcher's `finally` won't fire
+        // because no event ever reached the queue).
+        let gitOutcome;
+        try {
+            gitOutcome = await runGitPreCompile(workspace, {
+                writeTracker: ctx.writeTracker,
+            });
+        }
+        catch (err) {
+            releaseWikiCompileLock(workspace.name);
+            throw err;
+        }
         if (gitOutcome.status === "refused") {
             // Extremely narrow race: the tree turned dirty between preview and
             // commit (e.g. a parallel `!ingest` writing to `10_raw/`). Surface and
@@ -295,12 +317,19 @@ export const compileCommand = {
         if (gitOutcome.status === "committed") {
             lines.push(`- pre-compile git commit: ${gitOutcome.commitSha.slice(0, 7)}`);
         }
-        const queued = await enqueueOrNotify(ctx, createWikiCommandEvent({
-            processKey: "wiki.compile",
-            workspace: workspace.name,
-            sourceEvent: ctx.event,
-            data: { mode: "full", estimate, git: gitOutcome },
-        }));
+        let queued = false;
+        try {
+            queued = await enqueueOrNotify(ctx, createWikiCommandEvent({
+                processKey: "wiki.compile",
+                workspace: workspace.name,
+                sourceEvent: ctx.event,
+                data: { mode: "full", estimate, git: gitOutcome },
+            }));
+        }
+        catch (err) {
+            releaseWikiCompileLock(workspace.name);
+            throw err;
+        }
         if (queued) {
             await ctx.notify([
                 ...lines,
@@ -582,4 +611,3 @@ function formatDuration(seconds) {
     const s = seconds % 60;
     return s === 0 ? `${m}m` : `${m}m ${s}s`;
 }
-//# sourceMappingURL=commands-wiki.js.map

package/dist/core/bang-commands/format-utils.d.ts

@@ -9,7 +9,8 @@ import type { AgentConfig } from "../../config.js";
  * WhatsApp/Telegram/Discord/Slack message caps. See §6.5 rule 8.
  */
 export declare const MOBILE_REPLY_BUDGET = 1500;
-/** First-line marker (I-10). */
+/** Prefix every SYSTEM-origin reply with this marker so the agent can
+ *  recognize its own output on round-trip. */
 export declare function buildSystemMarker(command: string, window?: string): string;
 /**
  * Inject the `[SYSTEM · …]` marker as the first line if the supplied text
@@ -43,4 +44,3 @@ export declare function formatLocalShort(isoOrSqlite: string, config: AgentConfi
  * timezone — used by `!stop`/`!start` where the calendar year matters.
  */
 export declare function formatLocalLong(iso: string, config: AgentConfig): string;
-//# sourceMappingURL=format-utils.d.ts.map

package/dist/core/bang-commands/format-utils.js

@@ -3,7 +3,8 @@
  * WhatsApp/Telegram/Discord/Slack message caps. See §6.5 rule 8.
  */
 export const MOBILE_REPLY_BUDGET = 1500;
-/** First-line marker (I-10). */
+/** Prefix every SYSTEM-origin reply with this marker so the agent can
+ *  recognize its own output on round-trip. */
 export function buildSystemMarker(command, window) {
     return window
         ? `[SYSTEM · ${command} · ${window}]`
@@ -134,4 +135,3 @@ function parseTimestampMs(value) {
     const ms = Date.parse(candidate);
     return Number.isFinite(ms) ? ms : null;
 }
-//# sourceMappingURL=format-utils.js.map

package/dist/core/bang-commands/index.d.ts

@@ -11,6 +11,8 @@ export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered,
 export { reportCommand, formatReport } from "./commands-report.js";
 export { helpCommand, formatHelp } from "./commands-help.js";
 export { askCommand, connectCommand, compileCommand, lintCommand, parseConnectArgs, traceCommand, ingestCommand, wikiHelpCommand, wikiStatusCommand, } from "./commands-wiki.js";
+export { researchCommand, parseResearchArgs } from "./commands-research.js";
+export { checksCommand, formatChecks } from "./commands-checks.js";
 export { buildSystemMarker, ensureSystemMarker, formatLocalLong, formatLocalShort, formatMoney, MOBILE_REPLY_BUDGET, truncateForMobile, } from "./format-utils.js";
 export { CUSTOM_BANG_COMMAND_SOURCE, DEFAULT_USER_BANG_COMMAND_SKILLS, USER_BANG_COMMAND_NAME_PATTERN, buildUserBangCommandPrompt, createUserBangCommand, createUserBangCommandEvent, deleteUserBangCommand, getEnabledUserBangCommandByCommand, getUserBangCommandByCommand, getUserBangCommandById, listUserBangCommands, normalizeBangCommandName, parseEnabledSkills, resolveCommandSkillSlugs, serializeEnabledSkills, updateUserBangCommand, } from "./user-commands.js";
 export type { NormalizeBangCommandNameResult, UserBangCommand, UserBangCommandInput, } from "./user-commands.js";
@@ -20,4 +22,3 @@ import { BangCommandRegistry } from "./registry.js";
  * is mutable — callers can `.register(...)` more commands afterwards.
  */
 export declare function createDefaultBangCommandRegistry(): BangCommandRegistry;
-//# sourceMappingURL=index.d.ts.map

package/dist/core/bang-commands/index.js

@@ -10,6 +10,8 @@ export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered,
 export { reportCommand, formatReport } from "./commands-report.js";
 export { helpCommand, formatHelp } from "./commands-help.js";
 export { askCommand, connectCommand, compileCommand, lintCommand, parseConnectArgs, traceCommand, ingestCommand, wikiHelpCommand, wikiStatusCommand, } from "./commands-wiki.js";
+export { researchCommand, parseResearchArgs } from "./commands-research.js";
+export { checksCommand, formatChecks } from "./commands-checks.js";
 export { buildSystemMarker, ensureSystemMarker, formatLocalLong, formatLocalShort, formatMoney, MOBILE_REPLY_BUDGET, truncateForMobile, } from "./format-utils.js";
 export { CUSTOM_BANG_COMMAND_SOURCE, DEFAULT_USER_BANG_COMMAND_SKILLS, USER_BANG_COMMAND_NAME_PATTERN, buildUserBangCommandPrompt, createUserBangCommand, createUserBangCommandEvent, deleteUserBangCommand, getEnabledUserBangCommandByCommand, getUserBangCommandByCommand, getUserBangCommandById, listUserBangCommands, normalizeBangCommandName, parseEnabledSkills, resolveCommandSkillSlugs, serializeEnabledSkills, updateUserBangCommand, } from "./user-commands.js";
 import { BangCommandRegistry } from "./registry.js";
@@ -19,6 +21,8 @@ import { costAllCommand, costBackendCommands, } from "./commands-cost.js";
 import { reportCommand } from "./commands-report.js";
 import { helpCommand } from "./commands-help.js";
 import { askCommand, connectCommand, compileCommand, lintCommand, traceCommand, ingestCommand, wikiHelpCommand, wikiStatusCommand, } from "./commands-wiki.js";
+import { researchCommand } from "./commands-research.js";
+import { checksCommand } from "./commands-checks.js";
 /**
  * Build a registry preloaded with the v1 built-in commands. The registry
  * is mutable — callers can `.register(...)` more commands afterwards.
@@ -43,6 +47,12 @@ export function createDefaultBangCommandRegistry() {
     registry.register(lintCommand);
     registry.register(traceCommand);
     registry.register(connectCommand);
+    // BROWSER_HISTORY_INTEGRATION_PLAN P3 — `!research` family.
+    registry.register(researchCommand);
+    // BROWSER_HISTORY_INTEGRATION_PLAN P4b — `!checks` (F4 reload-memory
+    // pull surface). Pure DB read on `browser_reload_signals`; the F4
+    // weekly surfacing lives inside `routine.weekly_review` and uses
+    // `/api/browser-history/reloads/weekly` instead.
+    registry.register(checksCommand);
     return registry;
 }
-//# sourceMappingURL=index.js.map

package/dist/core/bang-commands/registry.d.ts

@@ -53,6 +53,15 @@ export interface BangCommandContext {
     }>;
     enqueueUserBangCommand?: (command: UserBangCommand, event: MessageEvent) => Promise<void>;
     enqueueWikiEvent?: (event: Event) => Promise<void>;
+    /**
+     * BROWSER_HISTORY_INTEGRATION_PLAN P3 — wire-through for the
+     * `!research accept` / `!research wiki` paths. The bang handler
+     * constructs an Event via `createResearchCommandEvent` and the
+     * dispatcher-message-handler binds this callback to
+     * `await this.eventBus.put(event)`. Optional so unit-test fixtures
+     * without an EventBus can still exercise list / show / mute / rename.
+     */
+    enqueueBrowserResearchEvent?: (event: Event) => Promise<void>;
     /**
      * Approval handoff for `!compile full` when the cost estimate exceeds
      * the per-workspace threshold (WIKI_BUILDER_DESIGN.md §5.5). Inserts
@@ -162,4 +171,3 @@ export declare function makeNotify(rawSend: (text: string) => Promise<void>, fal
 export declare function tryHandle(registry: BangCommandRegistry, ctx: Omit<BangCommandContext, "notify" | "registry"> & {
     rawSend: (text: string) => Promise<void>;
 }): Promise<boolean>;
-//# sourceMappingURL=registry.d.ts.map

package/dist/core/bang-commands/registry.js

@@ -156,7 +156,7 @@ export async function tryHandle(registry, ctx) {
     const { event, db, audit, rawSend } = ctx;
     if (event.source === CUSTOM_BANG_COMMAND_SOURCE)
         return false;
-    // I-1: only DMs participate. Adapter-side owner gating is the single
+    // Only DMs participate. Adapter-side owner gating is the single
     // source of truth (matches the `/auth` precedent — see design §6.3).
     if (!event.isDm)
         return false;
@@ -169,7 +169,7 @@ export async function tryHandle(registry, ctx) {
     const isBang = lowered.startsWith("!");
     const paused = isUserPaused(db);
     // §6.3 pause branch — runs BEFORE the bang-prefix check so ANY DM while
-    // paused short-circuits without reaching the agent backend (I-3).
+    // paused short-circuits without reaching the agent backend.
     //
     // We use the full `resolve()` matcher (exact + prefix) rather than the
     // exact-only `match()`. Without this, every `BangPrefixCommand` (e.g.
@@ -208,10 +208,11 @@ export async function tryHandle(registry, ctx) {
                         closeActiveDmSession: ctx.closeActiveDmSession,
                         enqueueUserBangCommand: ctx.enqueueUserBangCommand,
                         enqueueWikiEvent: ctx.enqueueWikiEvent,
+                        enqueueBrowserResearchEvent: ctx.enqueueBrowserResearchEvent,
                         enqueueWikiApproval: ctx.enqueueWikiApproval,
                     };
-                    // P2-24: stamp the wall-clock the handler started so we can
-                    // back-fill runMs into the audit row on success/failure.
+                    // Stamp the wall-clock the handler started so we can back-fill
+                    // runMs into the audit row on success/failure.
                     const startedAtMs = Date.now();
                     try {
                         const args = match.kind === "prefix" && "prefix" in match.command
@@ -299,7 +300,7 @@ export async function tryHandle(registry, ctx) {
     if (!isBang)
         return false;
     // §7 spoof guard: a multi-line message that happens to start with `!stop`
-    // is "treated as agent input" — bang-command parsing is exact-match (I-2),
+    // is "treated as agent input" — bang-command parsing is exact-match,
     // so anything spanning newlines never produces a registry hit and must
     // fall through to the agent path instead of emitting the unknown-bang
     // help. Mirrors the intent of "Avoids spoofing by users embedding
@@ -320,9 +321,16 @@ export async function tryHandle(registry, ctx) {
             closeActiveDmSession: ctx.closeActiveDmSession,
             enqueueUserBangCommand: ctx.enqueueUserBangCommand,
             enqueueWikiEvent: ctx.enqueueWikiEvent,
+            // BROWSER_HISTORY_INTEGRATION_PLAN P3 — `!research accept|wiki` rely
+            // on this wire. The paused branch above forwards it too but never
+            // executes the LLM-dispatching variant (`!research` isn't
+            // `runsWhilePaused`); production runs land here, so omitting the
+            // forward turned every accept/wiki bang into "dispatch not wired"
+            // even when the dispatcher-message-handler caller had supplied it.
+            enqueueBrowserResearchEvent: ctx.enqueueBrowserResearchEvent,
             enqueueWikiApproval: ctx.enqueueWikiApproval,
         };
-        // P2-24: stamp wall-clock start so audit rows carry runMs.
+        // Stamp wall-clock start so audit rows carry runMs.
         const startedAtMs = Date.now();
         try {
             const args = match.kind === "prefix" && "prefix" in match.command
@@ -386,4 +394,3 @@ export async function tryHandle(registry, ctx) {
     ]));
     return true;
 }
-//# sourceMappingURL=registry.js.map

package/dist/core/bang-commands/user-commands.d.ts

@@ -83,4 +83,3 @@ export declare function serializeEnabledSkills(skills: readonly string[] | null
  * (it falls back to the default skill set).
  */
 export declare function parseEnabledSkills(raw: string | null): string[] | null;
-//# sourceMappingURL=user-commands.d.ts.map

package/dist/core/bang-commands/user-commands.js

@@ -209,4 +209,3 @@ function normalizeInstructionMd(value) {
     const trimmed = value.trim();
     return trimmed.length === 0 ? null : trimmed;
 }
-//# sourceMappingURL=user-commands.js.map

package/dist/core/browser-history/pre-morning-digest-job.d.ts

@@ -0,0 +1,79 @@
+import type Database from "better-sqlite3";
+import { type DigestBoundary } from "../../services/browser-history/pipeline/pre-morning-digest.js";
+import { type PreMorningDigest } from "@aitne/shared";
+/**
+ * Daemon-side wrapper around the pure digest builder. Three roles:
+ *
+ *  1. `runPreMorningDigestJob` — called by the scheduler at
+ *     `dayBoundaryHour − 1` (BROWSER_HISTORY_INTEGRATION_PLAN §5.F2
+ *     Stage 1). Builds the digest for the agent-day that's just about
+ *     to end and writes `<contextDir>/browser/yesterday-<date>.md`
+ *     plus a JSON sidecar (`yesterday-<date>.json`) so the API route
+ *     can return the exact same payload the journal sees, without
+ *     parsing markdown back into Zod-validated JSON.
+ *
+ *  2. `readPreMorningDigestJsonForDate` — used by the API route. Reads
+ *     the JSON sidecar when present; returns null otherwise. The route
+ *     then falls back to building fresh from the DB.
+ *
+ *  3. `digestDate` / `digestPaths` — small helpers exported for tests
+ *     and the cron call site to share a single source of truth for the
+ *     filename layout.
+ *
+ * The job is intentionally fire-and-forget: a build / write failure
+ * logs loudly and never re-throws. The morning journal's task-flow
+ * tolerates a missing digest by calling
+ * `GET /api/browser-history/pre-morning-digest/{date}` as the
+ * documented fallback (§5.F2 Stage 2). Either path satisfies the
+ * journal's contract; the file path is the primary one because it
+ * pre-warms the morning context window without a network hop.
+ */
+export interface PreMorningDigestPaths {
+    /** Absolute path to the markdown file the journal reads. */
+    markdownPath: string;
+    /** Absolute path to the parallel JSON sidecar the API serves. */
+    jsonPath: string;
+    /**
+     * The `<path>` portion of `PUT /api/context/<path>.md` — useful for
+     * task-flow strings and log lines that need a stable agent-facing
+     * reference, independent of the on-disk `contextDir`.
+     */
+    contextRelative: string;
+}
+export declare function digestPaths(contextDir: string, dateStr: string): PreMorningDigestPaths;
+export interface RunPreMorningDigestJobArgs {
+    readonly db: Database.Database;
+    readonly contextDir: string;
+    readonly boundary: DigestBoundary;
+    /** Override `Date.now()` for tests and the API on-demand path. */
+    readonly nowMs?: number;
+}
+export interface RunPreMorningDigestJobResult {
+    readonly date: string;
+    readonly paths: PreMorningDigestPaths;
+    readonly digest: PreMorningDigest;
+}
+/**
+ * Build + persist the digest for the agent-day "now" is inside of.
+ * Returns the typed digest so callers (the API route's
+ * rebuild-on-demand path, tests) can use the same code shape as the
+ * cron call site.
+ */
+export declare function runPreMorningDigestJob(args: RunPreMorningDigestJobArgs): RunPreMorningDigestJobResult;
+/**
+ * Read the JSON sidecar for the given agent-day, Zod-validate it, and
+ * return the typed digest. Returns null when the file is missing or
+ * the bytes do not parse — the API caller can then rebuild fresh.
+ *
+ * Validation matters here: the journal Stage B task-flow trusts the
+ * file's schema invariants (no raw URLs / titles). Returning unvetted
+ * JSON would let a corrupt sidecar bypass that boundary.
+ */
+export declare function readPreMorningDigestJsonForDate(contextDir: string, dateStr: string): PreMorningDigest | null;
+/**
+ * Wrapper safe to register as a fire-and-forget cron callback. Catches
+ * every error so a transient SQL failure or filesystem hiccup cannot
+ * crash the scheduler's cron tick. Returns the result for callers that
+ * want to inspect outcomes (tests / dashboards / future audit hooks).
+ */
+export declare function safeRunPreMorningDigestJob(args: RunPreMorningDigestJobArgs): RunPreMorningDigestJobResult | null;