@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/bang-commands/commands-revert-tuning.js

@@ -0,0 +1,63 @@
+/**
+ * `!revert tuning` — undo the most recent applied self-tuning config change
+ * (SELF_TUNING_REVIEW_CYCLE_DESIGN.md §3.4, Phase 3).
+ *
+ * The owner-side escape hatch for the Autonomous-plus-DM actuation posture
+ * (D1): every applied change DMs "Reply `!revert tuning` to undo", and this
+ * command is that reply. It restores the ledger's `prev` value through the
+ * same `applyConfigUpdates` chokepoint the actuator used, stamps
+ * `reverted_at` (which puts the key into the 28-day re-proposal cool-down),
+ * audits `self_tuning.reverted`, and records an explicit-correction
+ * feedback signal so the lesson loop learns from the owner's override.
+ *
+ * `runsWhilePaused: true` — a pure DB/config write with no LLM dispatch,
+ * and the owner may well have paused the agent *because* of a bad tuning
+ * change; the undo must not be locked behind `!start`.
+ */
+import { BangArgError } from "./registry.js";
+import { applyConfigUpdates } from "../../api/env-writer.js";
+import { createSettingsStore } from "../../settings/settings-store.js";
+import { findLatestRevertableEntry, listLedgerEntries, revertAppliedTuningChange, } from "../feedback/tuning-actuator.js";
+const USAGE = "Usage: `!revert tuning` — undo the most recent self-tuning config change.";
+export const revertTuningCommand = {
+    prefix: "!revert",
+    title: "Revert self-tuning",
+    describe: "undo the most recent self-tuning config change",
+    details: [
+        "Restores the previous value of the most recently applied self-tuning config change via the standard config chokepoint.",
+        "The reverted key enters a 28-day re-proposal cool-down so the loop cannot immediately re-apply it.",
+        "Pure DB/config write — works while the agent is paused.",
+    ],
+    runsWhilePaused: true,
+    parseArgs: (rest) => {
+        if (rest.toLowerCase() !== "tuning") {
+            throw new BangArgError(USAGE);
+        }
+        return undefined;
+    },
+    handler: async (ctx) => {
+        const entry = findLatestRevertableEntry(listLedgerEntries(ctx.db));
+        if (!entry) {
+            await ctx.notify("No applied self-tuning change to revert. Applied changes show up in the daemon's per-change DM and the weekly review's tuning ledger.");
+            return;
+        }
+        const settingsStore = createSettingsStore(ctx.db);
+        const result = await revertAppliedTuningChange({
+            db: ctx.db,
+            applyUpdates: (updates) => applyConfigUpdates(ctx.config, settingsStore, updates, { db: ctx.db }),
+            feedbackLearningEnabled: ctx.config.feedbackLearningEnabled,
+        }, entry, {
+            trigger: "bang_command",
+            reason: "owner requested revert via !revert tuning",
+            now: new Date(),
+        });
+        if (!result.ok) {
+            await ctx.notify(`Could not revert ${entry.key}: ${result.error}`);
+            return;
+        }
+        await ctx.notify(`Reverted ${entry.key} ${String(entry.blob.proposed)} → ` +
+            `${String(entry.blob.prev)} (rule ${entry.blob.rule}, applied ` +
+            `${entry.blob.applied_at.slice(0, 10)}). The key is now in a ` +
+            "28-day re-proposal cool-down.");
+    },
+};

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

@@ -45,7 +45,7 @@ export const stopCommand = {
             "",
             "Halted:",
             "- Morning / evening / weekly / monthly review",
-            "- Hourly check, profile sweep",
+            "- Activity scan, profile sweep",
             "- Scheduled DMs",
             "",
             "Still running:",
@@ -63,7 +63,7 @@ export const startCommand = {
     describe: "Resume autonomous work paused by !stop.",
     details: [
         "Clears the user-paused state.",
-        "Queued observations are consumed by the next eligible hourly check.",
+        "Queued observations are consumed by the next eligible activity scan.",
     ],
     runsWhilePaused: true,
     handler: async (ctx) => {
@@ -82,7 +82,7 @@ export const startCommand = {
             "",
             `Was paused: ${formatLocalLong(prev.since, ctx.config)}`,
             "",
-            "Next hourly check will consume any observations",
+            "Next activity scan will consume any observations",
             "queued during the pause.",
         ].join("\n"));
     },

package/dist/core/bang-commands/commands-task-control.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Per-task control bang-commands — `!status` (list the active detached
+ * tasks) and `!stop <id>` (cancel one of them). BACKGROUND_TASK_RUNNER_
+ * DESIGN.md Phase 4.
+ *
+ * Both run OUTSIDE the SessionGate (the bang interceptor in
+ * `dispatcher-message-handler` runs before any agent backend, ahead of
+ * the gate), so the owner can inspect and cancel a long-running worker
+ * even while a DM turn is in flight or a delivery turn is gated. Both are
+ * `runsWhilePaused: true` — pure DB reads + a runner abort, no LLM work.
+ *
+ * `!stop` is a PREFIX command. Bare `!stop` resolves to the exact-match
+ * pause command (`commands-stop-start.ts`); `!stop <id>` falls through to
+ * the prefix matcher here and cancels that single task. The two never
+ * collide because the registry resolves exact matches before prefixes.
+ */
+import type { BangCommand, BangPrefixCommand } from "./registry.js";
+export declare const statusCommand: BangCommand;
+export declare const stopTaskCommand: BangPrefixCommand;

package/dist/core/bang-commands/commands-task-control.js

@@ -0,0 +1,147 @@
+/**
+ * Per-task control bang-commands — `!status` (list the active detached
+ * tasks) and `!stop <id>` (cancel one of them). BACKGROUND_TASK_RUNNER_
+ * DESIGN.md Phase 4.
+ *
+ * Both run OUTSIDE the SessionGate (the bang interceptor in
+ * `dispatcher-message-handler` runs before any agent backend, ahead of
+ * the gate), so the owner can inspect and cancel a long-running worker
+ * even while a DM turn is in flight or a delivery turn is gated. Both are
+ * `runsWhilePaused: true` — pure DB reads + a runner abort, no LLM work.
+ *
+ * `!stop` is a PREFIX command. Bare `!stop` resolves to the exact-match
+ * pause command (`commands-stop-start.ts`); `!stop <id>` falls through to
+ * the prefix matcher here and cancels that single task. The two never
+ * collide because the registry resolves exact matches before prefixes.
+ */
+import { getBackgroundTask, listBackgroundTasks, } from "../../db/background-task-store.js";
+import { getBrowserTask, listBrowserTasks, } from "../../db/browser-task-store.js";
+const BACKGROUND_ACTIVE_STATES = ["pending", "running", "awaiting_user"];
+const BROWSER_ACTIVE_STATES = [
+    "pending",
+    "running",
+    "awaiting_user",
+    "final_confirm",
+];
+function backgroundTitle(row) {
+    return row.title ?? row.brief.slice(0, 60);
+}
+function browserTitle(row) {
+    return row.description.slice(0, 60);
+}
+/** Gather every non-terminal background + browser task, newest first. */
+function listActiveTasks(ctx) {
+    const background = listBackgroundTasks(ctx.db, {
+        states: [...BACKGROUND_ACTIVE_STATES],
+        limit: 50,
+    }).map((row) => ({
+        id: row.id,
+        kind: "background",
+        state: row.state,
+        title: backgroundTitle(row),
+    }));
+    const browser = listBrowserTasks(ctx.db, {
+        states: [...BROWSER_ACTIVE_STATES],
+        limit: 50,
+    }).map((row) => ({
+        id: row.id,
+        kind: "browser",
+        state: row.state,
+        title: browserTitle(row),
+    }));
+    return [...background, ...browser];
+}
+/** Short, copy-pasteable id stem for the `!status` listing. The full id is
+ *  a uuid v4; the first 8 chars are unique in practice and `!stop` accepts
+ *  any unambiguous prefix. */
+function shortId(id) {
+    return id.slice(0, 8);
+}
+function formatStatus(tasks) {
+    if (tasks.length === 0) {
+        return "No background or browser tasks are running.";
+    }
+    const lines = tasks.map((t) => {
+        const label = t.kind === "background" ? "bg" : "web";
+        return `• [${label} ${shortId(t.id)}] ${t.state} — ${t.title}`;
+    });
+    const header = tasks.length === 1
+        ? "1 active task:"
+        : `${tasks.length} active tasks:`;
+    return [
+        header,
+        ...lines,
+        "",
+        "Stop one with !stop <id> (the short id shown above is fine).",
+    ].join("\n");
+}
+export const statusCommand = {
+    name: "!status",
+    title: "Task status",
+    describe: "List running background / browser tasks",
+    runsWhilePaused: true,
+    handler: async (ctx) => {
+        await ctx.notify(formatStatus(listActiveTasks(ctx)));
+    },
+};
+/** Resolve the owner-typed id to a single active task. Accepts the full
+ *  uuid or any unambiguous prefix (so the `!status` short id works). */
+function resolveTarget(ctx, raw) {
+    const needle = raw.trim().toLowerCase();
+    // Exact-id fast path — a full uuid lands here without scanning.
+    const bg = getBackgroundTask(ctx.db, needle);
+    if (bg && BACKGROUND_ACTIVE_STATES.includes(bg.state)) {
+        return { kind: "ok", task: { id: bg.id, kind: "background", state: bg.state, title: backgroundTitle(bg) } };
+    }
+    const web = getBrowserTask(ctx.db, needle);
+    if (web && BROWSER_ACTIVE_STATES.includes(web.state)) {
+        return { kind: "ok", task: { id: web.id, kind: "browser", state: web.state, title: browserTitle(web) } };
+    }
+    // Prefix match across the active set.
+    const matches = listActiveTasks(ctx).filter((t) => t.id.toLowerCase().startsWith(needle));
+    if (matches.length === 1)
+        return { kind: "ok", task: matches[0] };
+    if (matches.length === 0)
+        return { kind: "none" };
+    return { kind: "ambiguous", count: matches.length };
+}
+export const stopTaskCommand = {
+    prefix: "!stop",
+    title: "Stop a task",
+    describe: "Cancel one task by id (bare !stop pauses the agent)",
+    runsWhilePaused: true,
+    handler: async (ctx, args) => {
+        const id = typeof args === "string" ? args : "";
+        if (id.length === 0) {
+            // Unreachable in practice — bare `!stop` resolves to the exact pause
+            // command — but guard so a future resolver change can't crash here.
+            await ctx.notify("Usage: !stop <id> to cancel one task (run !status for ids). " +
+                "Bare !stop pauses the whole agent.");
+            return;
+        }
+        const resolved = resolveTarget(ctx, id);
+        if (resolved.kind === "none") {
+            await ctx.notify(`No active task matches "${id}". Run !status to see what's running.`);
+            return;
+        }
+        if (resolved.kind === "ambiguous") {
+            await ctx.notify(`"${id}" matches ${resolved.count} active tasks — add more characters of the id.`);
+            return;
+        }
+        const task = resolved.task;
+        const cancel = task.kind === "background"
+            ? ctx.cancelBackgroundTask
+            : ctx.cancelBrowserTask;
+        if (!cancel) {
+            // Runner not wired (lite install / boot race). The row still exists;
+            // tell the owner rather than silently dropping the request.
+            await ctx.notify(`Can't stop that ${task.kind} task right now — the runner isn't available. ` +
+                "Try again in a moment.");
+            return;
+        }
+        const ok = await cancel(task.id, "user_bang_stop");
+        await ctx.notify(ok
+            ? `Stopping the ${task.kind} task "${task.title}".`
+            : `Couldn't stop "${task.title}" — it may have already finished.`);
+    },
+};

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

@@ -108,7 +108,7 @@ async function requireWikiWorkspace(ctx, workspaceName = null) {
 export const ingestCommand = {
     prefix: "!ingest",
     title: "Ingest URLs",
-    describe: "ingest one or more URLs into the wiki's raw layer (`@<workspace>` optional)",
+    describe: "ingest one or more URLs into the wiki's raw layer",
     parseArgs(rest) {
         try {
             const { workspaceName, rest: payload } = splitWorkspaceToken(rest);
@@ -355,7 +355,7 @@ function renderCompileInProgressDm(holder, workspaceName) {
 export const askCommand = {
     prefix: "!ask",
     title: "Ask wiki",
-    describe: "ask a question against the wiki (`@<workspace>` optional)",
+    describe: "ask a question against the wiki",
     parseArgs(rest) {
         const { workspaceName, rest: payload } = splitWorkspaceToken(rest);
         const question = payload.trim();
@@ -458,7 +458,7 @@ export const wikiHelpCommand = {
 export const lintCommand = {
     prefix: "!lint",
     title: "Lint wiki",
-    describe: "audit the wiki and write a dated health report (`@<workspace>` optional)",
+    describe: "audit the wiki and write a dated health report",
     parseArgs(rest) {
         const { workspaceName, rest: payload } = splitWorkspaceToken(rest);
         if (payload.trim().length > 0) {
@@ -494,7 +494,7 @@ export const lintCommand = {
 export const traceCommand = {
     prefix: "!trace",
     title: "Trace wiki topic",
-    describe: "reconstruct an idea's evolution across raw / wiki / outputs (`@<workspace>` optional)",
+    describe: "reconstruct an idea's evolution across raw / wiki / outputs",
     parseArgs(rest) {
         const { workspaceName, rest: payload } = splitWorkspaceToken(rest);
         const topic = payload.trim();
@@ -560,7 +560,7 @@ export function parseConnectArgs(rest) {
 export const connectCommand = {
     prefix: "!connect",
     title: "Connect wiki domains",
-    describe: "bridge two domains in the wiki (`@<workspace>` optional)",
+    describe: "bridge two domains in the wiki",
     parseArgs(rest) {
         return parseConnectArgs(rest);
     },

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

@@ -6,6 +6,7 @@
 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 { statusCommand, stopTaskCommand } from "./commands-task-control.js";
 export { closeCommand } from "./commands-close.js";
 export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered, } from "./commands-cost.js";
 export { reportCommand, formatReport } from "./commands-report.js";
@@ -13,6 +14,7 @@ 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 { revertTuningCommand } from "./commands-revert-tuning.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";

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

@@ -5,6 +5,7 @@
  */
 export { BangCommandRegistry, BangArgError, buildPausedNotice, buildUnknownCommandReply, getBangCommandName, makeNotify, normalizeBangCommandText, tryHandle, } from "./registry.js";
 export { stopCommand, startCommand } from "./commands-stop-start.js";
+export { statusCommand, stopTaskCommand } from "./commands-task-control.js";
 export { closeCommand } from "./commands-close.js";
 export { costAllCommand, costBackendCommands, formatCostAll, formatCostFiltered, } from "./commands-cost.js";
 export { reportCommand, formatReport } from "./commands-report.js";
@@ -12,10 +13,12 @@ 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 { revertTuningCommand } from "./commands-revert-tuning.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 { statusCommand, stopTaskCommand } from "./commands-task-control.js";
 import { closeCommand } from "./commands-close.js";
 import { costAllCommand, costBackendCommands, } from "./commands-cost.js";
 import { reportCommand } from "./commands-report.js";
@@ -23,6 +26,7 @@ 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";
+import { revertTuningCommand } from "./commands-revert-tuning.js";
 /**
  * Build a registry preloaded with the v1 built-in commands. The registry
  * is mutable — callers can `.register(...)` more commands afterwards.
@@ -31,6 +35,11 @@ export function createDefaultBangCommandRegistry() {
     const registry = new BangCommandRegistry();
     registry.register(stopCommand);
     registry.register(startCommand);
+    // BACKGROUND_TASK_RUNNER_DESIGN.md Phase 4 — per-task control. `!status`
+    // (exact) lists active detached tasks; `!stop <id>` (prefix) cancels one.
+    // Bare `!stop` still resolves to the exact pause command above.
+    registry.register(statusCommand);
+    registry.register(stopTaskCommand);
     registry.register(closeCommand);
     registry.register(costAllCommand);
     for (const cmd of costBackendCommands) {
@@ -54,5 +63,8 @@ export function createDefaultBangCommandRegistry() {
     // weekly surfacing lives inside `routine.weekly_review` and uses
     // `/api/browser-history/reloads/weekly` instead.
     registry.register(checksCommand);
+    // SELF_TUNING_REVIEW_CYCLE_DESIGN.md §3.4 Phase 3 — `!revert tuning`,
+    // the owner-side undo for autonomously applied tuning changes.
+    registry.register(revertTuningCommand);
     return registry;
 }

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

@@ -53,6 +53,18 @@ export interface BangCommandContext {
     }>;
     enqueueUserBangCommand?: (command: UserBangCommand, event: MessageEvent) => Promise<void>;
     enqueueWikiEvent?: (event: Event) => Promise<void>;
+    /**
+     * Per-task `!stop <id>` cancel hooks (BACKGROUND_TASK_RUNNER_DESIGN.md
+     * Phase 4). Wired from the dispatcher's live runner instances, which
+     * hold the in-memory worker handles the abort needs to reach. Optional
+     * so bang-command unit fixtures (and lite installs without a runner)
+     * can omit them — the `!stop` handler tells the owner the runner is
+     * unavailable rather than silently dropping the request. Return `true`
+     * when an abort/terminal-transition was issued, `false` when the task
+     * was already gone.
+     */
+    cancelBackgroundTask?: (taskId: string, reason: string) => Promise<boolean>;
+    cancelBrowserTask?: (taskId: string, reason: string) => Promise<boolean>;
     /**
      * BROWSER_HISTORY_INTEGRATION_PLAN P3 — wire-through for the
      * `!research accept` / `!research wiki` paths. The bang handler

package/dist/core/browser-history/research-cluster-fanout.d.ts

@@ -2,16 +2,24 @@
  * Day-boundary fan-out helper — enumerates active research clusters
  * with new meaningful activity in the last 24h and emits one
  * `routine.research_cluster_update` event per cluster onto the
- * EventBus. Called once per agent-day from the scheduler's day-boundary
- * callback (see `bootstrap/index.ts`).
+ * EventBus. Called from the scheduler's day-boundary callback (see
+ * `index.ts`), which can fire MORE than once per agent-day — the 04:00
+ * cron, wake catch-up (every detected sleep gap >= 5 min), and the
+ * morning self-heal all invoke it.
  *
- * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3.
+ * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3; dedup added by
+ * RESEARCH_CLUSTER_COST_FIX_PLAN.md F1 after replayed day boundaries
+ * re-enqueued the same cluster ~25x in one morning.
  *
- * Pure orchestration — no LLM in this path. The fan-out is bounded by
- * the `limit` parameter (default 25) so a backlog from a long outage
- * cannot flood the event queue. Clusters that miss this cycle pick up
- * on the next day-boundary fire; the next cycle's DB query naturally
- * sees them as "still active with new activity since prior update".
+ * Pure orchestration — no LLM in this path. Each cluster is atomically
+ * CLAIMED for `todayAgentDay` BEFORE its event is enqueued, so neither a
+ * later sequential replay (`listClustersNeedingUpdate` filters claimed
+ * rows) nor a concurrently in-flight callback (the per-row claim is a
+ * single atomic UPDATE — only one fire wins) can double-fire — exactly
+ * one enqueue per cluster per agent day. A cluster whose claimed run
+ * fails retries on the next agent day; the journal task flow backfills
+ * the missed day. The fan-out is bounded by the `limit` parameter
+ * (default 25) so a backlog from a long outage cannot flood the queue.
  */
 import type Database from "better-sqlite3";
 export interface EventBusLike {
@@ -23,17 +31,23 @@ export interface FanoutResult {
     enqueuedSlugs: string[];
 }
 /**
- * Enumerate active clusters with new meaningful activity since the last
- * day-boundary cycle and enqueue one `routine.research_cluster_update`
- * event per cluster. Always returns the slugs it enqueued so the caller
- * can log a structured summary.
+ * Enumerate active clusters with new meaningful activity not yet
+ * enqueued for `todayAgentDay` and enqueue one
+ * `routine.research_cluster_update` event per cluster. Always returns
+ * the slugs it enqueued so the caller can log a structured summary.
+ *
+ * `todayAgentDay` is the caller-computed local agent-day label
+ * (`getAgentDayDateStr(config.timezone, config.dayBoundaryHour)`) —
+ * the fan-out is timezone-blind by design so it stays pure and
+ * deterministic in tests.
  *
  * When `eventBus` is absent (early-boot path before EventBus wiring),
  * the function returns an empty result without throwing — the next
  * day-boundary tick re-evaluates and picks up the clusters once
- * messaging is live.
+ * messaging is live. Nothing is stamped on that path.
  */
-export declare function fanoutResearchClusterUpdates(db: Database.Database, eventBus: EventBusLike | null | undefined, options?: {
+export declare function fanoutResearchClusterUpdates(db: Database.Database, eventBus: EventBusLike | null | undefined, options: {
+    todayAgentDay: string;
     lookbackMs?: number;
     limit?: number;
     nowMs?: number;

package/dist/core/browser-history/research-cluster-fanout.js

@@ -2,41 +2,64 @@
  * Day-boundary fan-out helper — enumerates active research clusters
  * with new meaningful activity in the last 24h and emits one
  * `routine.research_cluster_update` event per cluster onto the
- * EventBus. Called once per agent-day from the scheduler's day-boundary
- * callback (see `bootstrap/index.ts`).
+ * EventBus. Called from the scheduler's day-boundary callback (see
+ * `index.ts`), which can fire MORE than once per agent-day — the 04:00
+ * cron, wake catch-up (every detected sleep gap >= 5 min), and the
+ * morning self-heal all invoke it.
  *
- * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3.
+ * BROWSER_HISTORY_INTEGRATION_PLAN §10.6 step 3; dedup added by
+ * RESEARCH_CLUSTER_COST_FIX_PLAN.md F1 after replayed day boundaries
+ * re-enqueued the same cluster ~25x in one morning.
  *
- * Pure orchestration — no LLM in this path. The fan-out is bounded by
- * the `limit` parameter (default 25) so a backlog from a long outage
- * cannot flood the event queue. Clusters that miss this cycle pick up
- * on the next day-boundary fire; the next cycle's DB query naturally
- * sees them as "still active with new activity since prior update".
+ * Pure orchestration — no LLM in this path. Each cluster is atomically
+ * CLAIMED for `todayAgentDay` BEFORE its event is enqueued, so neither a
+ * later sequential replay (`listClustersNeedingUpdate` filters claimed
+ * rows) nor a concurrently in-flight callback (the per-row claim is a
+ * single atomic UPDATE — only one fire wins) can double-fire — exactly
+ * one enqueue per cluster per agent day. A cluster whose claimed run
+ * fails retries on the next agent day; the journal task flow backfills
+ * the missed day. The fan-out is bounded by the `limit` parameter
+ * (default 25) so a backlog from a long outage cannot flood the queue.
  */
-import { listClustersNeedingUpdate } from "../../db/browser-history-store.js";
+import { claimClusterJournalEnqueue, listClustersNeedingUpdate, } from "../../db/browser-history-store.js";
 import { createResearchCommandEvent } from "./research-events.js";
 export const RESEARCH_CLUSTER_FANOUT_LOOKBACK_MS = 24 * 60 * 60 * 1000;
 export const RESEARCH_CLUSTER_FANOUT_LIMIT = 25;
 /**
- * Enumerate active clusters with new meaningful activity since the last
- * day-boundary cycle and enqueue one `routine.research_cluster_update`
- * event per cluster. Always returns the slugs it enqueued so the caller
- * can log a structured summary.
+ * Enumerate active clusters with new meaningful activity not yet
+ * enqueued for `todayAgentDay` and enqueue one
+ * `routine.research_cluster_update` event per cluster. Always returns
+ * the slugs it enqueued so the caller can log a structured summary.
+ *
+ * `todayAgentDay` is the caller-computed local agent-day label
+ * (`getAgentDayDateStr(config.timezone, config.dayBoundaryHour)`) —
+ * the fan-out is timezone-blind by design so it stays pure and
+ * deterministic in tests.
  *
  * When `eventBus` is absent (early-boot path before EventBus wiring),
  * the function returns an empty result without throwing — the next
  * day-boundary tick re-evaluates and picks up the clusters once
- * messaging is live.
+ * messaging is live. Nothing is stamped on that path.
  */
-export async function fanoutResearchClusterUpdates(db, eventBus, options = {}) {
+export async function fanoutResearchClusterUpdates(db, eventBus, options) {
     if (!eventBus)
         return { enqueuedSlugs: [] };
     const lookbackMs = options.lookbackMs ?? RESEARCH_CLUSTER_FANOUT_LOOKBACK_MS;
     const limit = options.limit ?? RESEARCH_CLUSTER_FANOUT_LIMIT;
     const nowMs = options.nowMs ?? Date.now();
-    const rows = listClustersNeedingUpdate(db, lookbackMs, nowMs, limit);
+    const rows = listClustersNeedingUpdate(db, lookbackMs, nowMs, limit, options.todayAgentDay);
     const enqueuedSlugs = [];
     for (const row of rows) {
+        // Claim BEFORE the put. The claim is atomic, so if a concurrent
+        // day-boundary fire (the 04:00 cron is fire-and-forget and can
+        // overlap a wake catch-up) already claimed this cluster for today,
+        // our claim returns false and we skip it — exactly one enqueue per
+        // cluster per agent day. If the put then throws, the claim still
+        // persists so the cluster waits for the next agent day instead of
+        // re-firing on the next day-boundary replay.
+        if (!claimClusterJournalEnqueue(db, row.slug, options.todayAgentDay)) {
+            continue;
+        }
         await eventBus.put(createResearchCommandEvent({
             processKey: "routine.research_cluster_update",
             slug: row.slug,

package/dist/core/channel-timeline.d.ts

@@ -1,6 +1,6 @@
 import type Database from "better-sqlite3";
 import type { AgentConfig } from "../config.js";
-export declare const PROACTIVE_FORWARD_TYPES: readonly ["proactive_forward", "proactive_forward_batched", "scheduled_dm"];
+export declare const PROACTIVE_FORWARD_TYPES: readonly ["proactive_forward", "proactive_forward_batched", "scheduled_dm", "task_result", "task_clarification"];
 export type ProactiveForwardType = (typeof PROACTIVE_FORWARD_TYPES)[number];
 /**
  * Render-side suffix that goes after the role tag in the assembled
@@ -17,6 +17,9 @@ export type ProactiveForwardType = (typeof PROACTIVE_FORWARD_TYPES)[number];
  *   embed the dispatch timestamp here: every line already carries the
  *   `[timestamp]` prefix added by the caller, so a second timestamp
  *   in the suffix would just duplicate that information.
+ * - `task_result` / `task_clarification` → task-delivery annotations
+ *   used by the DM agent to understand that a background task result or
+ *   clarification was already surfaced.
  */
 export declare function formatForwardSuffix(metadata: Record<string, unknown>): string;
 export interface DeliveryRow {
@@ -41,4 +44,5 @@ export declare function recordProactiveForwardDeliveries(params: {
     dispatchIds?: string[];
     originSessionIds?: Array<number | null | undefined>;
     notificationType: ProactiveForwardType;
+    extraMetadata?: Record<string, unknown>;
 }): ProactiveForwardRecordResult;

package/dist/core/channel-timeline.js

@@ -12,6 +12,11 @@ export const PROACTIVE_FORWARD_TYPES = [
     // `notification_log` only and the user's follow-up reply would
     // have nothing to anchor to.
     "scheduled_dm",
+    // BACKGROUND_TASK_RUNNER_DESIGN.md Phase 1 — task.delivery records
+    // browser-task results and clarification prompts into owner-facing
+    // conversation history.
+    "task_result",
+    "task_clarification",
 ];
 /**
  * Render-side suffix that goes after the role tag in the assembled
@@ -28,9 +33,16 @@ export const PROACTIVE_FORWARD_TYPES = [
  *   embed the dispatch timestamp here: every line already carries the
  *   `[timestamp]` prefix added by the caller, so a second timestamp
  *   in the suffix would just duplicate that information.
+ * - `task_result` / `task_clarification` → task-delivery annotations
+ *   used by the DM agent to understand that a background task result or
+ *   clarification was already surfaced.
  */
 export function formatForwardSuffix(metadata) {
     switch (getProactiveForwardType(metadata)) {
+        case "task_result":
+            return " (background task result delivered)";
+        case "task_clarification":
+            return " (background task clarification requested)";
         case "scheduled_dm":
             return " (scheduled DM dispatched)";
         case "proactive_forward":
@@ -99,6 +111,7 @@ export function recordProactiveForwardDeliveries(params) {
         notificationType: params.notificationType,
         dispatchIds,
         originSessionIds,
+        ...(params.extraMetadata ?? {}),
     };
     let inserted = 0;
     const sessionIds = [];

package/dist/core/context/index-reconciler.js

@@ -16,6 +16,9 @@ import { CONTEXT_RELATIVE_PATHS } from "../context-paths.js";
 /** Vocabulary understood by `review-context.ts:reviewFlowsMatch`. */
 const REVIEW_FLOW_VOCAB = new Set([
     "all",
+    "activity-scan",
+    // Legacy token for the activity-scan flow (the agent was "Hourly Check"
+    // until v0.1.11); kept so pre-rename `_index.md` rows stay valid.
     "hourly",
     "morning",
     "evening",
@@ -205,7 +208,7 @@ export function renderReconcilerBlockBody(rows, updated) {
     lines.push("## Notes");
     lines.push("");
     lines.push("- Maintained by the daemon reconciler (`packages/daemon/src/core/context/index-reconciler.ts`).");
-    lines.push("- `Review flows` tokens: `all`, `hourly`, `morning`, `evening`, `weekly`,");
+    lines.push("- `Review flows` tokens: `all`, `activity-scan`, `morning`, `evening`, `weekly`,");
     lines.push("  `monthly`, `roadmap`, or `-` when no flow should auto-load the file.");
     return lines.join("\n");
 }
@@ -271,7 +274,7 @@ function defaultCells(entry) {
     if (path === CONTEXT_RELATIVE_PATHS.today) {
         return emit({
             purpose: "Current-day schedule, tasks, agent plan, handoff",
-            reviewFlows: "hourly, morning, evening",
+            reviewFlows: "activity-scan, morning, evening",
         });
     }
     if (path === CONTEXT_RELATIVE_PATHS.yesterday) {

package/dist/core/context/policy-index-reconciler.d.ts

@@ -25,10 +25,12 @@ export interface PolicySnapshotEntry {
     slug: string;
     status: PolicyStatus;
     /**
-     * Cron expression read from the linked `policies/routines/custom/<slug>.md`'s
-     * frontmatter. Null when no routine is linked or the routine file is
-     * missing. Frozen at snapshot time — manual cron edits to the routine
-     * propagate on the next reconcile pass.
+     * Cron expression read from the linked execution vehicle: the Agent's
+     * `policies/agents/<slug>/agent.md` `schedule.expression`, falling back to
+     * a legacy `policies/routines/custom/<slug>.md` `cron` (inert
+     * pre-migration files). Null when nothing is linked or neither file
+     * resolves. Frozen at snapshot time — edits propagate on the next
+     * reconcile pass.
      */
     cadence: string | null;
     /** Slug from `linked.routine` frontmatter, or null. */