mercury-agent 0.16.0 → 0.16.2

package/src/core/routes/dashboard.ts

@@ -1657,6 +1657,19 @@ export function createDashboardRoutes(ctx: DashboardContext) {
               const label =
                 spacesById.get(t.spaceId)?.name ?? (t.spaceId || "global");
               const swatchClass = spaceSwatchClass(t.spaceId, knownSpaceIds);
+              // One indexed lookup per task, and there are single digits of
+              // them. A latest-per-task join would be cheaper in principle and
+              // harder to read for a table this size.
+              const lastRun = core.db.listTaskRuns(t.id, 1)[0];
+              // `failed` still comes from the snapshot, so the badge means the
+              // same thing it did before the ledger existed. `quiet` is the new
+              // answer — a run that succeeded and deliberately said nothing.
+              const outcomeBadge =
+                t.lastStatus === "error"
+                  ? ' <span class="badge">failed</span>'
+                  : lastRun?.outcome === "no_update"
+                    ? ' <span class="badge muted">quiet</span>'
+                    : "";
               return `
               <tr data-space-id="${escapeHtml(t.spaceId || "")}">
                 <td class="mono">#${t.id}</td>
@@ -1668,16 +1681,13 @@ export function createDashboardRoutes(ctx: DashboardContext) {
                 <td class="muted"${t.lastError ? ` title="${escapeHtml(t.lastError)}"` : ""}>${
                   t.lastRunAt === null
                     ? "never"
-                    : `${formatRelativeTime(t.lastRunAt)}${
-                        t.lastStatus === "error"
-                          ? ' <span class="badge">failed</span>'
-                          : ""
-                      }`
+                    : `${formatRelativeTime(t.lastRunAt)}${outcomeBadge}`
                 }</td>
                 <td><span class="badge ${t.silent === 1 ? "muted" : ""}">${t.silent === 1 ? "silent" : "chat"}</span></td>
                 <td><span class="badge ${t.active ? "green" : ""}">${t.active ? "active" : "paused"}</span></td>
                 <td class="actions">
                   <button class="btn btn-sm" hx-post="/dashboard/api/tasks/${t.id}/run" hx-swap="none" hx-sync="this:drop" hx-disabled-elt="this" title="Run now">▶</button>
+                  <button class="btn btn-sm" hx-get="/dashboard/page/tasks/${t.id}/runs" hx-target="#task-runs-drawer" hx-swap="innerHTML" title="Run history">☰</button>
                   ${
                     t.active
                       ? `<button class="btn btn-sm" hx-post="/dashboard/api/tasks/${t.id}/pause" hx-swap="none" title="Pause">⏸</button>`
@@ -1742,6 +1752,97 @@ export function createDashboardRoutes(ctx: DashboardContext) {
           </table>
         </div>
       </div>
+
+      <div id="task-runs-drawer"></div>
+    `);
+  });
+
+  /**
+   * Run history for one task. Served into the drawer under the tasks table
+   * rather than as a page of its own — the question it answers ("what has this
+   * task actually been doing?") is always asked while looking at the row.
+   */
+  app.get("/page/tasks/:id/runs", (c) => {
+    const taskId = Number(c.req.param("id"));
+    if (!Number.isFinite(taskId) || taskId < 1) {
+      return c.html(
+        html`<div class="panel"><p class="empty">Invalid task ID</p></div>`,
+      );
+    }
+    const task = core.db.getTask(taskId);
+    if (!task) {
+      return c.html(
+        html`<div class="panel"><p class="empty">Task not found</p></div>`,
+      );
+    }
+    const runs = core.db.listTaskRuns(taskId, 25);
+
+    const outcomeCell = (run: (typeof runs)[number]): string => {
+      if (run.status === "error") return '<span class="badge">failed</span>';
+      if (run.outcome === "no_update")
+        return '<span class="badge muted">quiet</span>';
+      if (run.outcome === "posted")
+        return '<span class="badge green">posted</span>';
+      return '<span class="muted">—</span>';
+    };
+
+    const rowsHtml =
+      runs.length > 0
+        ? runs
+            .map((run) => {
+              // A clock moved backwards mid-run makes this negative. Say
+              // nothing rather than report a negative duration as fact.
+              const ms = run.finishedAt - run.startedAt;
+              const duration = ms >= 0 ? `${Math.round(ms / 1000)}s` : "—";
+              return `
+              <tr>
+                <td class="muted">${formatRelativeTime(run.startedAt)}</td>
+                <td>${outcomeCell(run)}</td>
+                <td class="mono muted">${run.model ? escapeHtml(run.model) : "—"}</td>
+                <td class="mono">${run.totalTokens === null ? "—" : formatTokenCount(run.totalTokens)}</td>
+                <td class="mono">${run.cost === null ? "—" : formatCost(run.cost)}</td>
+                <td class="mono muted">${duration}</td>
+                <td class="mono muted">${run.replyChars === null ? "—" : run.replyChars}</td>
+                <td class="mono muted">${run.files ? run.files : "—"}</td>
+                <td><span class="badge ${run.manual ? "" : "muted"}">${run.manual ? "manual" : "cron"}</span></td>
+                <td class="mono muted">${run.attempt > 1 ? `#${run.attempt}` : "—"}</td>
+                <td class="truncate muted"${run.error ? ` title="${escapeHtml(run.error)}"` : ""}>${run.error ? escapeHtml(truncate(run.error, 40)) : "—"}</td>
+              </tr>
+            `;
+            })
+            .join("")
+        : `<tr><td colspan="11" class="empty">No runs recorded yet${
+            task.lastRunAt === null
+              ? ""
+              : " — this task last ran before the ledger existed"
+          }</td></tr>`;
+
+    return c.html(html`
+      <div class="panel">
+        <div class="page-header">
+          <h3>Run history — task #${taskId}</h3>
+        </div>
+        <div class="table-scroll">
+          <table class="table">
+            <thead>
+              <tr>
+                <th>When</th>
+                <th>Outcome</th>
+                <th>Model</th>
+                <th>Tokens</th>
+                <th>Cost</th>
+                <th>Took</th>
+                <th>Chars</th>
+                <th>Files</th>
+                <th>Trigger</th>
+                <th>Attempt</th>
+                <th>Error</th>
+              </tr>
+            </thead>
+            <tbody>${raw(rowsHtml)}</tbody>
+          </table>
+        </div>
+      </div>
     `);
   });
 

package/src/core/routes/tasks.ts

@@ -180,6 +180,34 @@ tasks.post("/:id/run", (c) => {
   return c.json({ id: taskId, triggered: true });
 });
 
+/**
+ * The last N attempts of a task. Read-only, space-scoped like its siblings,
+ * and empty rather than 404 for a task that predates the ledger.
+ */
+tasks.get("/:id/runs", (c) => {
+  const { spaceId } = getAuth(c);
+  const denied = checkPerm(c, "tasks.list");
+  if (denied) return denied;
+
+  const { db } = getApiCtx(c);
+  const taskId = Number(c.req.param("id"));
+  if (!Number.isFinite(taskId) || taskId < 1) {
+    return c.json({ error: "Invalid task ID" }, 400);
+  }
+
+  const task = db.getTask(taskId);
+  if (!task || task.spaceId !== spaceId) {
+    return c.json({ error: "Task not found" }, 404);
+  }
+
+  // A caller asking for nonsense gets the default rather than an error: the
+  // number is a page size, not an assertion about the data.
+  const rawLimit = Number(c.req.query("limit"));
+  const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? rawLimit : 50;
+
+  return c.json({ id: taskId, runs: db.listTaskRuns(taskId, limit) });
+});
+
 tasks.delete("/:id", (c) => {
   const { spaceId } = getAuth(c);
   const denied = checkPerm(c, "tasks.delete");

package/src/core/runtime.ts

@@ -22,6 +22,7 @@ import type {
   MessageAttachment,
   MessageRunMeta,
   MessageSender,
+  TaskRunDetail,
   TokenUsage,
 } from "../types.js";
 import { formatDroppedAttachmentNote } from "./attachment-notes.js";
@@ -50,7 +51,11 @@ import {
   resolveLocale,
 } from "./system-messages.js";
 import { isNoOpTaskReply } from "./task-output.js";
-import { type TaskFailure, TaskScheduler } from "./task-scheduler.js";
+import {
+  TaskDeliveryError,
+  type TaskFailure,
+  TaskScheduler,
+} from "./task-scheduler.js";
 
 export type InputSource = "cli" | "scheduler" | "chat-sdk";
 
@@ -363,12 +368,35 @@ export class MercuryCoreRuntime {
         const text = noOp ? "" : result.reply;
         const worthSending = !noOp || result.files.length > 0;
 
+        // What the run *produced*, for the ledger. `worthSending` is the same
+        // judgement the send path is about to make, so the recorded outcome
+        // can never disagree with what the space was offered.
+        //
+        // Delivery is not folded in: a silent task that reports something is
+        // `posted` here, because "the task found news" and "the group heard
+        // about it" are different questions and `silent` already answers the
+        // second one.
+        const detail: TaskRunDetail = {
+          outcome: worthSending ? "posted" : "no_update",
+          usage: result.usage,
+          replyChars: result.reply?.length ?? 0,
+          files: result.files.length,
+        };
+
         if (!task.silent && sender && worthSending) {
-          await sender.send(task.spaceId, text, result.files);
+          try {
+            await sender.send(task.spaceId, text, result.files);
+          } catch (error) {
+            // Still a failed run — retry, report, post nothing — but the
+            // model work is done and paid for, and the ledger should say so.
+            throw new TaskDeliveryError(error, detail);
+          }
         }
         if (!task.silent && text) {
           this.deliverTaskOutput(task.spaceId, text);
         }
+
+        return detail;
       },
       (failure) => this.announceTaskFailure(failure, sender),
     );
@@ -2015,6 +2043,39 @@ export class MercuryCoreRuntime {
       }
       // ────────────────────────────────────────────────────────────────────
 
+      // ── Scheduler no-op: leave no trace in the space history ─────────────
+      // A monitoring task is silent on most runs by design. The scheduler
+      // already declines to *send* such a reply (`isNoOpTaskReply`, at the
+      // callback in `startScheduler`), but both rows were still written — so a
+      // space polled five times a day accumulated ten messages nobody ever saw,
+      // and the agent read its own prompt back as conversation history on the
+      // next run.
+      //
+      // Scoped three ways on purpose. Only `scheduler` — chat behaviour is
+      // untouched, and a person who types "ok" gets their turn recorded. Only
+      // when there are no files — the scheduler still delivers an attachment
+      // with an empty caption, and a delivered message with no stored row would
+      // be worse than the noise this removes. And the usage is still recorded
+      // below either way: the run cost real tokens whether or not it had
+      // anything to say, and the ledger has to agree with the bill.
+      const schedulerNoOp =
+        source === "scheduler" &&
+        containerResult.files.length === 0 &&
+        isNoOpTaskReply(containerResult.reply);
+
+      if (schedulerNoOp) {
+        this.db.deleteMessage(userMessageId);
+        if (containerResult.usage) {
+          this.db.recordUsage(spaceId, containerResult.usage);
+        }
+        logger.debug("Scheduled no-op turn not persisted", {
+          spaceId,
+          userMessageId,
+        });
+        return containerResult;
+      }
+      // ─────────────────────────────────────────────────────────────────────
+
       const assistantMessageId = this.db.addMessage(
         spaceId,
         "assistant",

package/src/core/task-scheduler.ts

@@ -1,15 +1,37 @@
 import { CronExpressionParser } from "cron-parser";
 import { logger } from "../logger.js";
 import { type Db, TASK_LAST_ERROR_MAX_LENGTH } from "../storage/db.js";
-import type { ScheduledTask } from "../types.js";
+import type { ScheduledTask, TaskRunDetail, TaskRunStatus } from "../types.js";
 
+/**
+ * A handler may report what the run produced, for the ledger. Returning
+ * nothing stays legal and costs only detail: the row is still written, with a
+ * null outcome rather than a guessed one.
+ */
 type TaskHandler = (task: {
   id: number;
   spaceId: string;
   prompt: string;
   createdBy: string;
   silent: boolean;
-}) => Promise<void>;
+}) => Promise<TaskRunDetail | void>;
+
+/**
+ * A run whose model work completed but whose delivery did not. Thrown by a
+ * handler so the scheduler still treats the run as failed — retry, report,
+ * post nothing — while the ledger keeps the usage the run already paid for.
+ * Without it a delivery failure and a model failure look identical in the
+ * run history, and the cost of the former is simply lost.
+ */
+export class TaskDeliveryError extends Error {
+  readonly detail: TaskRunDetail;
+  constructor(cause: unknown, detail: TaskRunDetail) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    super(`Delivery failed: ${message}`);
+    this.name = "TaskDeliveryError";
+    this.detail = detail;
+  }
+}
 
 /**
  * A task that has run out of attempts. Reported once per due cycle, never
@@ -127,7 +149,7 @@ export class TaskScheduler {
           const fresh = this.db.getTask(task.id);
           if (!fresh?.active || fresh.nextRunAt > Date.now()) continue;
 
-          await this.runTask(fresh, true);
+          await this.runTask(fresh, true, false);
         }
       } catch (error) {
         logger.error(
@@ -215,6 +237,7 @@ export class TaskScheduler {
   private async runTask(
     task: ScheduledTask,
     applyBookkeeping: boolean,
+    manual: boolean,
   ): Promise<void> {
     const handler = this.handler;
     if (!handler) {
@@ -230,16 +253,20 @@ export class TaskScheduler {
     this.running.add(task.id);
     try {
       let failure: string | null = null;
+      let detail: TaskRunDetail | undefined;
+      const startedAt = Date.now();
       try {
-        await handler({
-          id: task.id,
-          spaceId: task.spaceId,
-          prompt: task.prompt,
-          createdBy: task.createdBy,
-          silent: task.silent === 1,
-        });
+        detail =
+          (await handler({
+            id: task.id,
+            spaceId: task.spaceId,
+            prompt: task.prompt,
+            createdBy: task.createdBy,
+            silent: task.silent === 1,
+          })) ?? undefined;
       } catch (error) {
         failure = error instanceof Error ? error.message : String(error);
+        if (error instanceof TaskDeliveryError) detail = error.detail;
       }
 
       // A preview run has no schedule to consume, so it must not touch the
@@ -249,7 +276,14 @@ export class TaskScheduler {
       const attempts = applyBookkeeping
         ? (this.attempts.get(task.id) ?? 0) + 1
         : 1;
-      this.db.recordTaskRun(task.id, failure ? "error" : "ok", failure);
+      this.recordRun(task, {
+        status: failure ? "error" : "ok",
+        failure,
+        startedAt,
+        detail,
+        manual,
+        attempt: attempts,
+      });
 
       if (!failure) {
         if (applyBookkeeping) {
@@ -296,6 +330,63 @@ export class TaskScheduler {
     }
   }
 
+  /**
+   * Write the run down — one grep-able log line, then the snapshot and the
+   * ledger row (a single `recordTaskRun` call, so the two can never drift).
+   *
+   * The log comes first on purpose: it is the record that survives a database
+   * that is refusing writes, which is exactly when knowing the run happened
+   * matters most.
+   *
+   * Bookkeeping runs *after* the handler, so a throw here would be a second
+   * failure charged to a run that may well have succeeded — the shape that
+   * turned an unparseable cron into a full agent turn every five seconds
+   * (docs/debug/major/2026-08-11-scheduled-task-timeout-silent.md). It is
+   * caught and logged, never propagated.
+   */
+  private recordRun(
+    task: ScheduledTask,
+    run: {
+      status: TaskRunStatus;
+      failure: string | null;
+      startedAt: number;
+      detail?: TaskRunDetail;
+      manual: boolean;
+      attempt: number;
+    },
+  ): void {
+    const finishedAt = Date.now();
+    logger.info("Scheduled run finished", {
+      taskId: task.id,
+      spaceId: task.spaceId,
+      status: run.status,
+      outcome: run.status === "error" ? "error" : (run.detail?.outcome ?? null),
+      model: run.detail?.usage?.model ?? null,
+      durationMs: finishedAt - run.startedAt,
+      totalTokens: run.detail?.usage?.totalTokens ?? null,
+      cost: run.detail?.usage?.cost ?? null,
+      replyChars: run.detail?.replyChars ?? null,
+      files: run.detail?.files ?? null,
+      manual: run.manual,
+      attempt: run.attempt,
+    });
+    try {
+      this.db.recordTaskRun(task.id, run.status, run.failure, finishedAt, {
+        spaceId: task.spaceId,
+        startedAt: run.startedAt,
+        detail: run.detail,
+        manual: run.manual,
+        attempt: run.attempt,
+      });
+    } catch (error) {
+      logger.error("Failed to record a scheduled run", {
+        taskId: task.id,
+        spaceId: task.spaceId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   /**
    * When to attempt a failed task again. Normally now + the retry delay, but
    * never later than the task's own next occurrence — a 5-minute retry delay
@@ -399,7 +490,7 @@ export class TaskScheduler {
     // net, so anything runTask throws after the handler (a DB write racing
     // shutdown, say) would surface as an unhandled rejection and take the
     // process down. Catch it here instead.
-    void this.runTask(task, applyBookkeeping).catch((error) => {
+    void this.runTask(task, applyBookkeeping, true).catch((error) => {
       logger.error("Manual task run failed after the handler", {
         taskId: task.id,
         spaceId: task.spaceId,

package/src/extensions/catalog.ts

@@ -112,6 +112,15 @@ export const EXTENSION_CATALOG: ExtensionCatalogEntry[] = [
     ],
     requiresRestart: true,
   },
+  {
+    name: "feed-watch",
+    label: "Feed watch",
+    description:
+      "Poll RSS and Google News on the host, match headlines against a per-space watchlist, and open a short verify run only when something matched. Feeds a daily article prompt everything seen since the last one. No model runs on the host side. Off for every space until enabled on the space page.",
+    category: "automation",
+    sourceDir: "feed-watch",
+    requiresRestart: true,
+  },
   {
     name: "yahoo-mail",
     label: "Yahoo Mail",