@aitne/daemon 0.1.7 → 0.1.9

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

@@ -16,6 +16,7 @@ export const stopCommand = {
         "Does not abort in-flight backend sessions.",
         "While paused, non-command DMs are declined without LLM cost.",
     ],
+    runsWhilePaused: true,
     handler: async (ctx) => {
         const prev = getUserPaused(ctx.db);
         if (prev) {
@@ -64,6 +65,7 @@ export const startCommand = {
         "Clears the user-paused state.",
         "Queued observations are consumed by the next eligible hourly check.",
     ],
+    runsWhilePaused: true,
     handler: async (ctx) => {
         const prev = getUserPaused(ctx.db);
         if (!prev) {
@@ -85,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}\`.`);
             }
@@ -272,7 +283,24 @@ export const compileCommand = {
             await ctx.notify(renderCompileInProgressDm(lock.holder, workspace.name));
             return;
         }
-        const gitOutcome = await runGitPreCompile(workspace);
+        // Forward the tracker so the snapshot SHA is registered with the
+        // 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.
+        //
+        // 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
@@ -289,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,
@@ -349,6 +384,9 @@ export const wikiStatusCommand = {
     name: "!wiki",
     title: "Wiki status",
     describe: "show wiki workspace status (one line per active workspace)",
+    // Pure DB read — safe to run while the agent is paused so the user can
+    // inspect workspace shape without resuming autonomous work.
+    runsWhilePaused: true,
     async handler(ctx) {
         if (!isWikiEnabled(ctx.db)) {
             await ctx.notify("Wiki is not enabled. Open `/settings/wiki` to enable the internal workspace.");
@@ -392,6 +430,8 @@ export const wikiHelpCommand = {
     name: "!wiki help",
     title: "Wiki help",
     describe: "show wiki command help",
+    // Static help text — no DB / LLM. Mirrors `!help` semantics.
+    runsWhilePaused: true,
     async handler(ctx) {
         await ctx.notify([
             "Wiki commands:",
@@ -571,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
@@ -17,7 +18,19 @@ export declare function buildSystemMarker(command: string, window?: string): str
  * forget to prepend the marker still produce well-formed output.
  */
 export declare function ensureSystemMarker(text: string, marker: string): string;
-/** Truncate a reply that exceeds the mobile budget, appending a footer. */
+/** Truncate a reply that exceeds the mobile budget, appending a footer.
+ *
+ * UTF-16 surrogate safety: a naive `text.slice(...)` slice that lands
+ * between a high surrogate (0xD800-0xDBFF) and its trailing low surrogate
+ * tears the pair. The orphan renders as U+FFFD on every platform and
+ * Slack/Telegram/Discord reject the payload outright if the broken pair
+ * happens to be the last code unit. Bang-reply text routinely carries
+ * non-BMP code points (emoji, CJK extension B+) when the agent quotes
+ * user input, so this is hit in practice. The fix mirrors
+ * `splitOutboundText`'s B-2 backoff: if the boundary lands directly
+ * after a high surrogate, step back by one code unit so the pair stays
+ * intact in the truncated chunk.
+ */
 export declare function truncateForMobile(text: string): string;
 /** Compact USD formatter — `$1.42`, `$0.08`, `<$0.01`. */
 export declare function formatMoney(usd: number): string;
@@ -31,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}]`
@@ -19,12 +20,31 @@ export function ensureSystemMarker(text, marker) {
         return text;
     return `${marker}\n${text}`;
 }
-/** Truncate a reply that exceeds the mobile budget, appending a footer. */
+/** Truncate a reply that exceeds the mobile budget, appending a footer.
+ *
+ * UTF-16 surrogate safety: a naive `text.slice(...)` slice that lands
+ * between a high surrogate (0xD800-0xDBFF) and its trailing low surrogate
+ * tears the pair. The orphan renders as U+FFFD on every platform and
+ * Slack/Telegram/Discord reject the payload outright if the broken pair
+ * happens to be the last code unit. Bang-reply text routinely carries
+ * non-BMP code points (emoji, CJK extension B+) when the agent quotes
+ * user input, so this is hit in practice. The fix mirrors
+ * `splitOutboundText`'s B-2 backoff: if the boundary lands directly
+ * after a high surrogate, step back by one code unit so the pair stays
+ * intact in the truncated chunk.
+ */
 export function truncateForMobile(text) {
     if (text.length <= MOBILE_REPLY_BUDGET)
         return text;
     const footer = "\n… (truncated)";
-    return text.slice(0, MOBILE_REPLY_BUDGET - footer.length) + footer;
+    let cut = MOBILE_REPLY_BUDGET - footer.length;
+    if (cut > 0 && isHighSurrogate(text.charCodeAt(cut - 1))) {
+        cut -= 1;
+    }
+    return text.slice(0, cut) + footer;
+}
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
 }
 /** Compact USD formatter — `$1.42`, `$0.08`, `<$0.01`. */
 export function formatMoney(usd) {
@@ -115,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

@@ -6,10 +6,13 @@
 export { BangCommandRegistry, BangArgError, buildPausedNotice, buildUnknownCommandReply, getBangCommandName, makeNotify, normalizeBangCommandText, tryHandle, } from "./registry.js";
 export type { BangCommand, BangCommandContext, BangCommandMatch, BangPrefixCommand, RegisteredBangCommand, } from "./registry.js";
 export { stopCommand, startCommand } from "./commands-stop-start.js";
+export { closeCommand } from "./commands-close.js";
 export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered, } from "./commands-cost.js";
 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";
@@ -19,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

@@ -5,18 +5,24 @@
  */
 export { BangCommandRegistry, BangArgError, buildPausedNotice, buildUnknownCommandReply, getBangCommandName, makeNotify, normalizeBangCommandText, tryHandle, } from "./registry.js";
 export { stopCommand, startCommand } from "./commands-stop-start.js";
+export { closeCommand } from "./commands-close.js";
 export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered, } from "./commands-cost.js";
 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";
 import { startCommand, stopCommand } from "./commands-stop-start.js";
+import { closeCommand } from "./commands-close.js";
 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.
@@ -25,6 +31,7 @@ export function createDefaultBangCommandRegistry() {
     const registry = new BangCommandRegistry();
     registry.register(stopCommand);
     registry.register(startCommand);
+    registry.register(closeCommand);
     registry.register(costAllCommand);
     for (const cmd of costBackendCommands) {
         registry.register(cmd);
@@ -40,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