@code-yeongyu/senpi 2026.10.21-1 → 2026.10.21-2

package/dist/core/extensions/builtin/terminal/monitor-notify.js

@@ -1,9 +1,11 @@
 import { MONITOR_NOTIFICATION_CUSTOM_TYPE } from "../monitor-state-event.js";
+import { monitorDetails } from "./monitor-notify-details.js";
+import { buildWakeMessage, eventBody, renderedLength, WAKE_BUDGET_PAUSE_NOTICE } from "./monitor-notify-format.js";
+import { OverflowBook } from "./monitor-overflow.js";
+import { fitWake } from "./monitor-wake-fit.js";
+import { WakePacer } from "./monitor-wake-pacing.js";
 import { getTerminalNotificationDelivery } from "./notify.js";
-import { sanitizeTerminalOutput } from "./output-format.js";
-import { FIRE_BUDGET_AUTO_MUTE_SUMMARY } from "./shared.js";
-const SYSTEM_REMINDER_OPEN = "<system-reminder>";
-const SYSTEM_REMINDER_CLOSE = "</system-reminder>";
+import { RUNAWAY_PAUSE_SUMMARY_PREFIX } from "./shared.js";
 const QUEUE_OVERHEAD_CHARS = 512;
 const WAKE_STREAK_QUIET_GAP_MULTIPLIER = 2;
 const systemScheduler = {
@@ -23,42 +25,20 @@ function resolveSettings(settings) {
         maxLinesPerInjection: boundedPositiveInt(settings.maxLinesPerInjection, 50, 1, 200),
         maxCharsPerInjection: boundedPositiveInt(settings.maxCharsPerInjection, 4096, 512, 16_384),
         wakeBudget: boundedPositiveInt(settings.wakeBudget, 5, 1, 100),
+        wakesPerHour: boundedPositiveInt(settings.wakesPerHour, 12, 1, 3600),
     };
 }
-function eventBody(event) {
-    const value = event.type === "line" ? event.line : event.summary;
-    return sanitizeTerminalOutput(value)
-        .replace(/[\r\n]+/g, " ")
-        .trimEnd();
-}
-function clip(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    if (maxChars <= 3)
-        return text.slice(0, maxChars);
-    return `${text.slice(0, maxChars - 3)}...`;
-}
-function formatEvents(events) {
-    const groups = new Map();
-    for (const event of events) {
-        const group = groups.get(event.id) ?? { description: event.description, bodies: [] };
-        group.bodies.push(eventBody(event));
-        groups.set(event.id, group);
-    }
-    return [...groups.values()]
-        .map((group) => `Monitor event(${group.description}): ${group.bodies.join("\n")}`)
-        .join("\n");
-}
 /**
  * Session-scoped monitor delivery queue. It preserves the terminal runtime as the authoritative,
- * bounded event history while retaining only one capped coalescing batch for chat injection.
+ * bounded event history while retaining only capped per-monitor batches for chat injection. A
+ * wake is filled by whole monitors; a monitor that does not fit stays queued for the next wake.
  */
 export class MonitorNotifier {
     #deps;
     #scheduler;
+    #pacer;
+    #overflow;
     #events = [];
-    #eventChars = 0;
-    #overflow = new Map();
     #lastInjectionAt = new Map();
     #lastInjectedBatch = new Map();
     #timer;
@@ -68,6 +48,8 @@ export class MonitorNotifier {
     constructor(deps) {
         this.#deps = deps;
         this.#scheduler = deps.scheduler ?? systemScheduler;
+        this.#pacer = new WakePacer((id) => deps.wakesPerHour?.(id));
+        this.#overflow = new OverflowBook(deps.spillOverflow);
     }
     notifyEvent(event) {
         if (event.type === "summary") {
@@ -77,17 +59,24 @@ export class MonitorNotifier {
         if (!getTerminalNotificationDelivery(this.#deps, MONITOR_NOTIFICATION_CUSTOM_TYPE))
             return;
         const settings = resolveSettings(this.#deps.getSettings());
-        const rendered = `Monitor event(${event.description}): ${eventBody(event)}`;
         const queueLimit = Math.max(1, settings.maxCharsPerInjection - QUEUE_OVERHEAD_CHARS);
+        const own = this.#events.filter((queued) => queued.id === event.id);
+        const ownChars = own.reduce((total, queued) => total + renderedLength(queued), 0);
         if (event.type !== "summary" &&
-            (this.#events.length >= settings.maxLinesPerInjection || this.#eventChars + rendered.length > queueLimit)) {
-            this.#recordOverflow(event);
+            (own.length >= settings.maxLinesPerInjection ||
+                ownChars + renderedLength(event) > queueLimit ||
+                this.#overflow.count(event.id) > 0)) {
+            this.#overflow.record(event, eventBody(event));
         }
         else {
             this.#events.push(event);
-            this.#eventChars += rendered.length;
         }
-        this.#schedule(settings.coalesceWindowMs);
+        // A paced monitor out of tokens is not flushed before its next token: no wasted wake-ups.
+        const now = this.#scheduler.now();
+        const delay = event.type === "summary"
+            ? settings.coalesceWindowMs
+            : Math.max(settings.coalesceWindowMs, this.#pacer.readyAt(event.id, now) - now);
+        this.#schedule(delay);
     }
     /** Any explicit user or tool activity breaks a consecutive monitor-only wake streak. */
     noteActivity() {
@@ -110,23 +99,9 @@ export class MonitorNotifier {
         this.#timer = undefined;
         this.#scheduledAt = undefined;
         this.#events = [];
-        this.#eventChars = 0;
         this.#overflow.clear();
         this.#lastInjectedBatch.clear();
-    }
-    #recordOverflow(event) {
-        const overflow = this.#overflow.get(event.id) ?? {
-            id: event.id,
-            description: event.description,
-            count: 0,
-            kinds: new Set(),
-            humanInput: false,
-        };
-        overflow.count++;
-        overflow.kinds.add(event.type);
-        if (event.type === "line" && event.humanInput === true)
-            overflow.humanInput = true;
-        this.#overflow.set(event.id, overflow);
+        this.#pacer.clear();
     }
     #schedule(delayMs) {
         const due = this.#scheduler.now() + delayMs;
@@ -137,6 +112,9 @@ export class MonitorNotifier {
         this.#scheduledAt = due;
         this.#timer = this.#scheduler.setTimeout(() => this.#flush(), delayMs);
     }
+    #pendingIds() {
+        return new Set([...this.#events.map((event) => event.id), ...this.#overflow.ids()]);
+    }
     #flush() {
         this.#timer = undefined;
         this.#scheduledAt = undefined;
@@ -147,83 +125,84 @@ export class MonitorNotifier {
         }
         const settings = resolveSettings(this.#deps.getSettings());
         const now = this.#scheduler.now();
-        const pendingIds = new Set([...this.#events.map((event) => event.id), ...this.#overflow.keys()]);
+        const pendingIds = this.#pendingIds();
         if (pendingIds.size === 0)
             return;
         const summaryIds = new Set(this.#events.filter((event) => event.type === "summary").map((event) => event.id));
-        const ready = new Set([...pendingIds].filter((id) => {
+        const ready = [...pendingIds].filter((id) => {
             if (summaryIds.has(id))
                 return true;
             const last = this.#lastInjectionAt.get(id);
-            return last === undefined || now - last >= settings.rateLimitMs;
-        }));
-        if (ready.size === 0) {
-            this.#scheduleNextRateLimit(pendingIds, now, settings);
+            if (last !== undefined && now - last < settings.rateLimitMs)
+                return false;
+            return this.#pacer.readyAt(id, now) <= now;
+        });
+        if (ready.length === 0) {
+            this.#scheduleNext(pendingIds, now, settings);
             return;
         }
         const fingerprints = this.#batchFingerprints(ready);
         const suppressedIds = new Set([...fingerprints]
             .filter(([id, fingerprint]) => this.#lastInjectedBatch.get(id) === fingerprint)
             .map(([id]) => id));
-        const injectedIds = new Set([...ready].filter((id) => !suppressedIds.has(id)));
-        const selected = this.#events.filter((event) => injectedIds.has(event.id));
-        const deferred = this.#events.filter((event) => !ready.has(event.id));
-        if (injectedIds.size === 0) {
-            this.#discardSuppressed(deferred, now, settings);
+        this.#events = this.#events.filter((event) => !suppressedIds.has(event.id));
+        const wake = fitWake(this.#events, this.#overflow, ready.filter((id) => !suppressedIds.has(id)), summaryIds, settings.maxCharsPerInjection);
+        if (wake.size === 0) {
+            this.#scheduleNext(this.#pendingIds(), now, settings);
             return;
         }
-        const overflowCount = [...this.#overflow.values()]
-            .filter((overflow) => injectedIds.has(overflow.id))
-            .reduce((total, overflow) => total + overflow.count, 0);
+        const injectedIds = new Set(wake.keys());
+        const selected = [...wake.values()].flatMap((share) => share.events);
+        const delivered = new Set(selected);
         if (this.#lastWakeAt !== undefined &&
             now - this.#lastWakeAt > settings.rateLimitMs * WAKE_STREAK_QUIET_GAP_MULTIPLIER) {
             this.#consecutiveWakes = 0;
         }
         const deliversSummary = selected.some(
-        // A fire-budget auto-mute summary is a mute, not a completion: exempting it keeps the
+        // A runaway-guard pause summary is a pause, not a completion: exempting it keeps the
         // session-global wake streak — the notifier's own pause state — from being cleared.
-        (event) => event.type === "summary" && event.summary !== FIRE_BUDGET_AUTO_MUTE_SUMMARY);
+        (event) => event.type === "summary" && !event.summary.startsWith(RUNAWAY_PAUSE_SUMMARY_PREFIX));
         const reachesBudget = !deliversSummary && this.#consecutiveWakes + 1 >= settings.wakeBudget;
-        const pauseNotice = reachesBudget
-            ? "Monitor paused after repeated updates. Completion still wakes this session; peek bash_output or re-arm only for intermediate events."
-            : "";
-        const content = this.#buildMessage(selected, overflowCount, pauseNotice, settings.maxCharsPerInjection);
-        const details = { monitors: this.#monitorDetails(selected, injectedIds) };
+        const notices = [...wake].map(([id, share]) => (share.whole ? this.#overflow.notice(id) : ""));
+        const content = buildWakeMessage(selected, notices, reachesBudget ? WAKE_BUDGET_PAUSE_NOTICE : "", settings.maxCharsPerInjection);
+        const details = { monitors: monitorDetails(selected, injectedIds, this.#overflow) };
         delivery.send(content, reachesBudget ? { forceWake: true, details } : { details });
         this.#lastWakeAt = now;
-        for (const id of injectedIds) {
+        for (const [id, share] of wake) {
+            if (share.events.some((event) => event.type === "summary"))
+                this.#pacer.forget(id);
+            else
+                this.#pacer.spend(id, now);
             this.#lastInjectionAt.set(id, now);
-            this.#overflow.delete(id);
-            const fingerprint = fingerprints.get(id);
+            // A monitor that sent only a prefix keeps its remaining lines and overflow for the next wake.
+            if (share.whole)
+                this.#overflow.delete(id);
+            const fingerprint = share.whole ? fingerprints.get(id) : undefined;
             if (fingerprint === undefined)
                 this.#lastInjectedBatch.delete(id);
             else
                 this.#lastInjectedBatch.set(id, fingerprint);
         }
-        this.#events = deferred;
-        this.#eventChars = deferred.reduce((total, event) => total + `Monitor event(${event.description}): ${eventBody(event)}`.length, 0);
+        this.#events = this.#events.filter((event) => !delivered.has(event));
         this.#consecutiveWakes = deliversSummary ? 0 : this.#consecutiveWakes + 1;
         if (reachesBudget) {
+            // Only the monitors in this wake are paused; every other monitor keeps its held lines.
             this.#deps.pauseMonitors([...injectedIds]);
-            this.#events = [];
-            this.#eventChars = 0;
-            this.#overflow.clear();
             this.#consecutiveWakes = 0;
-            return;
         }
-        const remainingIds = new Set([...this.#events.map((event) => event.id), ...this.#overflow.keys()]);
+        const remainingIds = this.#pendingIds();
         if (remainingIds.size > 0)
-            this.#scheduleNextRateLimit(remainingIds, now, settings);
+            this.#scheduleNext(remainingIds, now, settings);
     }
-    #scheduleNextRateLimit(ids, now, settings) {
-        const nextAt = Math.min(...[...ids].map((id) => (this.#lastInjectionAt.get(id) ?? now) + settings.rateLimitMs));
+    #scheduleNext(ids, now, settings) {
+        const nextAt = Math.min(...[...ids].map((id) => Math.max((this.#lastInjectionAt.get(id) ?? now) + settings.rateLimitMs, this.#pacer.readyAt(id, now))));
         this.#schedule(Math.max(1, nextAt - now));
     }
     /** A ready monitor whose line-only batch matches its previous injection carries no new information. */
     #batchFingerprints(ids) {
         const fingerprints = new Map();
         for (const id of ids) {
-            if ((this.#overflow.get(id)?.count ?? 0) > 0)
+            if (this.#overflow.count(id) > 0)
                 continue;
             const batch = this.#events.filter((event) => event.id === id);
             if (batch.length === 0 || batch.some((event) => event.type !== "line"))
@@ -232,38 +211,5 @@ export class MonitorNotifier {
         }
         return fingerprints;
     }
-    #discardSuppressed(deferred, now, settings) {
-        this.#events = deferred;
-        this.#eventChars = deferred.reduce((total, event) => total + `Monitor event(${event.description}): ${eventBody(event)}`.length, 0);
-        const remainingIds = new Set([...deferred.map((event) => event.id), ...this.#overflow.keys()]);
-        if (remainingIds.size > 0)
-            this.#scheduleNextRateLimit(remainingIds, now, settings);
-    }
-    #monitorDetails(events, ids) {
-        return [...ids].map((id) => {
-            const own = events.filter((event) => event.id === id);
-            const overflow = this.#overflow.get(id);
-            const kinds = new Set(own.map((event) => event.type));
-            for (const kind of overflow?.kinds ?? [])
-                kinds.add(kind);
-            const humanInput = own.some((event) => event.type === "line" && event.humanInput === true) || overflow?.humanInput === true;
-            return {
-                id,
-                description: own[0]?.description ?? overflow?.description ?? id,
-                eventCount: own.length + (overflow?.count ?? 0),
-                kinds: [...kinds],
-                ...(humanInput ? { humanInput: true } : {}),
-            };
-        });
-    }
-    #buildMessage(events, overflowCount, pauseNotice, maxChars) {
-        const overflowNotice = overflowCount > 0
-            ? `[${overflowCount} additional event lines omitted; peek bash_output for full history.]`
-            : "";
-        const suffix = [overflowNotice, pauseNotice].filter(Boolean).join("\n");
-        const fixedChars = SYSTEM_REMINDER_OPEN.length + SYSTEM_REMINDER_CLOSE.length + (suffix ? suffix.length + 1 : 0);
-        const body = clip(formatEvents(events), Math.max(0, maxChars - fixedChars));
-        return `${SYSTEM_REMINDER_OPEN}${body}${body && suffix ? "\n" : ""}${suffix}${SYSTEM_REMINDER_CLOSE}`;
-    }
 }
 //# sourceMappingURL=monitor-notify.js.map

package/dist/core/extensions/builtin/terminal/monitor-overflow-file.d.ts

@@ -0,0 +1,7 @@
+import type { MonitorSpillResult } from "./monitor-overflow.ts";
+export declare function monitorOverflowPath(terminalDir: string, monitorId: string): string;
+/** Append `lines` to the watch's overflow file. Throws on a filesystem error. */
+export declare function appendMonitorOverflow(terminalDir: string, monitorId: string, lines: readonly string[], maxBytes?: number): MonitorSpillResult;
+/** Remove overflow files (and rotated copies) not written for longer than a durable watch lives. */
+export declare function sweepMonitorOverflowFiles(terminalDir: string, now?: number, maxAgeMs?: number): Promise<number>;
+//# sourceMappingURL=monitor-overflow-file.d.ts.map

package/dist/core/extensions/builtin/terminal/monitor-overflow-file.js

@@ -0,0 +1,67 @@
+/**
+ * Per-monitor overflow file: lines a paced persistent watch matched beyond what one wake carries.
+ * The wake names this file, so no matched line is lost to the batch cap. It lives in the session's
+ * terminal state dir (not the watch's own SENPI_MONITOR_STATE_DIR, which belongs to the command and
+ * is removed when the watch ends, while the agent may still need to read the overflow), and is
+ * bounded: past MONITOR_OVERFLOW_FILE_MAX_BYTES it rotates to one `.1` copy. Files untouched for
+ * longer than a durable watch can live are swept at session start.
+ */
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { readdir, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { DURABLE_MONITOR_EXPIRY_MS, MONITOR_OVERFLOW_FILE_MAX_BYTES } from "./shared.js";
+function overflowDir(terminalDir) {
+    return join(terminalDir, "overflow");
+}
+export function monitorOverflowPath(terminalDir, monitorId) {
+    return join(overflowDir(terminalDir), `${monitorId}.log`);
+}
+function isEnoent(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+/** Append `lines` to the watch's overflow file. Throws on a filesystem error. */
+export function appendMonitorOverflow(terminalDir, monitorId, lines, maxBytes = MONITOR_OVERFLOW_FILE_MAX_BYTES) {
+    const path = monitorOverflowPath(terminalDir, monitorId);
+    mkdirSync(overflowDir(terminalDir), { recursive: true, mode: 0o700 });
+    let size = 0;
+    try {
+        size = statSync(path).size;
+    }
+    catch (error) {
+        if (!isEnoent(error))
+            throw error;
+    }
+    const rotated = size >= maxBytes;
+    if (rotated)
+        renameSync(path, `${path}.1`);
+    appendFileSync(path, `${lines.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
+    return { path, rotated };
+}
+/** Remove overflow files (and rotated copies) not written for longer than a durable watch lives. */
+export async function sweepMonitorOverflowFiles(terminalDir, now = Date.now(), maxAgeMs = DURABLE_MONITOR_EXPIRY_MS) {
+    let names;
+    try {
+        names = await readdir(overflowDir(terminalDir));
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return 0;
+        throw error;
+    }
+    let removed = 0;
+    for (const name of names) {
+        if (!name.endsWith(".log") && !name.endsWith(".log.1"))
+            continue;
+        const path = join(overflowDir(terminalDir), name);
+        const info = await stat(path).catch(() => undefined);
+        if (info === undefined || now - info.mtimeMs <= maxAgeMs)
+            continue;
+        await unlink(path).catch((error) => {
+            if (!isEnoent(error))
+                throw error;
+        });
+        removed += 1;
+    }
+    return removed;
+}
+//# sourceMappingURL=monitor-overflow-file.js.map

package/dist/core/extensions/builtin/terminal/monitor-overflow.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Overflow bookkeeping of the monitor notifier: events that did not fit a monitor's batch. Line
+ * bodies are written to the monitor's overflow file in chunks (when a spill sink exists), and the
+ * wake that carries the monitor names the file; without a file the wake says how many were omitted.
+ */
+import type { MonitorEvent } from "./monitor-registry.ts";
+export interface MonitorSpillResult {
+    readonly path: string;
+    /** The file rotated to `<path>.1` while this chunk was written. */
+    readonly rotated: boolean;
+}
+export type MonitorSpill = (id: string, lines: readonly string[]) => MonitorSpillResult | undefined;
+export interface MonitorOverflow {
+    readonly id: string;
+    readonly description: string;
+    count: number;
+    kinds: Set<MonitorEvent["type"]>;
+    humanInput: boolean;
+    pending: string[];
+    spilled: number;
+    path: string | undefined;
+    rotated: boolean;
+}
+export declare class OverflowBook {
+    #private;
+    constructor(spill: MonitorSpill | undefined);
+    get(id: string): MonitorOverflow | undefined;
+    count(id: string): number;
+    ids(): string[];
+    record(event: MonitorEvent, body: string): void;
+    flush(id: string): void;
+    /** The notice a wake carries for this monitor's overflow; "" when nothing overflowed. */
+    notice(id: string): string;
+    delete(id: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=monitor-overflow.d.ts.map

package/dist/core/extensions/builtin/terminal/monitor-overflow.js

@@ -0,0 +1,75 @@
+/** Lines are written out in chunks of this many, so a burst never sits whole in memory. */
+const SPILL_CHUNK_LINES = 256;
+export class OverflowBook {
+    #spill;
+    #entries = new Map();
+    constructor(spill) {
+        this.#spill = spill;
+    }
+    get(id) {
+        return this.#entries.get(id);
+    }
+    count(id) {
+        return this.#entries.get(id)?.count ?? 0;
+    }
+    ids() {
+        return [...this.#entries.keys()];
+    }
+    record(event, body) {
+        const overflow = this.#entries.get(event.id) ?? {
+            id: event.id,
+            description: event.description,
+            count: 0,
+            kinds: new Set(),
+            humanInput: false,
+            pending: [],
+            spilled: 0,
+            path: undefined,
+            rotated: false,
+        };
+        overflow.count += 1;
+        overflow.kinds.add(event.type);
+        if (event.type === "line" && event.humanInput === true)
+            overflow.humanInput = true;
+        this.#entries.set(event.id, overflow);
+        if (this.#spill === undefined)
+            return;
+        overflow.pending.push(body);
+        if (overflow.pending.length >= SPILL_CHUNK_LINES)
+            this.flush(event.id);
+    }
+    flush(id) {
+        const overflow = this.#entries.get(id);
+        if (overflow === undefined || overflow.pending.length === 0 || this.#spill === undefined)
+            return;
+        const result = this.#spill(id, overflow.pending);
+        if (result !== undefined) {
+            overflow.spilled += overflow.pending.length;
+            overflow.path = result.path;
+            overflow.rotated ||= result.rotated;
+        }
+        overflow.pending = [];
+    }
+    /** The notice a wake carries for this monitor's overflow; "" when nothing overflowed. */
+    notice(id) {
+        const overflow = this.#entries.get(id);
+        if (overflow === undefined || overflow.count === 0)
+            return "";
+        const notices = [];
+        if (overflow.spilled > 0 && overflow.path !== undefined) {
+            const rotated = overflow.rotated ? `; earlier ones in ${overflow.path}.1` : "";
+            notices.push(`[${overflow.spilled} more lines in ${overflow.path}${rotated}]`);
+        }
+        const unspilled = overflow.count - overflow.spilled;
+        if (unspilled > 0)
+            notices.push(`[${unspilled} additional event lines omitted; peek bash_output for full history.]`);
+        return notices.join("\n");
+    }
+    delete(id) {
+        this.#entries.delete(id);
+    }
+    clear() {
+        this.#entries.clear();
+    }
+}
+//# sourceMappingURL=monitor-overflow.js.map

package/dist/core/extensions/builtin/terminal/monitor-registry.d.ts

@@ -7,6 +7,7 @@ import { type RegisterMonitorOptions } from "./command-monitor-source.ts";
 import { type RegisterFileMonitorOptions } from "./file-monitor-source.ts";
 import type { MonitorEndedEvent, MonitorEvent, MonitorFireWindow, MonitorRearmResult, MonitorResumeResult, MonitorSnapshotEntry } from "./monitor-types.ts";
 import type { RegisterRpcMonitorOptions } from "./rpc-monitor-source.ts";
+import type { MonitorRunawayGuard } from "./settings.ts";
 export type { RegisterMonitorOptions } from "./command-monitor-source.ts";
 export type { RegisterFileMonitorOptions } from "./file-monitor-source.ts";
 export { allocateMonitorId, type MonitorEndedEvent, type MonitorEndedReason, type MonitorEvent, type MonitorFireWindow, type MonitorLineEvent, type MonitorRearmResult, type MonitorResumeResult, type MonitorSnapshotEntry, type MonitorSummaryEvent, } from "./monitor-types.ts";
@@ -23,6 +24,15 @@ export interface MonitorRegistryOptions {
 export declare class MonitorRegistry {
     #private;
     constructor(emit: (event: MonitorEvent) => void, options?: MonitorRegistryOptions);
+    /** Apply the resolved runaway-guard settings; the registry outlives a reload, the settings do not. */
+    setRunawayGuard(guard: MonitorRunawayGuard): void;
+    /**
+     * Wake pacing of a live watch: only persistent command watches are paced. Returns the watch's
+     * own wake-rate override (undefined = the setting) or undefined when the watch is not paced.
+     */
+    wakePacing(id: string): {
+        readonly wakesPerHour: number | undefined;
+    } | undefined;
     /** Attachment parking is independent of persisted monitor mute and wake budgets. */
     setParked(parked: boolean): void;
     snapshot(): readonly MonitorSnapshotEntry[];

package/dist/core/extensions/builtin/terminal/monitor-registry.js

@@ -6,6 +6,7 @@
 import { CommandMonitorSource } from "./command-monitor-source.js";
 import { FileMonitorSource } from "./file-monitor-source.js";
 import { loadRpcMonitorSource } from "./rpc-monitor.lazy.js";
+import { DEFAULT_MONITOR_RUNAWAY_LINES_PER_MINUTE, DEFAULT_MONITOR_RUNAWAY_MINUTES } from "./shared.js";
 export { allocateMonitorId, } from "./monitor-types.js";
 export class MonitorRegistry {
     #emit;
@@ -17,6 +18,10 @@ export class MonitorRegistry {
     #host;
     #rpc;
     #parked = false;
+    #runawayGuard = {
+        linesPerMinute: DEFAULT_MONITOR_RUNAWAY_LINES_PER_MINUTE,
+        minutes: DEFAULT_MONITOR_RUNAWAY_MINUTES,
+    };
     constructor(emit, options) {
         this.#emit = emit;
         this.#onChange = options?.onChange;
@@ -27,11 +32,26 @@ export class MonitorRegistry {
             emitRaw: (event) => this.#emit(event),
             ended: (record, reason, exitCode) => this.#emitEnded(record, reason, exitCode),
             changed: () => this.#notifyChange(),
+            runawayGuard: () => this.#runawayGuard,
         };
         this.#host = host;
         this.#commands = new CommandMonitorSource(host);
         this.#files = new FileMonitorSource(host, options?.reserve);
     }
+    /** Apply the resolved runaway-guard settings; the registry outlives a reload, the settings do not. */
+    setRunawayGuard(guard) {
+        this.#runawayGuard = guard;
+    }
+    /**
+     * Wake pacing of a live watch: only persistent command watches are paced. Returns the watch's
+     * own wake-rate override (undefined = the setting) or undefined when the watch is not paced.
+     */
+    wakePacing(id) {
+        const record = this.#commands.get(id);
+        if (record === undefined || !record.persistent)
+            return undefined;
+        return { wakesPerHour: record.wakesPerHour };
+    }
     /** Attachment parking is independent of persisted monitor mute and wake budgets. */
     setParked(parked) {
         if (this.#parked === parked)
@@ -127,9 +147,12 @@ export class MonitorRegistry {
             const mutedDropped = "mutedDropped" in record ? record.mutedDropped : 0;
             if ("mutedDropped" in record)
                 record.mutedDropped = 0;
-            // A rearm (or any resume) restarts the rolling fire budget while keeping its window start.
+            // A rearm (or any resume) restarts the rolling fire count while keeping its window start,
+            // and gives the runaway guard a clean minute history.
             if ("fireWindow" in record && record.fireWindow !== undefined)
                 record.fireWindow.count = 0;
+            if ("runaway" in record)
+                record.runaway = undefined;
             resumed.push({ id: record.id, mutedDropped });
             if ("watch" in record && !this.#files.parked)
                 record.watch.resume();

package/dist/core/extensions/builtin/terminal/monitor-types.d.ts

@@ -67,5 +67,10 @@ export interface MonitorSourceHost {
     emitRaw(event: MonitorEvent): void;
     ended(record: MonitorRecordBase, reason: MonitorEndedReason, exitCode: number | null): void;
     changed(): void;
+    /** The current runaway-guard thresholds (settings can change across a reload). */
+    runawayGuard(): {
+        readonly linesPerMinute: number;
+        readonly minutes: number;
+    };
 }
 //# sourceMappingURL=monitor-types.d.ts.map

package/dist/core/extensions/builtin/terminal/monitor-wake-fit.d.ts

@@ -0,0 +1,9 @@
+import type { OverflowBook } from "./monitor-overflow.ts";
+import type { MonitorEvent } from "./monitor-registry.ts";
+export interface WakeShare {
+    readonly events: MonitorEvent[];
+    /** Every queued line went; when false the monitor keeps its rest and overflow for the next wake. */
+    readonly whole: boolean;
+}
+export declare function fitWake(queue: readonly MonitorEvent[], overflow: OverflowBook, candidates: readonly string[], summaryIds: ReadonlySet<string>, maxChars: number): Map<string, WakeShare>;
+//# sourceMappingURL=monitor-wake-fit.d.ts.map

package/dist/core/extensions/builtin/terminal/monitor-wake-fit.js

@@ -0,0 +1,34 @@
+/**
+ * Filling one monitor wake within `maxChars`, measured from the real wrapper (reminder tags, the
+ * pause notice, each monitor's actual overflow notice), never an assumed reserve. Monitors with a
+ * summary go first, then queue order; a monitor that does not fit whole waits for the next wake.
+ * Only when the first monitor alone is too big does it send a prefix of its lines; the rest stay
+ * queued. The line cap already holds per monitor at enqueue, so a wake is never clipped.
+ */
+import { monitorShareChars, SYSTEM_REMINDER_CLOSE, SYSTEM_REMINDER_OPEN, WAKE_BUDGET_PAUSE_NOTICE, } from "./monitor-notify-format.js";
+export function fitWake(queue, overflow, candidates, summaryIds, maxChars) {
+    const queued = [...new Set([...queue.map((event) => event.id), ...overflow.ids()])].filter((id) => candidates.includes(id));
+    const ordered = [...queued.filter((id) => summaryIds.has(id)), ...queued.filter((id) => !summaryIds.has(id))];
+    const budget = maxChars - SYSTEM_REMINDER_OPEN.length - SYSTEM_REMINDER_CLOSE.length - WAKE_BUDGET_PAUSE_NOTICE.length - 1;
+    const wake = new Map();
+    let chars = 0;
+    for (const id of ordered) {
+        overflow.flush(id);
+        const own = queue.filter((event) => event.id === id);
+        const share = monitorShareChars(own, overflow.notice(id));
+        if (chars + share <= budget || (wake.size === 0 && own.length === 0)) {
+            wake.set(id, { events: own, whole: true });
+            chars += share;
+        }
+        else if (wake.size === 0) {
+            let count = 1;
+            while (count < own.length && monitorShareChars(own.slice(0, count + 1), "") <= budget)
+                count += 1;
+            const prefix = own.slice(0, count);
+            wake.set(id, { events: prefix, whole: prefix.length === own.length && overflow.count(id) === 0 });
+            chars += monitorShareChars(prefix, "");
+        }
+    }
+    return wake;
+}
+//# sourceMappingURL=monitor-wake-fit.js.map

package/dist/core/extensions/builtin/terminal/monitor-wake-pacing.d.ts

@@ -0,0 +1,10 @@
+export declare class WakePacer {
+    #private;
+    constructor(rateOf: (id: string) => number | undefined);
+    /** When `id` next holds a whole token: `now` for an unpaced monitor or one with a token left. */
+    readyAt(id: string, now: number): number;
+    spend(id: string, now: number): void;
+    forget(id: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=monitor-wake-pacing.d.ts.map