@saadnvd1/agent-os 0.3.497 → 0.3.499

package/components/Chat/Messages.tsx

@@ -5,6 +5,8 @@ import type { ChatItem } from "@/lib/chat/events";
 import { cn } from "@/lib/utils";
 import { leadingCommand } from "@/lib/chat/commands";
 import { compactedLine } from "@/lib/chat/stale";
+import { splitInlineCode, splitUserText } from "@/lib/chat/user-text";
+import { CodeBlock } from "./Code";
 import { CopyButton } from "./CopyButton";
 import { ImageThumb } from "./ImageThumb";
 import { Markdown } from "./Markdown";
@@ -13,13 +15,44 @@ import { useRowState } from "./rowState";
 
 type Of<K extends ChatItem["kind"]> = Extract<ChatItem, { kind: K }>;
 
+function Prose({ text }: { text: string }) {
+  return (
+    <>
+      {splitInlineCode(text).map((p, i) =>
+        p.code ? (
+          <code
+            key={i}
+            className="bg-foreground/[0.06] rounded px-1 py-0.5 font-mono text-[0.9em]"
+          >
+            {p.text}
+          </code>
+        ) : (
+          <span key={i}>{p.text}</span>
+        )
+      )}
+    </>
+  );
+}
+
 function UserText({ text }: { text: string }) {
-  const command = leadingCommand(text);
-  if (!command) return <>{text}</>;
   return (
     <>
-      <span className="text-primary font-mono">{command}</span>
-      {text.slice(command.length)}
+      {splitUserText(text).map((part, i) => {
+        if (part.kind === "code")
+          return (
+            <div key={i} className="my-1.5 first:mt-0 last:mb-0">
+              <CodeBlock code={part.code} language={part.language} />
+            </div>
+          );
+        const command = i === 0 ? leadingCommand(part.text) : null;
+        if (!command) return <Prose key={i} text={part.text} />;
+        return (
+          <span key={i}>
+            <span className="text-primary font-mono">{command}</span>
+            <Prose text={part.text.slice(command.length)} />
+          </span>
+        );
+      })}
     </>
   );
 }

package/lib/chat/user-text.ts

@@ -0,0 +1,64 @@
+export type UserTextPart =
+  | { kind: "text"; text: string }
+  | { kind: "code"; code: string; language?: string };
+
+const OPEN = /^ {0,3}(`{3,}|~{3,})\s*([\w+-]*)[^\n`]*$/;
+
+// A sent message split at its fenced code blocks. Everything else stays the
+// text it was typed as: no emphasis, no HTML, no reflow. An unclosed fence
+// runs to the end, as in markdown.
+export function splitUserText(text: string): UserTextPart[] {
+  if (!text.includes("```") && !text.includes("~~~"))
+    return [{ kind: "text", text }];
+  const parts: UserTextPart[] = [];
+  let prose: string[] = [];
+  let code: string[] | null = null;
+  let fence = "";
+  let language: string | undefined;
+  const flushProse = () => {
+    if (prose.length) parts.push({ kind: "text", text: prose.join("\n") });
+    prose = [];
+  };
+  for (const line of text.replace(/\r\n?/g, "\n").split("\n")) {
+    if (code === null) {
+      const m = OPEN.exec(line);
+      if (m) {
+        flushProse();
+        code = [];
+        fence = m[1];
+        language = m[2] || undefined;
+      } else prose.push(line);
+      continue;
+    }
+    const t = line.trim();
+    if (
+      t.startsWith(fence[0]) &&
+      t.length >= fence.length &&
+      !/[^`~]/.test(t) &&
+      t[0] === fence[0]
+    ) {
+      parts.push({ kind: "code", code: code.join("\n"), language });
+      code = null;
+    } else code.push(line);
+  }
+  if (code !== null)
+    parts.push({ kind: "code", code: code.join("\n"), language });
+  flushProse();
+  return parts;
+}
+
+// Backtick spans inside prose, split out so they can be set in monospace.
+export function splitInlineCode(
+  text: string
+): { code: boolean; text: string }[] {
+  const out: { code: boolean; text: string }[] = [];
+  let last = 0;
+  for (const m of text.matchAll(/(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/g)) {
+    if (m.index > last)
+      out.push({ code: false, text: text.slice(last, m.index) });
+    out.push({ code: true, text: m[2] });
+    last = m.index + m[0].length;
+  }
+  if (last < text.length) out.push({ code: false, text: text.slice(last) });
+  return out;
+}

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.497",
+  "version": "0.3.499",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"