mercury-agent 0.18.2 → 0.20.0

package/docs/profile-guide.md

@@ -203,10 +203,15 @@ win by being specific:
 - *Presenting tool results* — "simple lists, never commands/JSON". A
   reporter who must not answer in lists: say so; a profile whose users *are*
   developers: say the opposite.
-- *Character → "set a preference"* — a standing instruction from a member
-  becomes "only an admin can set that", which in a friends' group reads as
-  refusing a joke. Say what the bot does with a standing request from a
-  member (relay, decline in one line, or treat as banter).
+- *Character → "set a preference"* — a standing instruction from an
+  admin becomes "only an admin can set that", which in a friends' group reads
+  as refusing a joke. A member never sees that procedure at all: from the
+  2026-09 image rebuild (`7d242e2`) the `## Character` heading and its "Always
+  follow it" / "only the bot owner can change it" sentences ship to every
+  caller, while the `mrctl` procedure under them stays gated on `prefs.set`, so
+  a member's request gets the one-line decline. Say what the bot does with a
+  standing request from a member (relay, decline in one line, or treat as
+  banter).
 - *"Be concise"*, *"Ask for clarification"* from the pi preamble and the
   default global `AGENTS.md` — a reporter that must give a full factual
   answer, or a bot that must not ask before acting, says so.
@@ -360,10 +365,25 @@ What that means for a profile:
    bot an explicit rule for when to update it. The three DM spaces on the
    live bot that have one use it; the football space, which needed it most,
    never had one.
-3. **Episodes need keywords that will recur.** An episode about "Abu Fani's
-   transfer" with `keywords: ["אבו פאני","hapoel","transfer"]` surfaces on
-   the next message containing one of those words; without keywords it never
-   surfaces. Prefer a notebook the bot reads by rule over relying on scoring.
+3. **Episodes need keywords that will recur, one word each.** An episode
+   about "Abu Fani's transfer" with `keywords: ["פאני","fani","hapoel",
+   "transfer"]` surfaces on the next message containing one of those words;
+   without keywords it never surfaces. The message is split on whitespace,
+   ASCII punctuation, the hyphen and the maqaf, so a keyword with a space, an
+   apostrophe or a dash — `"אבו פאני"`, `"מנצ'סטר"`, `"man-united"` — can
+   never match anything (a geresh or gershayim *inside* a word in the message
+   is dropped rather than split, so `לבית"ר` does reach the keyword `ביתר`;
+   the keyword itself is never rewritten). A Hebrew prefix on the word still
+   matches (`ליונייטד`, `וכשיונייטד`) as long as four letters remain once it
+   is stripped — five after a leading `מ`, which also opens whole words. So
+   list the bare word once — every extra keyword lowers the note's score —
+   and before choosing a short keyword, read it back with each of
+   `ו/ה/ב/ל/ש/כ` in front: if that spells a different everyday word, the
+   note will surface on that word too, so pick another keyword. Mem is the
+   one the host handles itself — it turned `שוער` (goalkeeper) into `משוער`
+   (projected) — and the extra letter it costs is deliberate: `מחיפה` no
+   longer reaches a note keyed `חיפה`, while `חיפה` and `בחיפה` still do.
+   Prefer a notebook the bot reads by rule over relying on scoring.
 4. **Do not let distillation stand in for a notebook.** On the live bot
    napkin distils every space daily and has written *zero* entity files for
    the football space — group banter does not meet its "lasting signal"

package/examples/extensions/archive/backends/local.ts

@@ -13,7 +13,6 @@
 
 import { randomBytes } from "node:crypto";
 import {
-  copyFileSync,
   existsSync,
   mkdirSync,
   readdirSync,
@@ -22,6 +21,7 @@ import {
   statSync,
   unlinkSync,
 } from "node:fs";
+import { copyFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { type ArchiveBackend, ArchiveConfigError } from "./types.js";
 
@@ -84,7 +84,9 @@ export class LocalArchiveBackend implements ArchiveBackend {
     // hash that claims to describe complete content.
     const tmp = `${dest}.${randomBytes(4).toString("hex")}.tmp`;
     try {
-      copyFileSync(srcPath, tmp);
+      // Awaited: blobs run to the 25 MB outbox cap and this backend is on the
+      // host delivery path — a sync copy stalls every other space.
+      await copyFile(srcPath, tmp);
       renameSync(tmp, dest);
     } catch (err) {
       // Leave nothing behind on failure; the queue will retry.
@@ -122,7 +124,8 @@ export class LocalArchiveBackend implements ArchiveBackend {
     // attached to a reply and sent to the customer as if it were whole.
     const tmp = `${destPath}.${randomBytes(4).toString("hex")}.tmp`;
     try {
-      copyFileSync(src, tmp);
+      // Awaited, same reason as `put`.
+      await copyFile(src, tmp);
       renameSync(tmp, destPath);
     } catch (err) {
       try {

package/examples/extensions/archive/queue.ts

@@ -29,11 +29,21 @@
  * bytes that were never stored: `ARCHIVE.md` would advertise a file, and
  * retrieving it would 404 forever. That asymmetry is why the order is a rule
  * and not a preference.
+ *
+ * ## The one window that is not a crash
+ *
+ * `spool` used to have no `await` in it, so `deleteSpool` — whole-space
+ * erasure — could only run wholly before or wholly after it. The copy is
+ * awaited now (it was blocking the host event loop), so an erasure can land
+ * inside it. That is not a crash window and reconcile does not cover it: the
+ * pending directory simply stops existing halfway through. `spool` detects it
+ * and fails with a message naming the erasure, rather than recreating the
+ * directory — a record written back into an erased spool would drain, and the
+ * file the customer asked to erase would be archived again.
  */
 
 import { createHash, randomBytes } from "node:crypto";
 import {
-  copyFileSync,
   createReadStream,
   existsSync,
   mkdirSync,
@@ -44,6 +54,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { copyFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ArchiveBackend } from "./backends/types.js";
 import { isDeleting } from "./inflight.js";
@@ -121,15 +132,45 @@ export async function spool(
   mkdirSync(dir, { recursive: true });
 
   const blobCopy = join(dir, `${record.id}.blob`);
-  copyFileSync(srcPath, blobCopy);
-
-  const full: PendingRecord = { v: PENDING_VERSION, attempts: 0, ...record };
-  const tmp = join(
-    dir,
-    `${record.id}.json.${randomBytes(4).toString("hex")}.tmp`,
-  );
-  writeFileSync(tmp, JSON.stringify(full), "utf8");
-  renameSync(tmp, join(dir, `${record.id}.json`));
+  try {
+    // Awaited, not `copyFileSync`. This runs inside the `delivery` hook, on
+    // the host, in-process — the same thread that owns every other space's
+    // turn, the dashboard, `/health` and the inner-container API socket.
+    // Outbox files are capped at 25 MB, so the synchronous version parked all
+    // of them for a 25 MB disk-to-disk copy on the hot path before a reply was
+    // sent.
+    await copyFile(srcPath, blobCopy);
+
+    const full: PendingRecord = { v: PENDING_VERSION, attempts: 0, ...record };
+    const tmp = join(
+      dir,
+      `${record.id}.json.${randomBytes(4).toString("hex")}.tmp`,
+    );
+    writeFileSync(tmp, JSON.stringify(full), "utf8");
+    renameSync(tmp, join(dir, `${record.id}.json`));
+  } catch (err) {
+    throw erasedMidSpool(err, dir, record);
+  }
+}
+
+/**
+ * Translate "the spool directory vanished under us" — the header's one
+ * non-crash window, opened by making the copy awaited — into a message that
+ * names what happened. Every other error is passed through untouched: nothing
+ * is swallowed here, and the `delivery` hook logs whichever comes out.
+ */
+function erasedMidSpool(
+  err: unknown,
+  dir: string,
+  record: { space: string; name: string },
+): Error {
+  const code = (err as NodeJS.ErrnoException | undefined)?.code;
+  if (code === "ENOENT" && !existsSync(dir)) {
+    return new Error(
+      `the spool for space ${record.space} was erased while ${record.name} was being copied into it — not spooled`,
+    );
+  }
+  return err instanceof Error ? err : new Error(String(err));
 }
 
 /** Every spooled record for a space, oldest first. `onCorrupt` is called per unreadable file. */

package/examples/extensions/feed-watch/config.ts

@@ -1,6 +1,6 @@
 /**
- * The eight per-space config keys, their validators, and the reader that turns
- * eight strings into one typed `WatchConfig`.
+ * The ten per-space config keys, their validators, and the reader that turns
+ * ten strings into one typed `WatchConfig`.
  *
  * Two audiences, deliberately held apart:
  *
@@ -31,6 +31,19 @@ export const MAX_BATCH_MINUTES = 30;
 export const DEFAULT_DIGEST_MAX_ITEMS = 200;
 export const DIGEST_MAX_ITEMS_CEILING = 400;
 
+/**
+ * Most items one verify run carries. The other half of the same lesson, on the
+ * other prompt: `prompts/verify.md` asks the agent to open the link for every
+ * item, which is a per-item instruction, so the batch has to stay the size that
+ * instruction was written for. Nothing bounded it until 2026-09-06, when the
+ * first poll after a 29-hour outage opened a single run with **116** items and
+ * the model answered with one line — 115 items neither verified nor deferred.
+ * Overflow is not dropped: it stays in the pending batch for the next tick and
+ * is in the daily digest either way.
+ */
+export const DEFAULT_VERIFY_MAX_ITEMS = 20;
+export const VERIFY_MAX_ITEMS_CEILING = 50;
+
 /** An RSS/Atom URL, polled as-is. */
 export interface RssSource {
   type: "rss";
@@ -70,6 +83,8 @@ export interface WatchConfig {
   quietHours: QuietHours | null;
   maxPerHour: number;
   batchMinutes: number;
+  /** Hard ceiling on how many items one verify run carries, newest first. */
+  verifyMaxItems: number;
   /** Hard ceiling on how many items the daily digest hands the article. */
   digestMaxItems: number;
   /** IANA zone, or "" to fall back to the deployment default and then UTC. */
@@ -178,6 +193,15 @@ export function isValidDigestMaxItems(value: string): boolean {
   return isIntInRange(value, 1, DIGEST_MAX_ITEMS_CEILING);
 }
 
+/**
+ * At least one, because zero is already spelled `max_per_hour: 0` — a run that
+ * carries no items is not a quieter watcher, it is an empty prompt. The ceiling
+ * is where a per-item "open the link" instruction stops being followable.
+ */
+export function isValidVerifyMaxItems(value: string): boolean {
+  return isIntInRange(value, 1, VERIFY_MAX_ITEMS_CEILING);
+}
+
 /**
  * An IANA zone name, checked by asking `Intl` to use it. Empty means "unset",
  * which is a valid state — the poller falls back to the deployment default.
@@ -290,6 +314,16 @@ export function readSpaceConfig(
         log,
       ),
     ),
+    verifyMaxItems: Number(
+      read(
+        getConfig,
+        spaceId,
+        "verify_max_items",
+        String(DEFAULT_VERIFY_MAX_ITEMS),
+        isValidVerifyMaxItems,
+        log,
+      ),
+    ),
     digestMaxItems: Number(
       read(
         getConfig,
@@ -374,6 +408,12 @@ export const CONFIG_KEYS: ConfigKeyDef[] = [
     default: String(DEFAULT_BATCH_MINUTES),
     validate: isValidBatchMinutes,
   },
+  {
+    key: "verify_max_items",
+    description: `Most items one verify run carries, newest first (1–${VERIFY_MAX_ITEMS_CEILING}, default ${DEFAULT_VERIFY_MAX_ITEMS}). The rest stay in the batch for the next tick and reach the daily digest either way — a bound on how much one run is asked to check, not a filter.`,
+    default: String(DEFAULT_VERIFY_MAX_ITEMS),
+    validate: isValidVerifyMaxItems,
+  },
   {
     key: "digest_max_items",
     description: `Most items the daily digest carries into the article's prompt, newest first (1–${DIGEST_MAX_ITEMS_CEILING}, default ${DEFAULT_DIGEST_MAX_ITEMS}). Older matches stay in the workspace digest file. A bound on prompt size, not a filter.`,

package/examples/extensions/feed-watch/digest.ts

@@ -18,6 +18,7 @@ import {
   formatItemLines,
   formatLocal,
   isAggregatorLink,
+  newestFirst,
   resolveTimezone,
   type StoredItem,
 } from "./items.js";
@@ -200,13 +201,9 @@ export function buildDigest(
     return !Number.isFinite(untilMs) || seen <= untilMs;
   });
 
-  // Newest first, then cut. `formatItemLines` sorts the same way, so the lines
-  // and the cut agree about which items are the freshest.
-  const byRecency = [...items].sort(
-    (a, b) =>
-      Date.parse(b.publishedAt ?? b.seenAt) -
-      Date.parse(a.publishedAt ?? a.seenAt),
-  );
+  // Newest first, then cut. `formatItemLines` sorts through the same helper, so
+  // the lines and the cut agree about which items are the freshest.
+  const byRecency = newestFirst(items);
   const cap = maxItems && maxItems > 0 ? maxItems : byRecency.length;
   const shown = byRecency.slice(0, cap);
   const omitted = byRecency.length - shown.length;

package/examples/extensions/feed-watch/items.ts

@@ -191,25 +191,36 @@ export function formatItemLine(
   return `- ${parts.join(" | ")}`;
 }
 
+/**
+ * A copy of `items` ordered **newest first**, leaving the input untouched.
+ *
+ * Sorted by publication time where the outlet gave one, and by when we saw it
+ * where it did not — an undated item's `seenAt` is the closest honest stand-in,
+ * and it keeps the order total rather than leaving undated items bunched.
+ *
+ * Three callers share it and they must agree: the rendered lines, the digest's
+ * `digest_max_items` cut and the verify run's `verify_max_items` cut. A cap
+ * that cuts on one order while the lines are rendered in another would drop
+ * items nobody could name — so the order lives here once.
+ */
+export function newestFirst(items: StoredItem[]): StoredItem[] {
+  const at = (i: StoredItem) => Date.parse(i.publishedAt ?? i.seenAt);
+  return [...items].sort((a, b) => at(b) - at(a));
+}
+
 /**
  * Render a list of items as lines, **newest first**.
  *
  * The buffer is append-ordered, so without this both the verify prompt and the
  * digest would lead with the oldest headline. The agent is told to trust these
  * lines over its own memory; the freshest one is the one it should read first.
- *
- * Sorted by publication time where the outlet gave one, and by when we saw it
- * where it did not — an undated item's `seenAt` is the closest honest stand-in,
- * and it keeps the order total rather than leaving undated items bunched.
  */
 export function formatItemLines(
   items: StoredItem[],
   zone: string,
   opts: FormatOptions = {},
 ): string {
-  const at = (i: StoredItem) => Date.parse(i.publishedAt ?? i.seenAt);
-  return [...items]
-    .sort((a, b) => at(b) - at(a))
+  return newestFirst(items)
     .map((i) => formatItemLine(i, zone, opts))
     .join("\n");
 }

package/examples/extensions/feed-watch/match.ts

@@ -7,6 +7,11 @@
  * phone will carry none of those forms. So matching normalizes aggressively
  * and then asks a substring question, which is the only question that survives
  * a prefixed, pointed, hyphenated language.
+ *
+ * Exclusions ask a narrower one — the same substring, but it has to start a
+ * word, looking through the attached Hebrew prefixes. The asymmetry is the
+ * point: an over-matching watch term costs a line in a prompt that then
+ * rejects it, an over-matching exclusion drops the story and says nothing.
  */
 
 import { createHash } from "node:crypto";
@@ -59,20 +64,129 @@ export interface MatchResult {
   terms: string[];
   /** True when an exclude term hit — the item is dropped whatever matched. */
   excluded: boolean;
+  /**
+   * The exclude term that dropped it, as the admin wrote it. Present only when
+   * `excluded` is true — an item dropped here leaves no other trace, so the
+   * needle is carried out for the caller to log.
+   */
+  excludedBy?: string;
+}
+
+/**
+ * The Hebrew prefix letters that attach to the word they govern: ו (and),
+ * ה (the), ב (in), ל (to), מ (from), ש (that), כ (as). Up to three stack —
+ * `וכשנשים` is "and when women".
+ *
+ * The same set, and the same stacking limit, as `HEBREW_PREFIX_RE` in
+ * `src/agent/container-entry.ts`, which does this for episode keywords. It is
+ * restated rather than imported because this extension is installed as a
+ * snapshot and imports nothing from the host; when one moves, move both.
+ */
+const HEBREW_PREFIXES = "ובהלמשכ";
+const MAX_STACKED_PREFIXES = 3;
+
+/** A letter or digit in any script. What "inside a word" means here. */
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/**
+ * A *Hebrew* needle shorter than this is matched at a bare word boundary only
+ * — the prefix letters are not stripped for it. Three-letter Hebrew words are
+ * where the false positives live (`container-entry.ts` carries the same floor
+ * for the same reason: `בבית` must not select a note keyed on `בית`), and an
+ * exclusion that fires wrongly drops a story with no trace at all.
+ *
+ * The floor is about Hebrew stems, so it is gated on the needle's script and
+ * not on its length alone. A Latin needle is never a short Hebrew word, and it
+ * still needs the walk: Hebrew outlets write `ה-WSL`, which `normalize` folds
+ * to `הwsl` — three-letter Latin acronyms (`WSL`, `U21`, `U19`) are exactly
+ * the entries on the live list that arrive glued to a prefix.
+ */
+const PREFIX_STRIP_MIN_CHARS = 4;
+
+/**
+ * Does the term open with a character from the Hebrew block (U+0590–U+05FF)?
+ *
+ * Written as code points rather than a character-class range: a pasted range
+ * of two invisible-ish boundary characters is one format-on-save away from
+ * meaning something else.
+ */
+function opensWithHebrew(term: string): boolean {
+  const cp = term.codePointAt(0) ?? 0;
+  return cp >= 0x0590 && cp <= 0x05ff;
+}
+
+/**
+ * Does the occurrence at `index` start a word?
+ *
+ * "Start of a word" in Hebrew has to look through the attached prefixes: the
+ * feeds publish `הנשים`, `לנשים` and `בנשים` for the same word an admin typed
+ * as `נשים`, and nothing separates the letter from the noun. So up to three
+ * prefix letters are walked back over before the boundary is tested — which
+ * is what keeps `נשים` out of `אנשים`, where the preceding letter (א) is not
+ * one of them.
+ */
+function startsWord(
+  text: string,
+  index: number,
+  allowPrefixes: boolean,
+): boolean {
+  let start = index;
+  if (allowPrefixes) {
+    let stripped = 0;
+    while (start > 0 && stripped < MAX_STACKED_PREFIXES) {
+      // Spelled out rather than `includes(text[i] ?? "")`: `"…".includes("")`
+      // is *true*, so a missing character would authorize the strip instead of
+      // refusing it. Absence denies.
+      const before = text[start - 1];
+      if (!before || !HEBREW_PREFIXES.includes(before)) break;
+      start--;
+      stripped++;
+    }
+  }
+  return start === 0 || !WORD_CHAR.test(text[start - 1] ?? "");
+}
+
+/**
+ * Does `needle` occur in `text` at the start of a word (prefixes allowed)?
+ *
+ * Every occurrence is tried, not just the first: `אנשים במכבי חיפה נשים` has
+ * one that fails the test and one that passes, and the item is excluded.
+ *
+ * The *end* of the needle is deliberately not tested. `Women` has to keep
+ * dropping `Women's` — which normalizes to `womens` — and Hebrew inflects at
+ * the end as freely as it prefixes at the front. The bug this answers is
+ * over-matching to the left; the right-hand side is what the substring design
+ * was right about.
+ */
+function matchesAtWordStart(text: string, needle: string): boolean {
+  const allowPrefixes =
+    !opensWithHebrew(needle) || needle.length >= PREFIX_STRIP_MIN_CHARS;
+  for (
+    let at = text.indexOf(needle);
+    at !== -1;
+    at = text.indexOf(needle, at + 1)
+  ) {
+    if (startsWord(text, at, allowPrefixes)) return true;
+  }
+  return false;
 }
 
 /**
  * Match an item against a watchlist.
  *
- * Substring, not word-boundary. A boundary test is wrong for Hebrew — the
- * prefixes ל/ב/ה/ו/ש/כ/מ attach directly to the noun, so `למכבי` would fail a
- * boundary test against `מכבי` and the story would be missed. The cost is that
- * a short Latin term over-matches (`City` inside `Capacity`); that costs one
- * extra line in a prompt the verify run then rejects, where the Hebrew miss
- * costs the story itself. The skill tells admins to keep Latin terms specific.
+ * **Watch terms are plain substrings.** A naive boundary test is wrong for
+ * Hebrew — the prefixes ל/ב/ה/ו/ש/כ/מ attach directly to the noun, so `למכבי`
+ * would fail one against `מכבי` and the story would be missed. The cost is
+ * that a short Latin term over-matches (`City` inside `Capacity`); that costs
+ * one extra line in a prompt the verify run then rejects, where the Hebrew
+ * miss costs the story itself. The skill tells admins to keep terms specific.
  *
- * Exclusion is checked first and is unconditional: an excluded item is dropped
- * even when three watch terms hit it.
+ * **Exclusions match at a word start**, prefixes looked through. Exclusion is
+ * checked first and is unconditional: an excluded item is dropped even when
+ * three watch terms hit it, and it is dropped before any run or digest can
+ * show it — so the two directions are not symmetric, and the exclusion is the
+ * one that must not fire on an accident. `נשים` ("women") inside `אנשים`
+ * ("people") dropped ordinary football headlines until 2026-09-06.
  */
 export function matchItem(
   item: Pick<FeedItem, "title" | "description">,
@@ -83,7 +197,9 @@ export function matchItem(
 
   for (const raw of exclude) {
     const needle = normalize(raw);
-    if (needle && text.includes(needle)) return { terms: [], excluded: true };
+    if (needle && matchesAtWordStart(text, needle)) {
+      return { terms: [], excluded: true, excludedBy: raw };
+    }
   }
 
   const hits: string[] = [];

package/examples/extensions/feed-watch/skill/SKILL.md

@@ -60,6 +60,8 @@ Settings are per-space config keys under `feed-watch.`:
 | `quiet_hours` | `HH:MM-HH:MM` local, or empty. No runs are opened inside it. |
 | `max_per_hour` | `0`–`12`. `0` means digest-only. |
 | `batch_minutes` | `0`–`30`. How long to wait for other outlets to catch up. |
+| `verify_max_items` | `1`–`50`, default `20`. Most items one verify run carries. |
+| `digest_max_items` | `1`–`400`, default `200`. Most items the daily digest carries. |
 | `timezone` | IANA zone for quiet hours and timestamps. |
 
 Read one with:
@@ -103,6 +105,21 @@ also hits *Capacity*. Prefer specific terms (`Man City`, `Real Madrid`) and use
 `exclude` for the categories the space does not care about (`נוער`, `נשים`,
 `fantasy`, `WSL`).
 
+`exclude` is matched **at the start of a word**, not anywhere in it. The Hebrew
+prefixes are looked through, so `נשים` still drops `הנשים`, `לנשים` and
+`בנשים` — but not `אנשים` ("people"), which merely contains the letters. The
+end of the word is still open, so `Women` drops `Women's` and `הימור` drops
+`הימורים`. An exclusion shorter than four characters is matched at a bare word
+boundary with no prefixes looked through: at three letters the prefixed forms
+are ordinary words.
+
+An exclusion still only drops headlines in the language it was written in:
+`נשים` does not touch `Women's Champions League`. When a category is genuinely
+unwanted, list every form the feeds publish it in — and remember the list is
+only ever as good as its substrings. A category that must never be reported
+also needs a line in the space's `AGENTS.md`, which is what catches the item
+the substrings miss.
+
 ### Who may change it
 
 These keys are behind the `config.set` permission, which is **admin-only** by
@@ -126,3 +143,11 @@ default.
   The next new item is the first one that can wake anything.
 - `max_per_hour` may be spent, or the clock may be inside `quiet_hours`. Neither
   loses anything: those items still appear in the next daily digest.
+
+### If a run carries fewer items than you expected
+
+A verify run stops at `verify_max_items` (20 by default), newest first. The
+overflow is not lost — it waits for the next run and it is in the daily digest
+regardless — but it means a backlog drains over several runs rather than
+arriving in one. The poller says so in its log: `items=116 verified=20
+deferred=96`. This is what a first poll after a long outage looks like.

package/examples/extensions/feed-watch/watch.ts

@@ -19,6 +19,7 @@ import {
   formatItemLines,
   inWindow,
   localHhMm,
+  newestFirst,
   resolveTimezone,
   type StoredItem,
   toStoredItem,
@@ -389,7 +390,19 @@ export async function pollSpace(
     if (olderThanBuffer(item, now)) continue;
 
     const match = matchItem(item, cfg.terms, cfg.exclude);
-    if (match.excluded) continue;
+    if (match.excluded) {
+      // The one drop that leaves no other trace: an excluded item never
+      // reaches a run, a digest or the buffer, so without this line an
+      // exclusion that fires wrongly is invisible from chat and from the
+      // journal alike. Debug, and only on the reporting path — the seed tick
+      // would write one of these per item of a whole feed.
+      log.debug("feed-watch: item dropped by an exclude term", {
+        spaceId,
+        needle: match.excludedBy,
+        title: item.title,
+      });
+      continue;
+    }
     const terms = mergeTerms(match.terms, forcedTerm);
     if (terms.length === 0) continue;
 
@@ -456,16 +469,26 @@ export async function pollSpace(
       deferred = "task_pending";
     } else {
       const byId = new Map(buffered.map((b) => [b.id, b]));
-      const items = pending.itemIds
+      const matured = pending.itemIds
         .map((id) => byId.get(id))
         .filter((i): i is StoredItem => i !== undefined);
-      if (items.length === 0) {
+      if (matured.length === 0) {
         // Every item in the batch aged out of the buffer before it matured.
         // There is nothing to verify; drop the batch rather than open a run
         // with an empty item list.
         log.debug("feed-watch: batch expired before it matured", { spaceId });
         pending = null;
       } else {
+        // Newest first, then cut. The template asks the agent to open the link
+        // for every line, so a batch that outgrew `verify_max_items` is not a
+        // bigger run, it is an unfollowable one — 116 items in one run on
+        // 2026-09-06 produced a single line and 115 unexamined items. The
+        // overflow is kept, not dropped: it stays in `pending` (already mature,
+        // so the next tick opens it under `max_per_hour`) and it is in the
+        // buffer the daily digest reads either way.
+        const ordered = newestFirst(matured);
+        const items = ordered.slice(0, cfg.verifyMaxItems);
+        const overflow = ordered.slice(cfg.verifyMaxItems);
         const runAs = resolveRunAs(
           deps.configUpdatedBy(spaceId, "feed-watch.enabled"),
           log,
@@ -475,11 +498,22 @@ export async function pollSpace(
         const taskId = deps.createTask(spaceId, prompt, runAs);
         recentRuns.push(now);
         created = { taskId, itemCount: items.length };
-        pending = null;
+        // Same `startedAt`: this batch has already served its `batch_minutes`,
+        // and restarting the window would hold the overflow another round for
+        // outlets that have long since filed.
+        pending =
+          overflow.length > 0
+            ? {
+                startedAt: pending.startedAt,
+                itemIds: overflow.map((i) => i.id),
+              }
+            : null;
         log.info("feed-watch: opened a verify run", {
           spaceId,
           taskId,
-          items: items.length,
+          items: matured.length,
+          verified: items.length,
+          deferred: overflow.length,
           terms: [...new Set(items.flatMap((i) => i.terms))],
         });
       }