@saadnvd1/agent-os 0.3.498 → 0.3.499

package/lib/db/migrations.ts

@@ -1507,6 +1507,20 @@ const migrations: Migration[] = [
         );
     },
   },
+  {
+    id: 67,
+    name: "orchestrator_event_log_suppressed",
+    up: (db) => {
+      // A capped event is logged as suppressed so a drop leaves a trace.
+      const columns = db
+        .prepare(`PRAGMA table_info(orchestrator_event_log)`)
+        .all() as { name: string }[];
+      if (!columns.some((c) => c.name === "suppressed"))
+        db.exec(
+          `ALTER TABLE orchestrator_event_log ADD COLUMN suppressed TEXT`
+        );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/orchestrator/armed.ts

@@ -276,7 +276,8 @@ async function merge(
     return;
   }
   setArmed(task.id, false);
-  // The merged condition would say it again on the next diff.
+  // The merged condition would say it again on the next diff, so this armed
+  // line is the one merged notice. deliver.ts never caps `armed:` events.
   markTold(workspaceId, `merged:${task.id}`, task.id);
   event(
     workspaceId,

package/lib/orchestrator/deliver.ts

@@ -4,10 +4,13 @@ import {
   isAnswer,
   isAwayEvent,
   deliveriesSince,
+  type EventRow,
   lastDeliveredAt,
   logDeliveries,
+  logSuppressed,
   markDelivered,
   pendingEvents,
+  suppressedSince,
   unlogDeliveries,
 } from "./events";
 import { isPaused } from "./pause";
@@ -20,6 +23,25 @@ export const LOW_HOLD_MS = 10 * 60 * 1000;
 export const SUBJECT_CAP = 6;
 const HOUR = 60 * 60 * 1000;
 
+// Terminal and decision events are never capped: a merge, a gate refusal or
+// failure, an escalation to Saad, a drop or close, a review verdict, an
+// ask's answer. A finished task raises nothing after them, so a dropped one
+// is gone for good. The cap is for repeating noise (CI green, stack steps).
+const UNCAPPED = [
+  "merged:",
+  "blocked:",
+  "stack:merged:",
+  "stack:failed:",
+  "stack-status:",
+  "once:armed:", // merged, refused, failed, disarmed, closed
+  "once:review:",
+  "once:ask:",
+  "once:conflict:",
+  "once:plan-done:",
+];
+export const bypassesCap = (e: Pick<EventRow, "key">) =>
+  UNCAPPED.some((p) => e.key.startsWith(p));
+
 export const AGENTOS_SENDER = "agentos";
 
 export type ChatSender = (
@@ -47,7 +69,8 @@ const failing = new Map<string, { failures: number; until: number }>();
 // Rows are marked delivered before the send so a restart can't send them
 // twice. The cost: if the process dies between marking and the send
 // reaching the worker, those events are lost rather than repeated. That's
-// the cheaper failure for a paid turn, and the next change re-raises them.
+// the cheaper failure for a paid turn. (A condition that still holds is
+// re-raised by the next change; a one-off event is not.)
 export async function deliverEvents(opts: {
   workspaceId: string;
   orchestratorId: string;
@@ -62,22 +85,33 @@ export async function deliverEvents(opts: {
   if ((failing.get(workspaceId)?.until ?? 0) > now) return null;
   if (now - lastDeliveredAt(workspaceId) < BATCH_WINDOW_MS) return null;
 
-  // Over a subject's hourly cap: dropped, not sent later.
+  // Over a subject's hourly cap: dropped, not sent later, but logged as
+  // suppressed and counted into the subject's next line. Terminal events
+  // skip the cap.
   const counts = new Map<string, number>();
-  const capped: number[] = [];
+  const capped: EventRow[] = [];
   const pending = pendingEvents(workspaceId).filter((e) => {
-    if (!e.subject) return true;
+    if (!e.subject || bypassesCap(e)) return true;
     const n =
       counts.get(e.subject) ??
       deliveriesSince(workspaceId, e.subject, now - HOUR);
     if (n >= SUBJECT_CAP) {
-      capped.push(e.id);
+      capped.push(e);
       return false;
     }
     counts.set(e.subject, n + 1);
     return true;
   });
-  if (capped.length) markDelivered(capped, now);
+  if (capped.length) {
+    markDelivered(
+      capped.map((e) => e.id),
+      now
+    );
+    logSuppressed(workspaceId, capped, now);
+    console.warn(
+      `[orchestrator] ${capped.length} event(s) over the hourly cap dropped: ${capped.map((e) => e.key).join(", ")}`
+    );
+  }
   if (!pending.length) return null;
   const oldestLow = Math.min(
     ...pending.filter((e) => e.low).map((e) => Date.parse(e.created_at))
@@ -85,7 +119,15 @@ export async function deliverEvents(opts: {
   if (pending.every((e) => e.low) && now - oldestLow < LOW_HOLD_MS) return null;
 
   const ids = pending.map((e) => e.id);
-  const text = [...new Set(pending.map((e) => e.line))].join("\n");
+  const lines = [...new Set(pending.map((e) => e.line))];
+  for (const subject of new Set(pending.map((e) => e.subject))) {
+    const n = subject ? suppressedSince(workspaceId, subject, now - HOUR) : 0;
+    if (n)
+      lines.push(
+        `(+${n} capped event${n === 1 ? "" : "s"} for ${subject} in the last hour)`
+      );
+  }
+  const text = lines.join("\n");
   // Saad's answers to asks, shown in chat as his decisions.
   const decided = [...new Set(pending.filter(isAnswer).map((e) => e.line))];
   const origin: ChatOrigin = {

package/lib/orchestrator/events.ts

@@ -238,6 +238,38 @@ export function logDeliveries(
   )();
 }
 
+// Events held back by the subject cap: logged with the line, never counted
+// as deliveries.
+export function logSuppressed(
+  workspaceId: string,
+  events: Pick<EventRow, "subject" | "key">[],
+  at: number
+): void {
+  const stmt = db.prepare(
+    `INSERT INTO orchestrator_event_log (workspace_id, subject, delivered_at, suppressed) VALUES (?, ?, ?, ?)`
+  );
+  db.transaction(() => {
+    for (const e of events) stmt.run(workspaceId, e.subject, iso(at), e.key);
+  })();
+}
+
+// Events suppressed for a subject in the window.
+export function suppressedSince(
+  workspaceId: string,
+  subject: string,
+  since: number
+): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM orchestrator_event_log
+         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?
+           AND suppressed IS NOT NULL`
+      )
+      .get(workspaceId, subject, iso(since)) as { n: number }
+  ).n;
+}
+
 export function unlogDeliveries(ids: number[]): void {
   const stmt = db.prepare(`DELETE FROM orchestrator_event_log WHERE id = ?`);
   db.transaction(() => ids.forEach((id) => stmt.run(id)))();
@@ -246,7 +278,7 @@ export function unlogDeliveries(ids: number[]): void {
 export function lastDeliveredAt(workspaceId: string): number {
   const row = db
     .prepare(
-      `SELECT MAX(delivered_at) AS at FROM orchestrator_event_log WHERE workspace_id = ?`
+      `SELECT MAX(delivered_at) AS at FROM orchestrator_event_log WHERE workspace_id = ? AND suppressed IS NULL`
     )
     .get(workspaceId) as { at: string | null };
   return row.at ? Date.parse(row.at) : 0;
@@ -261,7 +293,8 @@ export function deliveriesSince(
     db
       .prepare(
         `SELECT COUNT(*) AS n FROM orchestrator_event_log
-         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?`
+         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?
+           AND suppressed IS NULL`
       )
       .get(workspaceId, subject, iso(since)) as { n: number }
   ).n;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.498",
+  "version": "0.3.499",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"