one-code-extension 0.1.3 → 0.3.0

package/extensions/background/index.ts

@@ -5,15 +5,19 @@
  * Owns the BackgroundRegistry. Other extensions (subagents) register their
  * long-running work over TASK_REGISTER_CHANNEL at runtime, so task_output and
  * task_stop address every background task in the session regardless of which
- * extension started it. Events and completions are delivered as follow-up
- * messages framed as system notifications, never as user input.
+ * extension started it. Events and completions are delivered as steered
+ * system notifications (lib/notifications.ts), never as user input.
  */
 
 import { spawn } from "node:child_process";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { whenAborted } from "../lib/abort.ts";
 import { DEFER_CHANNEL } from "../lib/deferred.ts";
-import { ccToolRenderers, customMessageText, notificationComponent } from "../lib/tui-render.ts";
+import { persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
+import { detachedSpawnOptions, KILL_GRACE_MS, stopProcessTree } from "../lib/process-tree.ts";
+import { sessionAlive } from "../lib/session-lifecycle.ts";
+import { ccToolRenderers, customMessageText, liveUiCtx, notificationComponent } from "../lib/tui-render.ts";
 import {
 	type BackgroundTask,
 	BackgroundRegistry,
@@ -21,55 +25,101 @@ import {
 	generateTaskId,
 	TASK_REGISTER_CHANNEL,
 } from "./registry.ts";
-import { buildWakeupMessage, clampDelaySeconds, describeSchedule } from "./wakeup.ts";
-import { systemNotification } from "../lib/notifications.ts";
+import {
+	buildDynamicLoopPrompt,
+	buildLoopMessage,
+	buildWakeupMessage,
+	clampDelaySeconds,
+	describeSchedule,
+	MAX_DELAY_SECONDS,
+	MIN_DELAY_SECONDS,
+	parseLoopArgs,
+} from "./wakeup.ts";
+import { createTaskNotifier, oneShotNote, sessionOutlivesTurn, systemNotification } from "../lib/notifications.ts";
+import {
+	batchSize,
+	emptyBatch,
+	formatMonitorBatch,
+	MONITOR_BATCH_BUSY_MS,
+	MONITOR_BATCH_IDLE_MS,
+	type MonitorBatch,
+	pushEvent,
+} from "./monitor-batch.ts";
 
 const OUTPUT_CAP = 30_000;
 const STORED_OUTPUT_CAP = 200_000;
-const EVENT_BATCH_MS = 1000;
 const DEFAULT_MONITOR_TIMEOUT_MS = 300_000;
 const MAX_MONITOR_TIMEOUT_MS = 3_600_000;
 const MAX_BLOCK_TIMEOUT_MS = 600_000;
-
 function tail(text: string, cap: number): string {
 	return text.length <= cap ? text : `… (earlier output truncated)\n${text.slice(-cap)}`;
 }
 
+/**
+ * `/clear`, `/new` and `/resume` stop every background task with the session
+ * they belong to (the notifier that would report them is inert by then, and
+ * the new session has no handle on them). Say so, once, in the NEW session:
+ * the old session's UI is torn down right after `session_shutdown`, so a
+ * notice printed there is lost. Module scope on purpose — jiti keeps this
+ * module across the factory re-run that builds the new instance, which is the
+ * only thing that survives the swap (LIFECYCLE-REVIEW-2026-09-06 L3).
+ */
+let pendingShutdownNotice: string | undefined;
+
 export default function backgroundExtension(pi: ExtensionAPI) {
+	// After session_shutdown the captured ctx throws on every access and the
+	// notifier is inert; a monitor whose command ends later (its shell was
+	// killed, the orphaned command finished) must repaint nothing and say
+	// nothing — before this guard, the widget repaint from the child's `close`
+	// callback took the whole process down (LIFECYCLE-REVIEW-2026-09-06 H1).
+	const alive = sessionAlive(pi);
 	const registry = new BackgroundRegistry();
 	let lastCtx: ExtensionContext | undefined;
 	let wakeup: { timer: NodeJS.Timeout; prompt: string; reason: string } | undefined;
+	// Fixed-interval /loop (harness-driven, auto-re-arming — distinct from the
+	// model-driven `wakeup` used by dynamic /loop). One at a time, like wakeup.
+	let loop: { timer: NodeJS.Timeout; intervalSeconds: number; task: string } | undefined;
+	// True between agent_start and agent_settled, so a fixed-interval tick can skip
+	// (not queue) while the previous tick's turn is still running — no backlog.
+	// agent_settled, not agent_end: agent_end can precede an internal retry /
+	// auto-compaction / queued continuation, and a tick landing in that gap would
+	// inject a turn while the prior one is still about to resume.
+	let agentBusy = false;
+	// Set when a dynamic /loop force-activated schedule_wakeup, so /loop stop can
+	// restore the lean tool surface it changed.
+	let activatedWakeupTool = false;
 
 	pi.events.on(TASK_REGISTER_CHANNEL, (task) => registry.register(task as BackgroundTask));
 
 	const updateWidget = () => {
-		if (!lastCtx?.hasUI) return;
-		const running = registry.running().length;
-		lastCtx.ui.setWidget("cc-background", running > 0 ? [` background tasks: ${running} running`] : undefined);
+		// liveUiCtx: a stale ctx (session replaced) reads as "no UI", never a throw;
+		// session_shutdown also drops lastCtx, so a late repaint is a no-op.
+		const live = liveUiCtx(lastCtx);
+		if (!live) return;
+		// A task whose producer gives it first-class panel UI (bash shells and
+		// subagent runs in the subagents panel) is excluded, or this line would
+		// stay permanently lit next to the panel already showing the same work.
+		const running = registry.running().filter((t) => !t.ownUI).length;
+		live.ui.setWidget("cc-background", running > 0 ? [` background tasks: ${running} running`] : undefined);
 	};
 
 	// Harness-injected notifications carry anti-confabulation framing for the
 	// model; the transcript shows a compact headline instead (ctrl+o expands).
 	// One registration covers every emitter of the type (bash uses it too).
-	for (const customType of ["task-notification", "wakeup"]) {
+	for (const customType of ["task-notification", "wakeup", "loop"]) {
 		pi.registerMessageRenderer(customType, (message, { expanded }, theme) =>
 			notificationComponent(theme, customMessageText(message.content), expanded),
 		);
 	}
 
-	const notify = (customType: string, text: string, details: Record<string, unknown>) => {
-		pi.sendMessage(
-			{ customType, content: [{ type: "text", text }], display: true, details },
-			{ deliverAs: "followUp", triggerTurn: true },
-		);
-	};
+	const notify = createTaskNotifier(pi);
 
 	pi.registerTool({
 		name: "monitor",
 		label: "Monitor",
 		...ccToolRenderers("Monitor"),
 		description:
-			"Start a background monitor that streams events from a long-running command. Each stdout line becomes a notification delivered to the conversation while you keep working; the command exiting ends the watch. Use for 'tell me every time X happens' (tail -f, polling loops); for a single completion signal prefer a subagent or a blocking command. Returns a task id — stop with task_stop, inspect with task_output. Alternatively pass `ws` to watch a WebSocket (each text frame is an event).",
+			"Start a background monitor that streams events from a long-running command. Each stdout line becomes a notification delivered to the conversation while you keep working; the command exiting ends the watch. Use for 'tell me every time X happens' (tail -f, an until-loop that polls a condition); for a single command's completion prefer bash with run_in_background: true — its completion notification arrives on its own. Returns a task id — stop with task_stop, inspect with task_output (both deferred — load them with tool_search). Alternatively pass `ws` to watch a WebSocket (each text frame is an event).",
 		parameters: Type.Object({
 			command: Type.Optional(Type.String({ description: "Shell command; each stdout line is an event, exit ends the watch" })),
 			description: Type.String({ description: "Short description of what is being monitored (shown in notifications)" }),
@@ -87,7 +137,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				),
 			),
 		}),
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			lastCtx = ctx;
 			if (Boolean(params.command) === Boolean(params.ws)) {
 				return {
@@ -97,11 +147,18 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				};
 			}
 
+			// One-shot modes (`-p` / `--mode json`) exit when the turn settles: the
+			// notifier goes inert, shutdown kills the monitor, and nothing it saw
+			// reaches anyone — the tool result had promised "events arrive as
+			// notifications" (LIFECYCLE-REVIEW M3, measured). Run it to its end
+			// there (exit or deadline) and return the collected events in the
+			// result — the shape bash and Agent use in these modes.
+			const oneShot = !sessionOutlivesTurn(ctx.mode);
 			const id = generateTaskId();
 			let status: BackgroundTask["status"] = "running";
 			let stored = "";
 			let eventCount = 0;
-			let pending: string[] = [];
+			let pending: MonitorBatch = emptyBatch();
 			let flushTimer: NodeJS.Timeout | undefined;
 			let finish!: () => void;
 			const finished = new Promise<void>((resolve) => {
@@ -110,21 +167,24 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 
 			const flush = () => {
 				flushTimer = undefined;
-				if (pending.length === 0) return;
+				if (batchSize(pending) === 0) return;
 				const batch = pending;
-				pending = [];
-				notify(
-					"task-notification",
-					systemNotification(`Monitor ${id} (${params.description}) emitted ${batch.length} event(s):\n${batch.join("\n")}`),
-					{ taskId: id, events: batch.length },
-				);
+				pending = emptyBatch();
+				notify("task-notification", systemNotification(formatMonitorBatch(id, params.description, batch)), {
+					taskId: id,
+					events: batchSize(batch),
+				});
 			};
 
 			const onEvent = (line: string) => {
 				eventCount++;
 				stored = tail(`${stored}${line}\n`, STORED_OUTPUT_CAP);
-				pending.push(line);
-				flushTimer ??= setTimeout(flush, EVENT_BATCH_MS);
+				if (oneShot) return; // collected into the tool result instead
+				pushEvent(pending, line);
+				// Bounded batches, and a wider window mid-turn so a chatty stream
+				// coalesces instead of steering one notification per second
+				// (monitor-batch.ts).
+				flushTimer ??= setTimeout(flush, agentBusy ? MONITOR_BATCH_BUSY_MS : MONITOR_BATCH_IDLE_MS);
 			};
 
 			const end = (finalStatus: BackgroundTask["status"], note?: string) => {
@@ -133,8 +193,12 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				task.status = finalStatus;
 				task.finishedAt = Date.now();
 				if (flushTimer) clearTimeout(flushTimer);
-				flush();
 				finish();
+				// Past this point everything touches the session: a monitor ending
+				// after shutdown (H1) or inside a one-shot run reports through
+				// `finished` alone.
+				if (!alive() || oneShot) return;
+				flush();
 				updateWidget();
 				notify(
 					"task-notification",
@@ -146,8 +210,13 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 			let stopRequested = false;
 			let stop: () => void;
 			if (params.command) {
+				// Own process group: stop() must end the COMMAND, not just the `$SHELL -c`
+				// leader — with zsh a `cmd; echo` or a pipeline otherwise lives on as an
+				// orphan holding the stdout pipe, so the task never finishes and, in a
+				// one-shot run, the process cannot exit (LIFECYCLE-REVIEW M2, measured).
 				const child = spawn(process.env.SHELL || "/bin/sh", ["-c", params.command], {
 					cwd: ctx.cwd,
+					...detachedSpawnOptions(),
 					stdio: ["ignore", "pipe", "pipe"],
 				});
 				let buffer = "";
@@ -172,7 +241,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				);
 				stop = () => {
 					stopRequested = true;
-					child.kill("SIGTERM");
+					stopProcessTree(child, KILL_GRACE_MS);
 				};
 			} else {
 				let ws: WebSocket;
@@ -211,17 +280,50 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				stop,
 				finished,
 			};
-			registry.register(task);
-			updateWidget();
+			// A one-shot monitor is awaited below and never addressable afterwards, so
+			// it is not registered behind task_output/task_stop (like bash's blocking
+			// path); `persistent` cannot be honoured either — the deadline applies.
+			if (!oneShot) {
+				registry.register(task);
+				updateWidget();
+			}
 
-			if (!params.persistent) {
-				const timeoutMs = Math.min(params.timeout_ms ?? DEFAULT_MONITOR_TIMEOUT_MS, MAX_MONITOR_TIMEOUT_MS);
+			const timeoutMs = Math.min(params.timeout_ms ?? DEFAULT_MONITOR_TIMEOUT_MS, MAX_MONITOR_TIMEOUT_MS);
+			if (oneShot || !params.persistent) {
 				const timer = setTimeout(() => {
 					if (task.status === "running") stop();
 				}, timeoutMs);
 				timer.unref?.();
 			}
 
+			if (oneShot) {
+				const unhook = whenAborted(signal, stop);
+				try {
+					await finished;
+				} finally {
+					unhook();
+				}
+				const output = persistIfLarge(stored.trim() || "(no events)", { dir: sessionResultsDir(ctx), id: `monitor-${id}` });
+				const finalStatus = task.status;
+				let how: string = finalStatus;
+				if (finalStatus === "stopped") {
+					if (signal?.aborted) how = "stopped (tool call aborted)";
+					else if (params.persistent) how = `stopped at its default deadline of ${timeoutMs} ms (persistent is not available in a one-shot session)`;
+					else how = `stopped at its ${timeoutMs} ms deadline`;
+				}
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Monitor ${id} (${params.description}) ${how} after ${eventCount} event(s). ${oneShotNote("monitor")}\n\n${output}`,
+						},
+					],
+					// No taskId: nothing is registered behind task_output/task_stop.
+					details: { status: finalStatus, events: eventCount },
+					isError: finalStatus === "failed",
+				};
+			}
+
 			return {
 				content: [
 					{
@@ -239,7 +341,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		label: "Task Output",
 		...ccToolRenderers("Task Output"),
 		description:
-			"Retrieve output from a running or finished background task (monitor, background subagent, or background bash) by task id. block=true (default) waits up to `timeout` ms for completion; block=false returns the current status immediately. You never need this just to learn that a task finished — completion always arrives as a system notification carrying the output; call this only when your next step needs the result now, or for a mid-run peek.",
+			"Retrieve output from a running or finished background task (monitor, background subagent, or background bash) by task id. block=true (default) waits up to `timeout` ms for completion; block=false returns the current status immediately. You never need this just to learn that a task finished — completion arrives as a system notification with the status and the last 2 KB of output; call this for the rest of the output, when your next step needs the result now, or for a mid-run peek.",
 		parameters: Type.Object({
 			task_id: Type.String({ description: "The task id to get output from" }),
 			block: Type.Optional(Type.Boolean({ description: "Wait for completion (default true)" })),
@@ -328,11 +430,12 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 			title: (a) => (a?.stop ? "stop" : a?.delaySeconds !== undefined ? `${a.delaySeconds}s` : undefined),
 		}),
 		description:
-			"Schedule when to resume work on a self-paced recurring task: after `delaySeconds` (clamped to [60, 3600]) the given prompt is delivered as a system notification and a new turn starts. One wakeup is pending at a time — scheduling again replaces it; {stop: true} cancels the loop. Do not use this to poll background tasks you started here — their completion already notifies you.",
+			"Schedule when to resume work on a self-paced recurring task — the dynamic mode of the /loop command. After `delaySeconds` (clamped to [60, 3600]) the given prompt is delivered as a system notification and a new turn starts. One wakeup is pending at a time — scheduling again replaces it; {stop: true} ends the loop and cancels any pending wakeup.\n\nPass the same task back via `prompt` each turn so the next firing repeats it. Set `noop: true` when nothing changed this tick (you checked and there's nothing to report); `noop: false` when something happened worth keeping. Pick `delaySeconds` from what you're actually waiting for: poll external state (a CI run, a deploy) at the rate it changes; for a quiet idle heartbeat prefer a long delay (1200s+). Do NOT schedule a short wakeup just to poll background work you started here — its completion already notifies you.",
 		parameters: Type.Object({
 			delaySeconds: Type.Optional(Type.Number({ description: "Seconds from now to wake up, clamped to [60, 3600]. Required unless stop is true" })),
 			prompt: Type.Optional(Type.String({ description: "The task to continue when the wakeup fires. Required unless stop is true" })),
 			reason: Type.Optional(Type.String({ description: "One short sentence explaining the chosen delay; shown to the user. Required unless stop is true" })),
+			noop: Type.Optional(Type.Boolean({ description: "true when nothing changed this tick (quiet hold); false when something happened worth keeping" })),
 			stop: Type.Optional(Type.Boolean({ description: "End the loop: cancel any pending wakeup and schedule nothing" })),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -364,15 +467,15 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 			// Valid reschedule — now it is safe to replace any pending wakeup.
 			clearPending();
 
-			const request = { delaySeconds: params.delaySeconds, prompt: params.prompt, reason: params.reason };
+			const request = { delaySeconds: params.delaySeconds, prompt: params.prompt, reason: params.reason, noop: params.noop };
 			const delayMs = clampDelaySeconds(params.delaySeconds) * 1000;
 			const timer = setTimeout(() => {
 				wakeup = undefined;
-				notify("wakeup", buildWakeupMessage(request), { reason: request.reason });
+				notify("wakeup", buildWakeupMessage(request), { reason: request.reason, noop: request.noop ?? false });
 			}, delayMs);
 			timer.unref?.();
 			wakeup = { timer, prompt: params.prompt, reason: params.reason };
-			return { content: [{ type: "text", text: describeSchedule(request) }], details: { delayMs } };
+			return { content: [{ type: "text", text: describeSchedule(request) }], details: { delayMs, noop: params.noop ?? false } };
 		},
 	});
 
@@ -393,13 +496,123 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	const clearLoop = () => {
+		if (loop) {
+			clearInterval(loop.timer);
+			loop = undefined;
+		}
+	};
+	const clearWakeup = () => {
+		if (wakeup) {
+			clearTimeout(wakeup.timer);
+			wakeup = undefined;
+		}
+	};
+
+	pi.registerCommand("loop", {
+		description: "Repeat a task on a loop: `/loop 5m <task>` (fixed interval) or `/loop <task>` (self-paced). `/loop stop` ends it.",
+		handler: async (args, ctx) => {
+			lastCtx = ctx;
+			const raw = (args ?? "").trim();
+			const keyword = raw.toLowerCase();
+
+			if (keyword === "stop") {
+				const had = Boolean(loop || wakeup);
+				clearLoop();
+				clearWakeup();
+				if (activatedWakeupTool) {
+					const active = pi.getActiveTools();
+					if (active.includes("schedule_wakeup")) pi.setActiveTools(active.filter((t) => t !== "schedule_wakeup"));
+					activatedWakeupTool = false;
+				}
+				ctx.ui.notify(had ? "Loop stopped; no further iterations will fire." : "No loop was running.", "info");
+				return;
+			}
+			if (raw === "" || keyword === "status") {
+				const parts: string[] = [];
+				if (loop) parts.push(`fixed interval every ${loop.intervalSeconds}s — ${loop.task}`);
+				if (wakeup) parts.push(`self-paced wakeup pending — ${wakeup.reason}`);
+				ctx.ui.notify(
+					parts.length
+						? `Running:\n- ${parts.join("\n- ")}\nStop with /loop stop.`
+						: "No loop running. Start with `/loop [interval] <task>`, e.g. `/loop 5m check the build`.",
+					"info",
+				);
+				return;
+			}
+
+			const parsed = parseLoopArgs(raw);
+			if (!parsed.task) {
+				ctx.ui.notify("Give a task to loop, e.g. `/loop 10m check for new PRs` or `/loop watch the deploy`.", "info");
+				return;
+			}
+
+			// One loop at a time — replace any existing interval loop or pending wakeup.
+			clearLoop();
+			clearWakeup();
+
+			if (parsed.intervalSeconds !== undefined) {
+				// Fixed interval, harness-driven: re-arm automatically and fire the first tick now.
+				const seconds = clampDelaySeconds(parsed.intervalSeconds);
+				const adjusted =
+					seconds !== parsed.intervalSeconds
+						? ` (adjusted from ${parsed.intervalSeconds}s; allowed range ${MIN_DELAY_SECONDS}-${MAX_DELAY_SECONDS}s)`
+						: "";
+				// Skip (don't queue) a tick while the previous tick's turn is still
+				// running, so a slow task can't build a backlog of stale iterations.
+				const tick = () => {
+					if (agentBusy) return;
+					notify("loop", buildLoopMessage(parsed.task), { intervalSeconds: seconds });
+				};
+				const timer = setInterval(tick, seconds * 1000);
+				timer.unref?.();
+				loop = { timer, intervalSeconds: seconds, task: parsed.task };
+				ctx.ui.notify(`Looping every ${seconds}s${adjusted}: ${parsed.task}. Stop with /loop stop.`, "info");
+				tick(); // fire the first iteration now
+				return;
+			}
+
+			// Dynamic (self-paced): the model drives schedule_wakeup, so make sure it is
+			// active — remembering we did, so /loop stop can restore the lean surface.
+			const active = pi.getActiveTools();
+			if (!active.includes("schedule_wakeup")) {
+				pi.setActiveTools([...active, "schedule_wakeup"]);
+				activatedWakeupTool = true;
+			}
+			ctx.ui.notify(`Self-paced loop started: ${parsed.task}. Stop with /loop stop.`, "info");
+			notify("loop", buildDynamicLoopPrompt(parsed.task), {});
+		},
+	});
+
 	pi.on("session_start", (_event, ctx) => {
 		lastCtx = ctx;
+		if (pendingShutdownNotice) {
+			const notice = pendingShutdownNotice;
+			pendingShutdownNotice = undefined;
+			if (ctx.hasUI) ctx.ui.notify(notice, "info");
+		}
+	});
+	pi.on("agent_start", () => {
+		agentBusy = true;
+	});
+	pi.on("agent_settled", () => {
+		agentBusy = false;
 	});
 
-	pi.on("session_shutdown", () => {
+	pi.on("session_shutdown", (event) => {
+		// Fires on /clear, /new, /resume and /reload too (findings §8). Everything
+		// running dies with this instance — the replacement instance has no handle
+		// on it — and the replacement is told (see pendingShutdownNotice); a quit
+		// needs no note. A reload keeps the conversation, so its note says so.
+		const running = registry.running();
+		if (running.length > 0 && event.reason !== "quit") {
+			const names = running.map((t) => `${t.id} (${t.description})`).join(", ");
+			const when = event.reason === "reload" ? "on reload" : "with the previous session";
+			pendingShutdownNotice = `Stopped ${running.length} background task${running.length === 1 ? "" : "s"} ${when}: ${names}.`;
+		}
 		registry.stopAll();
-		if (wakeup) clearTimeout(wakeup.timer);
-		wakeup = undefined;
+		clearWakeup();
+		clearLoop();
+		lastCtx = undefined;
 	});
 }

package/extensions/background/monitor-batch.ts

@@ -0,0 +1,58 @@
+/**
+ * Monitor event batching (pure). A monitor turns every stdout line into a
+ * steered notification; `tail -f` on a busy log used to mean an unbounded
+ * batch every second, each one a turn when the session was idle. Two limits:
+ *
+ * - a batch shows at most MAX_LINES lines / MAX_CHARS characters and says how
+ *   many more arrived (the full stream stays behind `task_output`);
+ * - while the agent is mid-turn the flush window widens (BUSY_MS), so events
+ *   coalesce into one notification at the next tool boundary instead of one
+ *   steer per second. Idle, the short window keeps latency low; the turn it
+ *   starts then widens the window for what follows.
+ */
+
+export const MONITOR_BATCH_MAX_LINES = 50;
+export const MONITOR_BATCH_MAX_CHARS = 4_000;
+export const MONITOR_BATCH_IDLE_MS = 1_000;
+export const MONITOR_BATCH_BUSY_MS = 10_000;
+
+export interface MonitorBatch {
+	/** Lines kept for display, in order (at most MAX_LINES). */
+	shown: string[];
+	/** Lines that arrived beyond the cap; counted, not kept. */
+	overflow: number;
+}
+
+export function emptyBatch(): MonitorBatch {
+	return { shown: [], overflow: 0 };
+}
+
+/** Add one event line, keeping the batch bounded. */
+export function pushEvent(batch: MonitorBatch, line: string): void {
+	if (batch.shown.length < MONITOR_BATCH_MAX_LINES) batch.shown.push(line);
+	else batch.overflow++;
+}
+
+export function batchSize(batch: MonitorBatch): number {
+	return batch.shown.length + batch.overflow;
+}
+
+/** The notification body for one flushed batch. */
+export function formatMonitorBatch(id: string, description: string, batch: MonitorBatch): string {
+	const total = batchSize(batch);
+	const lines: string[] = [];
+	let chars = 0;
+	let hidden = batch.overflow;
+	for (const line of batch.shown) {
+		if (chars + line.length + 1 > MONITOR_BATCH_MAX_CHARS && lines.length > 0) {
+			hidden += batch.shown.length - lines.length;
+			break;
+		}
+		const shown = line.length > MONITOR_BATCH_MAX_CHARS ? `${line.slice(0, MONITOR_BATCH_MAX_CHARS)}…` : line;
+		lines.push(shown);
+		chars += shown.length + 1;
+	}
+	const head = `Monitor ${id} (${description}) emitted ${total} event(s):`;
+	const more = hidden > 0 ? `\n… +${hidden} more line(s) not shown — task_output ${id} has the full stream` : "";
+	return `${head}\n${lines.join("\n")}${more}`;
+}

package/extensions/background/registry.ts

@@ -20,6 +20,8 @@ export interface BackgroundTask {
 	status: BackgroundStatus;
 	startedAt: number;
 	finishedAt?: number;
+	/** The raw shell command, when the task wraps one (shown by the shell panel). */
+	command?: string;
 	/** File the task spools its output to, when it has one. */
 	logPath?: string;
 	/** Output accumulated so far (or final output once finished). */
@@ -33,6 +35,13 @@ export interface BackgroundTask {
 	 * terminate it even though the task itself already completed.
 	 */
 	resident?: () => boolean;
+	/**
+	 * The task already has dedicated panel UI showing it live (bash shells and
+	 * subagent runs render in the subagents panel), so ambient counters like
+	 * the " background tasks: N" widget must not double-count it. Set by the
+	 * producer — never re-derived from `kind` by consumers.
+	 */
+	ownUI?: boolean;
 }
 
 export function generateTaskId(): string {

package/extensions/background/wakeup.ts

@@ -16,6 +16,51 @@ export interface WakeupRequest {
 	delaySeconds: number;
 	prompt: string;
 	reason: string;
+	/** Nothing changed this tick (matches CC's /loop noop flag). Recorded for callers; no effect on scheduling. */
+	noop?: boolean;
+}
+
+export interface ParsedLoop {
+	/** undefined = dynamic (model self-paces via schedule_wakeup); set = fixed interval. */
+	intervalSeconds?: number;
+	task: string;
+}
+
+/**
+ * Parse `/loop` arguments: a leading duration token (`5m`, `30s`, `2h`) selects
+ * fixed-interval mode and the rest is the task; no duration selects dynamic
+ * (self-paced) mode. `stop` / `status` are handled by the caller, not here.
+ */
+export function parseLoopArgs(raw: string): ParsedLoop {
+	const m = raw.trim().match(/^(\d+)\s*(s|m|h)\b\s*([\s\S]*)$/i);
+	if (m) {
+		const n = Number(m[1]);
+		const unit = m[2].toLowerCase();
+		const seconds = unit === "h" ? n * 3600 : unit === "m" ? n * 60 : n;
+		return { intervalSeconds: seconds, task: m[3].trim() };
+	}
+	return { task: raw.trim() };
+}
+
+/** A loop follow-up: an instruction line, a blank, then the task — system-framed. */
+function framedLoop(lead: string, task: string): string {
+	return systemNotification([lead, "", task].join("\n"));
+}
+
+/** The follow-up a fixed-interval `/loop` tick delivers. */
+export function buildLoopMessage(task: string): string {
+	return framedLoop(
+		"Loop tick — run the task below now. This repeats automatically on the interval and keeps firing until the user runs `/loop stop`.",
+		task,
+	);
+}
+
+/** The opening message for a dynamic (self-paced) `/loop` — instructs the model to drive schedule_wakeup. */
+export function buildDynamicLoopPrompt(task: string): string {
+	return framedLoop(
+		"Self-paced loop started. Work the task below now. When this iteration is done, call schedule_wakeup to schedule the next one — choose delaySeconds by what you're waiting for, and pass the same task back as `prompt`. End the loop with schedule_wakeup {stop: true} when the task is complete or the user says to stop.",
+		task,
+	);
 }
 
 /** The follow-up message a fired wakeup delivers. Framed so it never reads as user input. */