pi-famulus 0.1.6 → 0.1.8

package/src/format.ts

@@ -8,6 +8,7 @@ import {
   formatFamulusWake,
   shellWakeTitle,
   type FamulusWake,
+  type MonitorOutputInfo,
   wakeDuration,
   type FormattedWake,
   type OverrunShell,
@@ -15,6 +16,21 @@ import {
   type WakeItem,
 } from "./wake";
 import { fill } from "./prompts.generated";
+import { shellStartStatus } from "./shell-start";
+import { statusGlyph } from "./tui/tool-component";
+
+/** `850ms`, `12s`, `4m05s`, `2h03m`, `3d04h`: the same style as `pi-famulus top`. */
+export function formatDuration(ms: number): string {
+  const total = Math.max(0, Math.floor(ms));
+  if (total < 1000) return `${total}ms`;
+  const secs = Math.floor(total / 1000);
+  if (secs < 60) return `${secs}s`;
+  const m = Math.floor(secs / 60);
+  if (m < 60) return `${m}m${String(secs % 60).padStart(2, "0")}s`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h${String(m % 60).padStart(2, "0")}m`;
+  return `${Math.floor(h / 24)}d${String(h % 24).padStart(2, "0")}h`;
+}
 
 export { FAMULUS_WAKE_LEAD_IN } from "./wake";
 export type { FormattedWake, WakeItem } from "./wake";
@@ -84,6 +100,8 @@ export interface TaskExitInfo {
   preview: string;
   /** Signal name from the manager, when the exit was a signal. */
   signal?: string;
+  /** The manager's end_reason, when it sent one. */
+  endReason?: string;
 }
 
 /** Shorten a command for one-line display inside notifications. */
@@ -92,6 +110,8 @@ function displayCommand(command: string): string {
 }
 
 function statusPhrase(info: TaskExitInfo): string {
+  const startFailure = shellStartStatus(info.endReason);
+  if (startFailure) return startFailure;
   const code = info.exitCode === null ? null : `exit code ${info.exitCode}`;
   switch (info.status) {
     case "completed":
@@ -160,17 +180,22 @@ export function backgroundRowText(
   taskId: string,
   item: { status: string; exitCode?: number | null; startedAt: number; endedAt?: number } | undefined,
   now: number,
+  indexed = false,
 ): { glyph: string; color: string; text: string } {
+  // Missing from the index: pruned after it finished, or not yet re-listed
+  // after a reload. Either way the state is unknown, so claim neither.
+  if (!item && indexed) return { glyph: "·", color: "dim", text: `${taskId} · status in /tasks` };
   if (!item || item.status === "running" || item.status === "pending") {
-    return { glyph: "⏵", color: "accent", text: `${taskId} running in background · /tasks` };
+    const { glyph, color } = statusGlyph(item?.status ?? "running");
+    return { glyph, color, text: `${taskId} running in background · /tasks` };
   }
-  const secs = ((item.endedAt ?? now) - item.startedAt) / 1000;
-  const dur = secs < 60 ? `${secs.toFixed(1)}s` : `${Math.floor(secs / 60)}m${Math.round(secs % 60)}s`;
+  const dur = formatDuration((item.endedAt ?? now) - item.startedAt);
   const exit = item.exitCode === null || item.exitCode === undefined ? "" : ` · exit ${item.exitCode}`;
   const ok = item.status === "completed" && (item.exitCode === 0 || item.exitCode === null || item.exitCode === undefined);
-  return ok
-    ? { glyph: "✓", color: "success", text: `${taskId} finished${exit} · ${dur}` }
-    : { glyph: "✗", color: "error", text: `${taskId} ${item.status}${exit} · ${dur} · /tasks` };
+  if (ok) return { ...statusGlyph("completed"), text: `${taskId} finished${exit} · ${dur}` };
+  // A non-zero exit fails the row even when the task "completed".
+  const { glyph, color } = statusGlyph(item.status === "completed" ? "failed" : item.status);
+  return { glyph, color, text: `${taskId} ${item.status}${exit} · ${dur} · /tasks` };
 }
 
 /** Injected payload for a batch of monitor output lines (§4.4 / §4.5). */
@@ -179,7 +204,7 @@ export function formatMonitorEvent(
   taskId: string,
   batchText: string,
   status?: string,
-  extras: { eventCount?: number; droppedLines?: number } = {},
+  extras: { eventCount?: number; droppedLines?: number; output?: MonitorOutputInfo } = {},
 ): FormattedWake {
   return formatFamulusWake({
     kind: "monitor",
@@ -189,6 +214,7 @@ export function formatMonitorEvent(
     event: batchText,
     ...(extras.eventCount !== undefined ? { eventCount: extras.eventCount } : {}),
     ...(extras.droppedLines !== undefined ? { droppedLines: extras.droppedLines } : {}),
+    ...(extras.output ? { output: extras.output } : {}),
   });
 }
 

package/src/index.ts

@@ -25,7 +25,7 @@ import { createAgentMessageTool, createContactSupervisorTool } from "./comms/too
 import { registerReplyCommand } from "./comms/reply-command";
 import { describeManagerSearch, getFamulusHome, loadConfig, resolveManagerPath, resolveSubagentConfig } from "./config";
 import type { TaskExitInfo } from "./format";
-import { ManagerClient, type ManagerEvent, type TaskRecord } from "./manager-client";
+import { EXTENSION_VERSION, ManagerClient, type ManagerEvent, type TaskRecord } from "./manager-client";
 import { createMonitorTool, exitEventFromRecord, MonitorRegistry } from "./monitor";
 import { admitAgentChild, reregisterAgentLeases } from "./subagent/admission";
 import { NotifyCenter } from "./notify";
@@ -48,6 +48,8 @@ import { SubagentRegistry } from "./subagent/registry";
 import { InProcessRunner } from "./subagent/runner";
 import { createSubagentTool } from "./subagent/tool";
 import { createTaskListTool, createTaskOutputTool, createTaskStopTool } from "./task-tools";
+import { createPiBinding, parkRuntime, takeParkedRuntime } from "./reload-handoff";
+import { registerFamulusCommand } from "./tui/famulus-command";
 import { registerFamulusMessageRenderers } from "./tui/message-renderers";
 import { registerTasksCommand } from "./tui/tasks-command";
 import { stderrPathFor } from "./tui/task-output-paths";
@@ -69,8 +71,31 @@ function toExitStatus(event: ManagerEvent): TaskExitInfo["status"] {
   return "failed";
 }
 
+interface FamulusRuntime {
+  attach(pi: ExtensionAPI): void;
+}
+
 export default function (pi: ExtensionAPI): void {
   if (isFamulusChildSession(pi)) return;
+  // A /reload parked the previous instance's runtime: adopt it so its shells,
+  // monitors and subagents keep running (see reload-handoff.ts). Another
+  // version's runtime is torn down instead; its code may not match ours.
+  const parked = takeParkedRuntime<FamulusRuntime>();
+  if (parked?.version === EXTENSION_VERSION) {
+    parked.runtime.attach(pi);
+    return;
+  }
+  const retiring = parked?.dispose().catch(() => {});
+  createFamulusRuntime(retiring).attach(pi);
+}
+
+/**
+ * Everything one pi session owns. It registers on a PiBinding rather than on
+ * pi directly, so a /reload can re-attach it to the next extension instance.
+ */
+function createFamulusRuntime(retiring?: Promise<unknown>): FamulusRuntime {
+  const binding = createPiBinding();
+  const pi = binding.api;
   registerBehaviorGuidelines(pi);
   const home = getFamulusHome();
   const config = loadConfig(home);
@@ -277,6 +302,7 @@ export default function (pi: ExtensionAPI): void {
       status: toExitStatus(event),
       exitCode: event.exit_code ?? null,
       ...(typeof event.signal === "string" && event.signal ? { signal: event.signal } : {}),
+      ...(event.end_reason ? { endReason: event.end_reason } : {}),
       durationMs: event.duration_ms ?? 0,
       outputPath: event.output_path ?? "",
       preview: readPreview(event.output_path, 4000),
@@ -356,7 +382,7 @@ export default function (pi: ExtensionAPI): void {
       noteStopRequested: (id) => monitorRegistry?.noteStopRequested(id),
     }),
   );
-  pi.registerTool(createMonitorTool(monitorRegistry));
+  pi.registerTool(createMonitorTool(monitorRegistry, () => workIndex));
   registerTasksCommand(pi, {
     getRegistry: () => subagentRegistry,
     getIndex: () => workIndex,
@@ -366,6 +392,12 @@ export default function (pi: ExtensionAPI): void {
     clock,
     syncWithManager: deps.syncWithManager,
   });
+  registerFamulusCommand(pi, {
+    extensionVersion: EXTENSION_VERSION,
+    managerPath,
+    describeSearch: () => describeManagerSearch(config, home),
+    getClient: () => client,
+  });
   monitorRegistry.onChange(() => {
     for (const mon of monitorRegistry.listActive()) {
       const existing = workIndex.get(mon.taskId);
@@ -432,8 +464,37 @@ export default function (pi: ExtensionAPI): void {
   // each child session via customTools, see below).
   pi.registerTool(createAgentMessageTool(comms, { kind: "parent" }, commsHost, clock));
 
-  pi.on("session_start", async (_event, startCtx) => {
+  /** Session whose runtime a /reload parked; the reloaded instance's session_start resumes it. */
+  let parkedSessionId: string | null = null;
+  const startFleetWidget = (startCtx: ExtensionContext) => {
+    if (!startCtx.hasUI) return;
+    fleetWidget = new FleetWidget({
+      index: workIndex,
+      getUi: () => (ctx?.hasUI ? (ctx.ui as never) : null),
+      clock,
+    });
+    fleetWidget.start();
+  };
+
+  pi.on("session_start", async (event, startCtx) => {
+    if (parkedSessionId !== null) {
+      const resumed = event.reason === "reload" && startCtx.sessionManager.getSessionId() === parkedSessionId;
+      parkedSessionId = null;
+      if (resumed) {
+        // Same session after /reload: the client, registry and monitors kept
+        // running; only the context and the UI belong to the new instance.
+        ctx = startCtx;
+        binding.ready();
+        startFleetWidget(startCtx);
+        void syncWithManager();
+        return;
+      }
+      binding.discardQueued();
+      await teardown();
+    }
+    await retiring;
     ctx = startCtx;
+    binding.ready();
     notifyCenter?.dispose();
     notifyCenter = new NotifyCenter({
       sendMessage: (msg, opts) => pi.sendMessage(msg, opts),
@@ -496,7 +557,7 @@ export default function (pi: ExtensionAPI): void {
         return;
       }
       if (event.event === "output" && event.task_id && typeof event.chunk === "string") {
-        monitorRegistry?.handleOutput(event.task_id, event.chunk, event.next_cursor);
+        monitorRegistry?.handleOutput(event.task_id, event.chunk, event.next_cursor, event.monitor_records);
         return;
       }
       if (event.event === "task_exited" && event.task_id) {
@@ -586,11 +647,15 @@ export default function (pi: ExtensionAPI): void {
         return tools;
       },
     });
+    // The registry outlives startCtx across a /reload, which leaves startCtx
+    // stale; its closures keep plain values instead.
+    const sessionId = startCtx.sessionManager.getSessionId();
+    const sessionCwd = startCtx.cwd;
     const transcripts = new TranscriptWriter(home, clock);
     const syncTranscript = (childId: string): string | undefined => {
       const handle = registry.handle(childId);
       if (!handle) return undefined;
-      return transcripts.sync(startCtx.sessionManager.getSessionId(), childId, handle.conversation());
+      return transcripts.sync(sessionId, childId, handle.conversation());
     };
     const runner = new InProcessRunner({
       createSession,
@@ -657,7 +722,7 @@ export default function (pi: ExtensionAPI): void {
     registry.setRunner(runner);
     subagentRegistry = registry;
     // Persist child records so `pi-famulus ls` / task_list can see in-process agents.
-    const sessionIdForAgents = () => startCtx.sessionManager.getSessionId();
+    const sessionIdForAgents = () => sessionId;
     const previousAgentStatus = new Map<string, string>();
     registry.onTransition((run) => {
       const sid = sessionIdForAgents();
@@ -743,7 +808,7 @@ export default function (pi: ExtensionAPI): void {
           workKind: c.workKind ?? "other",
           ...(c.queueMs !== undefined ? { queueMs: c.queueMs } : {}),
           ...(c.model !== undefined ? { model: c.model } : {}),
-          cwd: startCtx.cwd,
+          cwd: sessionCwd,
           ...(c.prompt !== undefined ? { prompt: c.prompt } : {}),
           ...(c.preamble !== undefined ? { preamble: c.preamble } : {}),
           ...(c.result?.text ? { text: c.result.text } : {}),
@@ -751,14 +816,7 @@ export default function (pi: ExtensionAPI): void {
         });
       }
     });
-    if (startCtx.hasUI) {
-      fleetWidget = new FleetWidget({
-        index: workIndex,
-        getUi: () => (ctx?.hasUI ? (ctx.ui as never) : null),
-        clock,
-      });
-      fleetWidget.start();
-    }
+    startFleetWidget(startCtx);
 
     // Connect in the background: a cold manager spawn must not stall the
     // first prompt. Tools call ensureAvailable() lazily before use.
@@ -770,11 +828,13 @@ export default function (pi: ExtensionAPI): void {
           if (c.protocolLevel() >= 4) void reconcileAgentLeases(c).catch(() => {});
           return;
         }
-        if (startCtx.hasUI) {
+        // A /reload may have replaced startCtx by now; report to the live one.
+        const current = ctx;
+        if (current?.hasUI) {
           const detail = c.lastError();
           const reason = detail ? ` (${detail})` : "";
           const searched = managerPath ? `using ${managerPath}` : `looked in: ${describeManagerSearch(config, home)}`;
-          startCtx.ui.notify(
+          current.ui.notify(
             `pi-famulus unavailable${reason}; ${searched}. ` +
               "Bash runs locally without auto-backgrounding, task_*/monitor are disabled, " +
               "and subagents cannot run bash. Install it or set PI_FAMULUS_MANAGER_PATH (see README Install).",
@@ -785,7 +845,7 @@ export default function (pi: ExtensionAPI): void {
       .catch(() => {});
   });
 
-  pi.on("session_shutdown", async () => {
+  const teardown = async (): Promise<void> => {
     exitWatchdog.dispose();
     fleetWidget?.dispose();
     fleetWidget = null;
@@ -807,6 +867,22 @@ export default function (pi: ExtensionAPI): void {
       }
     }
     ctx = null;
+  };
+  const runtime: FamulusRuntime = { attach: (host) => binding.attach(host) };
+
+  pi.on("session_shutdown", async (event) => {
+    if (event.reason === "reload" && ctx) {
+      // Keep the session's shells, monitors and subagents running; the
+      // reloaded instance adopts this runtime.
+      parkedSessionId = ctx.sessionManager.getSessionId();
+      fleetWidget?.dispose();
+      fleetWidget = null;
+      ctx = null;
+      binding.detach();
+      parkRuntime({ version: EXTENSION_VERSION, runtime, dispose: teardown });
+      return;
+    }
+    await teardown();
   });
 
   pi.on("agent_settled", async () => {
@@ -822,4 +898,6 @@ export default function (pi: ExtensionAPI): void {
     });
     return message ? { message } : undefined;
   });
+
+  return runtime;
 }

package/src/manager-client.ts

@@ -5,7 +5,7 @@
  *   lifetime-lock holder cleans up stale socket/pid files.
  * - Request/response multiplexing over a single long-lived connection.
  * - Server events dispatched to registered handlers.
- * - On unexpected disconnect: immediate then exponential-backoff reconnect for 22s,
+ * - On unexpected disconnect: immediate then exponential-backoff reconnect for 27s,
  *   re-hello after reconnect. If all attempts fail the client is marked unavailable
  *   and callers are expected to degrade (bash falls back to local execution).
  */
@@ -18,7 +18,8 @@ import { famulusPaths } from "./config";
 import { realClock, type Clock, type ClockTimer } from "./clock";
 
 const MAX_FRAME_BYTES = 4 * 1024 * 1024; // 4 MiB (§3.3)
-const EXTENSION_VERSION = "0.1.6";
+const EXTENSION_VERSION = "0.1.8";
+export { EXTENSION_VERSION };
 // 5: speaks per-kind agent admission and queued acquire.
 const PROTOCOL = 5;
 const HELLO_TIMEOUT_MS = 5000;
@@ -51,6 +52,8 @@ export interface StartRequest {
   run_in_background?: boolean;
   timeout_ms?: number | null;
   origin?: TaskOrigin;
+  /** Human-readable name (monitor description). */
+  label?: string;
 }
 
 export interface StartResponse {
@@ -90,6 +93,19 @@ export interface TaskRecord {
   end_reason?: string;
 }
 
+/** Rust-framed logical output. Fingerprints cover full content, not the preview. */
+export interface MonitorOutputRecord {
+  version: 1;
+  kind: "line" | "progress";
+  observed_at: number;
+  cursor_start: number;
+  cursor_end: number;
+  preview: string;
+  truncated: boolean;
+  fingerprint?: string;
+  timestamp_fingerprint?: string;
+}
+
 /** Server-pushed event (§3.3). Fields beyond `event` depend on the event kind. */
 export interface ManagerEvent {
   event: "task_started" | "output" | "task_exited" | "session_rebound" | string;
@@ -99,6 +115,8 @@ export interface ManagerEvent {
   pid?: number;
   chunk?: string;
   next_cursor?: number;
+  /** Absent on legacy managers/replay fallback; [] means Rust framing is active. */
+  monitor_records?: MonitorOutputRecord[];
   exit_code?: number | null;
   signal?: string | null;
   duration_ms?: number;
@@ -281,6 +299,7 @@ export class ManagerClient {
   private eventHandlers = new Set<EventHandler>();
   private reconnectHandlers = new Set<() => void>();
   private protocolLevel_ = 0;
+  private daemonInfo: { version: string; pid: number } | null = null;
   private state: ClientState = "disconnected";
   private intentionalClose = false;
   private rebound = false;
@@ -313,6 +332,11 @@ export class ManagerClient {
     return this.protocolLevel_;
   }
 
+  /** Version and pid the connected daemon reported on hello; null before the first hello. */
+  managerInfo(): { version: string; pid: number } | null {
+    return this.daemonInfo;
+  }
+
   /** Last connect/reconnect failure reason (empty when never failed / currently connected). */
   lastError(): string {
     return this.lastFailureMessage;
@@ -792,7 +816,10 @@ export class ManagerClient {
     }
     if (this.helloWaiter && typeof msg.ok === "boolean") {
       // Unnamed response: correlate by order with the outstanding hello.
-      if (msg.ok === true) this.helloWaiter.resolve();
+      if (msg.ok === true) {
+        this.recordDaemonInfo(msg);
+        this.helloWaiter.resolve();
+      }
       else this.helloWaiter.reject(errorFromResponse(msg));
       this.helloWaiter = null;
       return;
@@ -800,6 +827,13 @@ export class ManagerClient {
     this.log(`unmatched message: ${JSON.stringify(msg).slice(0, 200)}`);
   }
 
+  private recordDaemonInfo(hello: Record<string, unknown>): void {
+    this.daemonInfo = {
+      version: typeof hello.version === "string" ? hello.version : "unknown",
+      pid: typeof hello.pid === "number" ? hello.pid : 0,
+    };
+  }
+
   private settle(id: string, msg: Record<string, unknown>): void {
     const entry = this.pending.get(id);
     if (!entry) return;
@@ -811,6 +845,7 @@ export class ManagerClient {
       if (entry.message.type === "hello") {
         const serverMaximum = typeof msg.protocol === "number" ? msg.protocol : 0;
         this.protocolLevel_ = Math.min(PROTOCOL, serverMaximum);
+        this.recordDaemonInfo(msg);
       }
       entry.resolve(msg);
     } else {

package/src/monitor-batching.ts

@@ -13,19 +13,71 @@ export interface LineBatcherOptions {
   flushMs?: number; // batching window, default 200
   maxLineChars?: number; // per-line cap, default 500
   maxBatchChars?: number; // per-batch cap, default 3000
-  onFlush: (text: string) => void;
+  onFlush: (text: string, info: { truncated: boolean; omittedChars: number }) => void;
   clock?: Clock;
 }
 
+function sourceOfSlice(text: string, source: number, start: number, end: number): number {
+  if (text.length === 0 || end <= start) return 0;
+  return Math.round(source * ((end - start) / text.length));
+}
+
+/** Fixed-memory head/tail preview. Counts omitted source units, not generated ellipses. */
+export class BoundedPreview {
+  private head = "";
+  private tail = "";
+  private sourceHead = 0;
+  private sourceTail = 0;
+  total = 0;
+  private sourceTotal = 0;
+  constructor(readonly limit: number) {
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("preview limit must be positive");
+  }
+  append(text: string, sourceChars = text.length): void {
+    const headLimit = Math.ceil((this.limit - 1) / 2);
+    if (this.total + text.length <= this.limit) {
+      this.head += text;
+      this.sourceHead += sourceChars;
+    } else {
+      const old = this.head;
+      const oldSourceHead = this.sourceHead;
+      if (this.total <= this.limit) {
+        const combined = old + text;
+        const combinedSource = oldSourceHead + sourceChars;
+        this.head = combined.slice(0, headLimit);
+        this.sourceHead = sourceOfSlice(combined, combinedSource, 0, this.head.length);
+      }
+      const tailLimit = this.limit - 1 - headLimit;
+      if (tailLimit > 0) {
+        const from = (this.tail || old).concat(text);
+        const fromSource = (this.tail ? this.sourceTail : oldSourceHead) + sourceChars;
+        this.tail = from.slice(-tailLimit);
+        this.sourceTail = sourceOfSlice(from, fromSource, from.length - this.tail.length, from.length);
+      } else {
+        this.tail = "";
+        this.sourceTail = 0;
+      }
+    }
+    this.total += text.length;
+    this.sourceTotal += sourceChars;
+  }
+  get omittedChars(): number {
+    if (this.total <= this.limit) return 0;
+    return Math.max(0, this.sourceTotal - this.sourceHead - this.sourceTail);
+  }
+  get text(): string { return this.total > this.limit ? `${this.head}…${this.tail}` : this.head; }
+}
+
 export class LineBatcher {
   private readonly flushMs: number;
   private readonly maxLineChars: number;
   private readonly maxBatchChars: number;
-  private readonly onFlush: (text: string) => void;
+  private readonly onFlush: LineBatcherOptions["onFlush"];
   private readonly clock: Clock;
-
-  private partial = ""; // trailing bytes not yet terminated by \n
-  private lines: string[] = []; // complete lines awaiting emission
+  private partial: BoundedPreview;
+  private lines: BoundedPreview;
+  private lineCount = 0;
+  private omittedLineChars = 0;
   private timer: ClockTimer | null = null;
   private disposed = false;
 
@@ -35,49 +87,52 @@ export class LineBatcher {
     this.maxBatchChars = opts.maxBatchChars ?? 3000;
     this.onFlush = opts.onFlush;
     this.clock = opts.clock ?? realClock;
+    this.partial = new BoundedPreview(this.maxLineChars);
+    this.lines = new BoundedPreview(this.maxBatchChars);
   }
 
-  /** Feed a raw output chunk (may contain no/newlines or multiple lines). */
+  /** Bound retained data during ingestion, not just after the timer fires. */
   push(chunk: string): void {
     if (this.disposed || chunk.length === 0) return;
-    const combined = this.partial + chunk;
-    const parts = combined.split("\n");
-    this.partial = parts.pop() ?? "";
-    for (const line of parts) {
-      this.lines.push(this.capLine(line));
+    const parts = chunk.split("\n");
+    for (let i = 0; i < parts.length; i++) {
+      this.partial.append(parts[i]);
+      if (i < parts.length - 1) this.finishLine();
     }
-    if (this.lines.length > 0 || this.partial.length > 0) this.schedule();
+    this.schedule();
   }
 
-  /**
-   * Immediately emit the current buffer when non-empty, including any
-   * unterminated trailing line. Used when a monitored process exits.
-   */
   flush(): void {
     if (this.disposed) return;
     this.clearTimer();
     this.emit();
   }
 
-  /** Clear the pending timer and drop buffered content. */
   dispose(): void {
     this.disposed = true;
     this.clearTimer();
-    this.lines = [];
-    this.partial = "";
+    this.reset();
   }
 
-  private capLine(line: string): string {
-    if (line.length <= this.maxLineChars) return line;
-    return line.slice(0, this.maxLineChars);
+  private finishLine(): void {
+    if (this.lineCount++ > 0) this.lines.append("\n", 1);
+    const displayed = this.partial.text;
+    this.lines.append(displayed, this.partial.total - this.partial.omittedChars);
+    this.omittedLineChars += this.partial.omittedChars;
+    this.partial = new BoundedPreview(this.maxLineChars);
+  }
+
+  private reset(): void {
+    this.partial = new BoundedPreview(this.maxLineChars);
+    this.lines = new BoundedPreview(this.maxBatchChars);
+    this.lineCount = 0;
+    this.omittedLineChars = 0;
   }
 
   private schedule(): void {
     if (this.timer !== null) return;
     this.timer = this.clock.setTimeout(() => {
       this.timer = null;
-      // Window end drains everything, including an unterminated trailing
-      // line (no data loss); a fresh window starts on the next push.
       this.emit();
     }, this.flushMs);
     this.clock.unref?.(this.timer);
@@ -91,18 +146,11 @@ export class LineBatcher {
   }
 
   private emit(): void {
-    const lines = this.lines;
-    const partial = this.partial.length > 0 ? this.capLine(this.partial) : "";
-    if (lines.length === 0 && partial.length === 0) return;
-    this.lines = [];
-    this.partial = "";
-
-    let text = partial.length > 0 ? [...lines, partial].join("\n") : lines.join("\n");
-    if (text.length > this.maxBatchChars) {
-      // Keep the tail: for monitoring, the most recent lines matter most.
-      text = `…${text.slice(-(this.maxBatchChars - 1))}`;
-    }
-    if (text.length > 0) this.onFlush(text);
+    if (this.partial.total > 0) this.finishLine();
+    const text = this.lines.text;
+    const omittedChars = this.omittedLineChars + this.lines.omittedChars;
+    this.reset();
+    if (text.length > 0) this.onFlush(text, { truncated: omittedChars > 0, omittedChars });
   }
 }