one-code-extension 0.4.1 → 0.6.0

package/extensions/background/index.ts

@@ -1,24 +1,32 @@
 /**
  * background extension — Claude Code's background-task surface:
- * monitor, task_output, task_stop, schedule_wakeup.
+ * monitor, task_output, task_stop, schedule_wakeup, cron_create, cron_list,
+ * cron_delete, and /loop.
  *
  * 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 steered
  * task notifications (lib/notifications.ts), never as user input; a fired
- * wakeup or loop tick re-invokes the session with its prompt verbatim.
+ * wakeup or cron job re-invokes the session with its prompt verbatim.
+ *
+ * Every scheduled prompt lives in one CronStore (cron.ts): cron_create jobs
+ * and schedule_wakeup's one-shot wakeups (wakeup.ts). One timer is armed to
+ * the store's next fire; jobs fire only while the agent is idle, so a job
+ * that came due during a turn fires once at agent_settled. `/loop` is
+ * Claude Code's skill (skills/loop, its body built by loop-skill.ts): the
+ * model schedules the loop itself.
  */
 
 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 { persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
-import { detachedSpawnOptions, KILL_GRACE_MS, stopProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { persistedFilePreview, persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
+import { detachedSpawnOptions, KILL_GRACE_MS, rememberProcessGroup, stopProcessTree, waitForChildExit } from "../lib/process-tree.ts";
 import { sessionAlive } from "../lib/session-lifecycle.ts";
 import { bashSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
-import { ccToolRenderers, customMessageText, liveUiCtx, notificationComponent, scheduledTaskComponent } from "../lib/tui-render.ts";
+import { ccToolRenderers, customMessageText, formatFireTime, liveUiCtx, notificationComponent, notificationUserMarkdown, scheduledTaskComponent } from "../lib/tui-render.ts";
 import {
 	type BackgroundTask,
 	BackgroundRegistry,
@@ -26,16 +34,47 @@ import {
 	generateTaskId,
 	TASK_REGISTER_CHANNEL,
 } from "./registry.ts";
+import { SWITCH_CANCEL, SWITCH_STOP, switchWarning, workWidgetLine } from "./switch-guard.ts";
 import {
-	buildDynamicLoopPrompt,
-	buildLoopMessage,
-	buildWakeupMessage,
-	clampDelaySeconds,
-	describeSchedule,
-	MAX_DELAY_SECONDS,
-	MIN_DELAY_SECONDS,
-	parseLoopArgs,
+	AGED_OUT_RESULT,
+	DynamicLoop,
+	formatScheduled,
+	formatStopped,
+	SCHEDULE_WAKEUP_DESCRIPTION,
+	SCHEDULE_WAKEUP_PARAMS,
+	WAKEUP_ERRORS,
 } from "./wakeup.ts";
+import {
+	deliveryFromState,
+	isAutonomousSentinel,
+	isLoopFileSentinel,
+	LOOP_DELIVERY_DETAILS_KEY,
+	LOOP_DELIVERY_STATE,
+	type LoopDeliveryState,
+	readLoopFile,
+	resolveLoopFire,
+} from "./loop-fire.ts";
+import { autonomousPreamble, loopSkillPrompt } from "./loop-skill.ts";
+import {
+	CRON_CREATE_DESCRIPTION,
+	CRON_CREATE_PARAMETERS,
+	CRON_DELETE_DESCRIPTION,
+	CRON_DELETE_PARAMETERS,
+	CRON_LIST_DESCRIPTION,
+	CRON_LIST_PARAMETERS,
+	CronStore,
+	type CronFire,
+	type CronJob,
+	describeCadence,
+	formatCannotFire,
+	formatCreateResult,
+	formatDeleteResult,
+	formatJobList,
+	formatUnknownJob,
+	JOB_FIRED_ENTRY,
+	scheduledJobsOnBranch,
+	WAKEUP_ARMED_ENTRY,
+} from "./cron.ts";
 import {
 	createTaskNotifier,
 	monitorEndedSummary,
@@ -55,29 +94,105 @@ import {
 	MONITOR_BATCH_MAX_CHARS,
 	MONITOR_BATCH_IDLE_MS,
 	type MonitorBatch,
+	MonitorLineSplitter,
 	pushEvent,
 } from "./monitor-batch.ts";
 import { registerLocalCommand } from "../lib/local-command.ts";
+import { applyNoopFolds, decideFold, type FoldDetails, type FoldEntry, foldSuffix } from "./noop-fold.ts";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { AGENT_CRON_CHANNEL, AGENT_CRON_FIRE_CHANNEL, type AgentCronFire, type AgentCronRequest, type FireConversation, formatNotOwner } from "../lib/agent-cron.ts";
+import { SKILL_BODY_CHANNEL, type SkillBodyQuery, SLASH_EXPAND_CHANNEL, type SlashExpandQuery } from "../lib/skill-body.ts";
+import { BUNDLED_SKILLS_DIR } from "../lib/skill-scan.ts";
+import { createWriteStream, mkdirSync, type WriteStream } from "node:fs";
+import { join, resolve } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { SESSION_WORK_CHANNEL, sessionBackgroundTask, sessionCron, type SessionWorkQuery } from "../lib/session-work.ts";
+import { WORKTREE_CHANNEL, type WorktreeLocation } from "../lib/worktree-channel.ts";
+import { queueNotice } from "../lib/notices.ts";
+import { makeRecord, RECORD } from "../lib/ledger/records.ts";
+import { recordState, stateSinceCompaction } from "../lib/ledger/state.ts";
+import { processState } from "../lib/process-state.ts";
+import { extensionVersion } from "../lib/package-version.ts";
 
-const OUTPUT_CAP = 30_000;
+/** Claude Code's `task_output` limit (`TASK_MAX_OUTPUT_DEFAULT`). */
+const TASK_OUTPUT_MAX_CHARS = 32_000;
 const STORED_OUTPUT_CAP = 200_000;
 const DEFAULT_MONITOR_TIMEOUT_MS = 300_000;
 const MAX_MONITOR_TIMEOUT_MS = 3_600_000;
 const MAX_BLOCK_TIMEOUT_MS = 600_000;
+/** A finished monitor that saw nothing says so, never a blank a model reads as "still running" (bash's EMPTY_OUTPUT_MARKER). */
+const MONITOR_EMPTY_OUTPUT = "(no output — the monitor received no events and nothing on stderr)";
+/** Heads a monitor's output when the start is gone: past the in-memory cap with no spool file to hold it. */
+const SPOOL_LOST_NOTE = `[The monitor's spool file could not be written, so only the last ${STORED_OUTPUT_CAP.toLocaleString("en-US")} characters of its output were kept.]\n`;
+/** setTimeout's longest delay; a later fire re-arms when this one wakes. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
 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).
+ * `/clear`, `/new`, `/resume` and `/reload` stop every background task with
+ * the session they belong to (the notifier that would report them is inert by
+ * then, and the new instance 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 (LIFECYCLE-REVIEW-2026-09-06 L3). The
+ * notice is process state (lib/process-state.ts): module scope would lose it
+ * wherever pi evaluates this module again, at `/reload` and at a `/resume`
+ * into another directory (lifecycle grid R3-L13).
+ */
+const shutdownNotice = () => processState<{ text?: string }>("background:shutdown-notice", () => ({}));
+
+/**
+ * `<sessionDir>/monitor/<taskId>/output.log`, beside background shells'
+ * `bash/<taskId>/`. A session-less run spools under the session's private
+ * results dir (`sessionResultsDir`), so its output is never kept only as the
+ * in-memory tail. Undefined when the folder cannot be made.
+ */
+function monitorLogPath(ctx: ExtensionContext, taskId: string): string | undefined {
+	try {
+		const dir = join(sessionResultsDir(ctx), "monitor", taskId);
+		mkdirSync(dir, { recursive: true });
+		return join(dir, "output.log");
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * `task_output`'s body. Past `TASK_OUTPUT_MAX_CHARS` a task with a spool file
+ * gets Claude Code's clip, `[Truncated. Full output: <path>]` and the tail
+ * that fits, since the file holds the full text; a task without one (a
+ * subagent's report) is persisted whole to the session's tool-results
+ * folder, never cut (decisions/tools.md).
  */
-let pendingShutdownNotice: string | undefined;
+function taskOutputBody(task: BackgroundTask, ctx: ExtensionContext): string {
+	const output = task.output();
+	if (output.length <= TASK_OUTPUT_MAX_CHARS) return output;
+	if (task.logPath) {
+		const header = `[Truncated. Full output: ${task.logPath}]\n\n`;
+		return `${header}${output.slice(-(TASK_OUTPUT_MAX_CHARS - header.length))}`;
+	}
+	return persistIfLarge(output, { dir: sessionResultsDir(ctx), id: `task-output-${task.id}`, maxBytes: TASK_OUTPUT_MAX_CHARS });
+}
+
+/** A session entry as the no-op fold reads it (noop-fold.ts). */
+function foldEntry(entry: { type: string; timestamp?: string; customType?: string; details?: unknown; message?: unknown }): FoldEntry {
+	if (entry.type === "compaction") return { kind: "compaction" };
+	if (entry.type === "custom_message") {
+		if (entry.customType === "wakeup") return { kind: "wakeup", timestamp: Date.parse(entry.timestamp ?? "") || 0, details: entry.details as FoldDetails | undefined };
+		return entry.customType === "cron" ? { kind: "fire" } : { kind: "other" };
+	}
+	if (entry.type !== "message") return { kind: "other" };
+	const message = entry.message as { role?: string; content?: unknown; stopReason?: string; toolCallId?: string };
+	if (message.role === "user") return { kind: "user" };
+	if (message.role === "toolResult") return { kind: "toolResult", toolCallId: message.toolCallId ?? "" };
+	if (message.role === "assistant") {
+		const blocks = Array.isArray(message.content) ? (message.content as Array<{ type?: string; id?: string; name?: string; arguments?: { noop?: unknown } }>) : [];
+		const toolCalls = blocks.filter((b) => b.type === "toolCall").map((b) => ({ id: b.id ?? "", name: b.name ?? "", noop: b.arguments?.noop }));
+		return { kind: "assistant", toolCalls, aborted: message.stopReason === "aborted" };
+	}
+	return { kind: "other" };
+}
 
 export default function backgroundExtension(pi: ExtensionAPI) {
 	// After session_shutdown the captured ctx throws on every access and the
@@ -88,32 +203,68 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	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.
+	const cron = new CronStore();
+	const dynamicLoop = new DynamicLoop(cron);
+	let sessionCwd = process.cwd();
+	// The main session's worktree while it is in one (enter_worktree), where its fires resolve.
+	let worktreeCwd: string | undefined;
+	pi.events.on(WORKTREE_CHANNEL, (data) => {
+		worktreeCwd = (data as WorktreeLocation | null)?.path;
+	});
+	let cronTimer: NodeJS.Timeout | undefined;
+	// True between agent_start and agent_settled, so a due cron job waits for the
+	// turn to end instead of injecting one mid-run. agent_settled, not agent_end:
+	// agent_end can precede an internal retry / auto-compaction / queued
+	// continuation, and a fire 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));
+	pi.events.on(TASK_REGISTER_CHANNEL, (data) => {
+		const task = data as BackgroundTask;
+		registry.register(task);
+		// Shells and subagent runs count toward the widget's warning line too.
+		updateWidget();
+		task.finished?.then(updateWidget, updateWidget);
+	});
+	// A subagent's cron tools (lib/agent-cron.ts): its jobs, its view, its deletes.
+	pi.events.on(AGENT_CRON_CHANNEL, (data) => {
+		const request = data as AgentCronRequest;
+		if (request.op === "create") {
+			const created = cron.create({ cron: request.cron, prompt: request.prompt, recurring: request.recurring, agentId: request.agentId, cwd: request.cwd }, Date.now());
+			request.result = created.ok
+				? { text: formatCreateResult(created.job), details: { jobId: created.job.id } }
+				: { text: created.error, isError: true };
+			if (created.ok) runCron();
+		} else if (request.op === "list") {
+			const jobs = cron.list().filter((job) => job.agentId === request.agentId);
+			request.result = { text: formatJobList(jobs), details: { jobCount: jobs.length } };
+		} else {
+			const job = cron.get(request.id);
+			if (!job) request.result = { text: formatUnknownJob(request.id), isError: true };
+			else if (job.agentId !== request.agentId) request.result = { text: formatNotOwner(request.id), isError: true };
+			else {
+				cron.delete(request.id);
+				runCron();
+				request.result = { text: formatDeleteResult(request.id) };
+			}
+		}
+	});
+	// The Stop hook's session_crons / background_tasks (lib/session-work.ts).
+	pi.events.on(SESSION_WORK_CHANNEL, (data) => {
+		const query = data as SessionWorkQuery;
+		query.crons.push(...cron.list().map(sessionCron));
+		query.tasks.push(...registry.running().map(sessionBackgroundTask));
+	});
 
 	const updateWidget = () => {
 		// 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);
+		// Every running task and scheduled job, panel-owned ones included: the
+		// line is the warning of what /clear, /reload or quitting stops (switch-guard.ts).
+		const line = workWidgetLine(registry.running().length, cron.list().length);
+		live.ui.setWidget("cc-background", line ? [line] : undefined);
 	};
 
 	// The wire frames are model-facing; the transcript shows a compact headline
@@ -123,19 +274,146 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	pi.registerMessageRenderer("task-notification", (message, { expanded }, theme) =>
 		notificationComponent(theme, customMessageText(message.content), expanded),
 	);
-	for (const customType of ["wakeup", "loop"]) {
-		pi.registerMessageRenderer(customType, (message, { expanded }, theme) =>
-			scheduledTaskComponent(theme, customMessageText(message.content), (message as { timestamp?: number }).timestamp ?? Date.now(), expanded),
-		);
-	}
-	// The dynamic /loop's opening turn is the user's command, not a fired task.
-	pi.registerMessageRenderer("loop-start", (message, { expanded }, theme) =>
-		notificationComponent(theme, customMessageText(message.content), expanded),
+	// A notification that opens the session's first turn is a user message
+	// (lib/notifications.ts, "First turn of a session"); pi draws those as
+	// markdown, so the same headline replaces the frames here. Every notifier's
+	// messages pass through this one transformer.
+	pi.registerMarkdownTransformer((markdown, context) =>
+		context.messageType === "user" ? (notificationUserMarkdown(markdown) ?? markdown) : markdown,
 	);
+	for (const customType of ["wakeup", "cron"]) {
+		// Claude Code: "Claude resuming /loop wakeup (…)" for a wakeup; the model here may not be Claude.
+		const label = customType === "wakeup" ? "Resuming /loop wakeup" : undefined;
+		pi.registerMessageRenderer(customType, (message, { expanded }, theme) => {
+			const fold = message.details as FoldDetails | undefined;
+			const suffix = fold?.noOpStreak ? foldSuffix(fold.noOpStreak, formatFireTime(fold.streakStartedAt ?? Date.now())) : "";
+			return scheduledTaskComponent(theme, customMessageText(message.content), (message as { timestamp?: number }).timestamp ?? Date.now(), expanded, label, suffix);
+		});
+	}
 
 	// A monitor's end the model already read through task_output is withdrawn
 	// like a shell's (lib/notifications.ts).
-	const notify = createTaskNotifier(pi, { withdrawOnDelivery: true });
+	const notify = createTaskNotifier(pi, {
+		withdrawOnDelivery: true,
+		// A fire's message reached the conversation: what it told the model is on the branch from here.
+		onDelivered: (customType, details) => {
+			if (customType !== "cron" && customType !== "wakeup") return;
+			const stored = details[LOOP_DELIVERY_DETAILS_KEY];
+			if (stored !== undefined) recordDelivery(pi, deliveryFromState(stored));
+		},
+	});
+
+	/**
+	 * A no-prompt /loop sentinel's text (loop-fire.ts), against what the
+	 * conversation it lands in was already sent. That record is branch state
+	 * of that conversation: the main session's, or a subagent's own session,
+	 * since each has its own history and compacts on its own. Read since the
+	 * last compaction, so the first fire after one resends the instructions,
+	 * as Claude Code does. `delivery` is the record this text makes true, set
+	 * only when it changes (lifecycle grid R3-L12); the caller writes it when
+	 * the text reaches the conversation.
+	 */
+	const expandSentinel = (prompt: string, cwd: string, conversation: FireConversation | undefined): { text: string; delivery?: LoopDeliveryState } => {
+		let branch: readonly unknown[] = [];
+		try {
+			branch = conversation?.getBranch() ?? [];
+		} catch {
+			// A torn-down session reads as one that was sent nothing.
+		}
+		const before = deliveryFromState(stateSinceCompaction(branch, LOOP_DELIVERY_STATE));
+		const state = { ...before };
+		const text = resolveLoopFire(state, prompt, cwd, autonomousPreamble());
+		const changed = state.autonomousPreambleDelivered !== before.autonomousPreambleDelivered || state.lastLoopFileDelivered !== before.lastLoopFileDelivered;
+		return changed ? { text, delivery: state } : { text };
+	};
+	/** Record what a delivered fire told its conversation; a torn-down one has nothing to record into. */
+	const recordDelivery = (conversation: Pick<FireConversation, "appendEntry">, delivery: LoopDeliveryState) => {
+		try {
+			recordState(conversation, LOOP_DELIVERY_STATE, delivery);
+		} catch {
+			// Same: nothing to record into.
+		}
+	};
+	/** The main session as a fire's conversation, while it is live. */
+	const mainConversation = (): FireConversation | undefined => {
+		const ctx = lastCtx;
+		return ctx ? { getBranch: () => ctx.sessionManager.getBranch(), appendEntry: (customType, data) => pi.appendEntry(customType, data) } : undefined;
+	};
+
+	/**
+	 * The text a fired prompt delivers, as Claude Code's queue would run it: a
+	 * no-prompt /loop sentinel expands (loop-fire.ts), and a slash command that
+	 * names a skill runs that skill (lib/skill-body.ts); anything else is the
+	 * prompt verbatim. Both resolve in the job owner's directory: a subagent's
+	 * own, or the main session's worktree while it is in one.
+	 */
+	const fireText = (job: CronJob, conversation: FireConversation | undefined): { text: string; delivery?: LoopDeliveryState } => {
+		const { prompt } = job;
+		const cwd = job.cwd ?? worktreeCwd ?? sessionCwd;
+		if (isAutonomousSentinel(prompt) || isLoopFileSentinel(prompt)) return expandSentinel(prompt, cwd, conversation);
+		if (!prompt.startsWith("/")) return { text: prompt };
+		const query: SlashExpandQuery = { text: prompt, cwd };
+		pi.events.emit(SLASH_EXPAND_CHANNEL, query);
+		return { text: query.expanded ?? prompt };
+	};
+	/** Claude Code's no-op fold for the wakeup firing now (noop-fold.ts), read off the session branch. */
+	const foldDetails = (): FoldDetails => {
+		let entries: FoldEntry[];
+		try {
+			entries = (lastCtx?.sessionManager.getBranch() ?? []).map(foldEntry);
+		} catch {
+			return {};
+		}
+		const decision = decideFold(entries);
+		return decision.kind === "fold" ? { noOpStreak: decision.priorStreak + 1, streakStartedAt: decision.since } : {};
+	};
+	const fireCron = (fire: CronFire) => {
+		const { job, final } = fire;
+		if (job.agentId !== undefined) {
+			// A subagent's job goes to that agent, or is dropped once it has ended.
+			// The agent's resident sends the text as soon as it asks for it, so the record goes with the text.
+			const text = (conversation: FireConversation | undefined) => {
+				const fired = fireText(job, conversation);
+				if (fired.delivery && conversation) recordDelivery(conversation, fired.delivery);
+				return fired.text;
+			};
+			const delivery: AgentCronFire = { agentId: job.agentId, jobId: job.id, text };
+			pi.events.emit(AGENT_CRON_FIRE_CHANNEL, delivery);
+			// The agent has ended: its job goes with it.
+			if (!delivery.delivered) cron.delete(job.id);
+			return;
+		}
+		const fold = job.source === "wakeup" ? foldDetails() : {};
+		// A fold removes the tick's messages from the model's context: above the
+		// append point, so the next request opens an epoch (extensions/ledger)
+		// and renders the folded context whole, once.
+		if (fold.noOpStreak !== undefined) pi.appendEntry(RECORD.epoch, makeRecord("epoch", extensionVersion(), { cause: "fold" }));
+		if (job.source === "wakeup") dynamicLoop.inFlight = job.prompt;
+		// Recorded whatever way the notification goes out, so a /reload knows the fire happened.
+		pi.appendEntry(JOB_FIRED_ENTRY, { jobId: job.id, final, source: job.source });
+		// The notifier may hold the message (a coalescing window, an interrupt) and
+		// a /reload drops what it holds, so the loop's record rides the message and
+		// is written when it is delivered (the notifier's onDelivered above).
+		const { text, delivery } = fireText(job, mainConversation());
+		const details = { jobId: job.id, cron: job.cron, source: job.source, final, ...fold, ...(delivery ? { [LOOP_DELIVERY_DETAILS_KEY]: delivery } : {}) };
+		notify(job.source === "wakeup" ? "wakeup" : "cron", text, details);
+	};
+	/** Fire every due job (only while idle), then arm the one timer to the next fire. */
+	const runCron = () => {
+		if (cronTimer) clearTimeout(cronTimer);
+		cronTimer = undefined;
+		// A busy agent re-runs this at agent_settled; a dead session never does.
+		if (!alive() || agentBusy) {
+			updateWidget();
+			return;
+		}
+		for (const fire of cron.takeDue(Date.now())) fireCron(fire);
+		updateWidget();
+		const next = cron.nextFireAt();
+		if (next === undefined) return;
+		cronTimer = setTimeout(runCron, Math.min(Math.max(0, next - Date.now()), MAX_TIMER_MS));
+		cronTimer.unref?.();
+	};
 
 	pi.registerTool({
 		name: "monitor",
@@ -180,6 +458,32 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 			const id = generateTaskId();
 			let status: BackgroundTask["status"] = "running";
 			let stored = "";
+			// The whole stream, spooled like a background shell's, so the batches'
+			// "task_output has the full stream" and task_output's clip header point
+			// at something true, and a one-shot result past the in-memory cap can
+			// still persist every line. Opened on the first output.
+			let log: WriteStream | undefined;
+			let spoolFailed = false;
+			let overflowed = false;
+			const record = (text: string) => {
+				if (stored.length + text.length > STORED_OUTPUT_CAP) overflowed = true;
+				stored = tail(`${stored}${text}`, STORED_OUTPUT_CAP);
+				if (!text || spoolFailed) return;
+				if (!log) {
+					const path = monitorLogPath(ctx, id);
+					if (!path) return;
+					log = createWriteStream(path, { flags: "a" });
+					log.on("error", () => {
+						// Best-effort, as bash's spool: the in-memory tail stays
+						// authoritative, and nothing names a missing or partial file as
+						// the full output any more.
+						spoolFailed = true;
+						task.logPath = undefined;
+					});
+					task.logPath = path;
+				}
+				log.write(text);
+			};
 			let eventCount = 0;
 			let pending: MonitorBatch = emptyBatch();
 			let flushTimer: NodeJS.Timeout | undefined;
@@ -188,9 +492,16 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				finish = resolve;
 			});
 
-			const flush = () => {
+			const flush = (force = false) => {
 				flushTimer = undefined;
 				if (batchSize(pending) === 0) return;
+				if (!force && notify.holding()) {
+					// Held after an interrupt: one bounded batch accumulates (its
+					// overflow counted) instead of one held message per flush, and
+					// goes out once the next turn starts.
+					flushTimer = setTimeout(() => flush(), MONITOR_BATCH_IDLE_MS);
+					return;
+				}
 				const batch = pending;
 				pending = emptyBatch();
 				// CC's mid-run monitor batch: no status, the lines in `<event>`.
@@ -201,48 +512,71 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				);
 			};
 
+			// Set by stop(): what the command prints while it is torn down (a shell
+			// running the rest of `sleep 30; echo done` before the SIGKILL grace ends)
+			// is not an event, so the count says what happened before the stop.
+			let stopRequested = false;
 			const onEvent = (line: string) => {
+				if (stopRequested) return;
 				eventCount++;
-				stored = tail(`${stored}${line}\n`, STORED_OUTPUT_CAP);
+				record(`${line}\n`);
 				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);
+				flushTimer ??= setTimeout(() => flush(), agentBusy ? MONITOR_BATCH_BUSY_MS : MONITOR_BATCH_IDLE_MS);
 			};
 
 			const end = (finalStatus: BackgroundTask["status"], note?: string) => {
 				if (status !== "running") return;
 				status = finalStatus;
-				task.status = finalStatus;
-				task.finishedAt = Date.now();
 				if (flushTimer) clearTimeout(flushTimer);
-				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();
-				// CC's monitor end: the recent tail rides `<event>` under the ended summary.
-				const ccStatus = taskStatusOf(finalStatus);
-				const recent = tail(stored, MONITOR_BATCH_MAX_CHARS).trim();
-				notify(
-					"task-notification",
-					taskNotification({
-						kind: "monitor",
-						taskId: id,
-						toolUseId: toolCallId,
-						status: ccStatus,
-						summary: monitorEndedSummary(params.description, ccStatus, eventCount > 0, note),
-						result: recent || undefined,
-					}),
-					{ taskId: id, status: finalStatus },
-				);
+				const complete = () => {
+					if (task.status !== "running") return;
+					// Terminal status and its notification promise readable final output.
+					task.status = finalStatus;
+					task.finishedAt = Date.now();
+					finish();
+					// After shutdown or inside a one-shot run, report through `finished` alone.
+					if (!alive() || oneShot) return;
+					flush(true);
+					updateWidget();
+					// CC's monitor end: the recent tail rides <event> under the ended summary.
+					const ccStatus = taskStatusOf(finalStatus);
+					const recent = tail(stored, MONITOR_BATCH_MAX_CHARS).trim();
+					notify(
+						"task-notification",
+						taskNotification({
+							kind: "monitor",
+							taskId: id,
+							toolUseId: toolCallId,
+							status: ccStatus,
+							summary: monitorEndedSummary(params.description, ccStatus, eventCount > 0, note),
+							result: recent || undefined,
+						}),
+						{ taskId: id, status: finalStatus },
+					);
+				};
+				if (log && !log.closed) {
+					// `close` follows a clean end and an error alike. A stuck stream
+					// must not hold a blocking tool forever or advertise a partial file.
+					const fallback = setTimeout(() => {
+						spoolFailed = true;
+						task.logPath = undefined;
+						log?.destroy();
+						complete();
+					}, 1_000);
+					log.once("close", () => {
+						clearTimeout(fallback);
+						complete();
+					});
+					log.end();
+				} else {
+					complete();
+				}
 			};
 
-			let stopRequested = false;
 			let stop: () => void;
 			if (params.command) {
 				// Own process group: stop() must end the COMMAND, not just the `$SHELL -c`
@@ -263,27 +597,32 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 					...detachedSpawnOptions(),
 					stdio: ["ignore", "pipe", "pipe"],
 				});
-				let buffer = "";
+				rememberProcessGroup(child);
+				const lines = new MonitorLineSplitter();
+				// Streaming decoders: a UTF-8 character split across reads stays whole.
+				const stdoutText = new StringDecoder("utf8");
+				const stderrText = new StringDecoder("utf8");
 				child.stdout?.on("data", (chunk: Buffer) => {
-					buffer += chunk.toString();
-					let idx: number;
-					while ((idx = buffer.indexOf("\n")) !== -1) {
-						const line = buffer.slice(0, idx).trimEnd();
-						buffer = buffer.slice(idx + 1);
-						if (line) onEvent(line);
-					}
+					for (const line of lines.push(stdoutText.write(chunk))) onEvent(line);
 				});
 				child.stderr?.on("data", (chunk: Buffer) => {
-					stored = tail(`${stored}${chunk.toString()}`, STORED_OUTPUT_CAP);
+					record(stderrText.write(chunk));
 				});
 				// Exit plus a short stdio grace, not `close` (lib/process-tree.ts).
+				// The last line may have no newline; it is an event all the same.
+				const drain = () => {
+					for (const line of [...lines.push(stdoutText.end()), ...lines.end()]) onEvent(line);
+					record(stderrText.end());
+				};
 				waitForChildExit(child).then(
-					({ code }) =>
-						end(
-							stopRequested ? "stopped" : code === 0 ? "completed" : "failed",
-							code !== null && code !== 0 ? `exit code ${code}` : undefined,
-						),
-					(error: Error) => end("failed", error.message),
+					({ code }) => {
+						drain();
+						end(stopRequested ? "stopped" : code === 0 ? "completed" : "failed", code !== null && code !== 0 ? `exit code ${code}` : undefined);
+					},
+					(error: Error) => {
+						drain();
+						end("failed", error.message);
+					},
 				);
 				stop = () => {
 					stopRequested = true;
@@ -322,7 +661,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				description: params.description,
 				status,
 				startedAt: Date.now(),
-				output: () => stored,
+				output: () => (overflowed && !task.logPath ? `${SPOOL_LOST_NOTE}${stored}` : stored || (task.status === "running" ? "" : MONITOR_EMPTY_OUTPUT)),
 				stop,
 				finished,
 			};
@@ -349,7 +688,11 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				} finally {
 					unhook();
 				}
-				const output = persistIfLarge(stored.trim() || "(no events)", { dir: sessionResultsDir(ctx), id: `monitor-${id}` });
+				// Past the in-memory cap the spool holds every line: point at it rather
+				// than persist the tail. Without one, say what was lost.
+				const spooled = overflowed && task.logPath ? persistedFilePreview(task.logPath) : undefined;
+				const kept = overflowed && !spooled ? `${SPOOL_LOST_NOTE}${stored.trim()}` : stored.trim() || "(no events)";
+				const output = spooled ?? persistIfLarge(kept, { dir: sessionResultsDir(ctx), id: `monitor-${id}` });
 				const finalStatus = task.status;
 				let how: string = finalStatus;
 				if (finalStatus === "stopped") {
@@ -407,22 +750,26 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 
 			if (params.block !== false && task.status === "running") {
 				const timeoutMs = Math.min(params.timeout ?? 30_000, MAX_BLOCK_TIMEOUT_MS);
-				await Promise.race([
-					task.finished,
-					new Promise<void>((resolve) => {
-						const timer = setTimeout(resolve, timeoutMs);
-						timer.unref?.();
-						signal?.addEventListener("abort", () => {
-							clearTimeout(timer);
-							resolve();
-						}, { once: true });
-					}),
-				]);
+				let timer: ReturnType<typeof setTimeout> | undefined;
+				let unhook = () => {};
+				try {
+					await Promise.race([
+						task.finished,
+						new Promise<void>((resolve) => {
+							// The tool awaits this deadline: keep it referenced in one-shot runs.
+							timer = setTimeout(resolve, timeoutMs);
+							unhook = whenAborted(signal, resolve);
+						}),
+					]);
+				} finally {
+					clearTimeout(timer);
+					unhook();
+				}
 			}
 
 			updateWidget();
 			const header = formatTaskLine(task);
-			const body = tail(task.output(), OUTPUT_CAP) || "(no output yet)";
+			const body = taskOutputBody(task, ctx) || "(no output yet)";
 			// The model now holds a finished task's output: a completion notification
 			// still waiting to go out for it is redundant (lib/notifications.ts).
 			if (task.status !== "running") pi.events.emit(TASK_OUTPUT_DELIVERED_CHANNEL, { taskId: task.id } satisfies TaskOutputDelivered);
@@ -437,9 +784,12 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		name: "task_stop",
 		label: "Stop Task",
 		...ccToolRenderers("Stop Task"),
-		description: "Stop a running background task (monitor, background subagent, or background bash) by task id.",
+		// Claude Code's TaskStop text without its agent-team and agent-name clauses:
+		// a task is stopped by its id here.
+		description:
+			"\n- Stops a running background task by its ID\n- Takes a task_id parameter identifying the task to stop\n- Returns a success or failure status\n- Use this tool when you need to terminate a long-running task\n",
 		parameters: Type.Object({
-			task_id: Type.String({ description: "The id of the background task to stop" }),
+			task_id: Type.String({ description: "The ID of the background task to stop." }),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			lastCtx = ctx;
@@ -463,7 +813,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 					{
 						type: "text",
 						text: wasResident
-							? `Terminated the resident agent behind ${task.id} (${task.description}); it can no longer be messaged live (send_message will resume it from its session file).`
+							? `Terminated the resident agent behind ${task.id} (${task.description}); it can no longer be messaged live (SendMessage will resume it from its session file).`
 							: `Stop requested for ${task.id} (${task.description}).`,
 					},
 				],
@@ -478,61 +828,91 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		...ccToolRenderers<{ delaySeconds?: number; stop?: boolean }>("Schedule Wakeup", {
 			title: (a) => (a?.stop ? "stop" : a?.delaySeconds !== undefined ? `${a.delaySeconds}s` : undefined),
 		}),
-		description:
-			"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 harness re-invokes you with the given prompt, verbatim, as the next turn's input. 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.",
+		description: SCHEDULE_WAKEUP_DESCRIPTION,
 		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" })),
+			delaySeconds: Type.Optional(Type.Number({ description: SCHEDULE_WAKEUP_PARAMS.delaySeconds })),
+			reason: Type.Optional(Type.String({ description: SCHEDULE_WAKEUP_PARAMS.reason })),
+			prompt: Type.Optional(Type.String({ description: SCHEDULE_WAKEUP_PARAMS.prompt })),
+			stop: Type.Optional(Type.Boolean({ description: SCHEDULE_WAKEUP_PARAMS.stop })),
+			noop: Type.Optional(Type.Boolean({ description: SCHEDULE_WAKEUP_PARAMS.noop })),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			lastCtx = ctx;
-			const clearPending = () => {
-				if (wakeup) {
-					clearTimeout(wakeup.timer);
-					wakeup = undefined;
-				}
-			};
-			if (params.stop) {
-				clearPending();
-				return { content: [{ type: "text", text: "Wakeup loop stopped; no further wakeups will fire." }], details: {} };
-			}
-			// Validate BEFORE touching the pending wakeup: clearing it up front meant
-			// a malformed reschedule silently killed a running /loop with no signal.
-			if (params.delaySeconds === undefined || !params.prompt || !params.reason) {
-				return {
-					content: [
-						{
-							type: "text",
-							text: `delaySeconds, prompt, and reason are all required unless stop is true.${wakeup ? " Your previous wakeup is still pending — this call was rejected and left it untouched." : ""}`,
-						},
-					],
-					details: {},
-					isError: true,
-				};
+			const fail = (text: string) => ({ content: [{ type: "text" as const, text }], details: {}, isError: true });
+			if (params.stop === true) {
+				const cancelled = dynamicLoop.stop();
+				runCron();
+				return { content: [{ type: "text", text: formatStopped(cancelled) }], details: { stopped: true, cancelledWakeups: cancelled } };
 			}
-			// Valid reschedule — now it is safe to replace any pending wakeup.
-			clearPending();
-
-			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, noop: request.noop ?? false });
-			}, delayMs);
-			timer.unref?.();
-			wakeup = { timer, prompt: params.prompt, reason: params.reason };
-			return { content: [{ type: "text", text: describeSchedule(request) }], details: { delayMs, noop: params.noop ?? false } };
+			if (params.delaySeconds === undefined || params.reason === undefined) return fail(WAKEUP_ERRORS.delayAndReason);
+			if (params.prompt === undefined) return fail(WAKEUP_ERRORS.prompt);
+			if (params.noop === undefined) return fail(WAKEUP_ERRORS.noop);
+			const now = Date.now();
+			const scheduled = dynamicLoop.schedule(params.delaySeconds, params.prompt, now);
+			runCron();
+			if (!scheduled) return { content: [{ type: "text", text: AGED_OUT_RESULT }], details: { scheduledFor: 0 } };
+			const text = formatScheduled(scheduled, now);
+			return {
+				content: [{ type: "text", text: sessionOutlivesTurn(ctx.mode) ? text : `${text} ${formatCannotFire()}` }],
+				details: { ...scheduled, reason: params.reason, noop: params.noop },
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "cron_create",
+		label: "Cron Create",
+		...ccToolRenderers<{ cron?: string }>("Cron Create", { title: (a) => a?.cron }),
+		description: CRON_CREATE_DESCRIPTION,
+		parameters: CRON_CREATE_PARAMETERS,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			lastCtx = ctx;
+			const created = cron.create({ cron: params.cron, prompt: params.prompt, recurring: params.recurring }, Date.now());
+			if (!created.ok) return { content: [{ type: "text", text: created.error }], details: {}, isError: true };
+			runCron();
+			const text = formatCreateResult(created.job);
+			return {
+				content: [{ type: "text", text: sessionOutlivesTurn(ctx.mode) ? text : `${text} ${formatCannotFire()}` }],
+				details: { jobId: created.job.id, cron: created.job.cron, recurring: created.job.recurring, nextFireAt: created.job.nextFireAt },
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "cron_list",
+		label: "Cron List",
+		...ccToolRenderers("Cron List"),
+		description: CRON_LIST_DESCRIPTION,
+		parameters: CRON_LIST_PARAMETERS,
+		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+			lastCtx = ctx;
+			const jobs = cron.list();
+			return { content: [{ type: "text", text: formatJobList(jobs) }], details: { count: jobs.length } };
 		},
 	});
 
+	pi.registerTool({
+		name: "cron_delete",
+		label: "Cron Delete",
+		...ccToolRenderers<{ id?: string }>("Cron Delete", { title: (a) => a?.id }),
+		description: CRON_DELETE_DESCRIPTION,
+		parameters: CRON_DELETE_PARAMETERS,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			lastCtx = ctx;
+			if (!cron.delete(params.id)) return { content: [{ type: "text", text: formatUnknownJob(params.id) }], details: {}, isError: true };
+			runCron();
+			return { content: [{ type: "text", text: formatDeleteResult(params.id) }], details: { jobId: params.id } };
+		},
+	});
+
+	// schedule_wakeup stays eager, as Claude Code's ScheduleWakeup is.
 	for (const [name, keywords] of Object.entries({
 		monitor: ["monitor", "watch", "background", "tail", "events", "stream", "websocket"],
 		task_output: ["task", "background", "output", "status", "wait"],
 		task_stop: ["task", "background", "stop", "kill", "cancel"],
-		schedule_wakeup: ["wakeup", "loop", "schedule", "timer", "recurring", "later"],
+		cron_create: ["cron", "schedule", "recurring", "remind", "timer", "every", "later"],
+		cron_list: ["cron", "schedule", "list", "jobs", "scheduled"],
+		cron_delete: ["cron", "schedule", "cancel", "delete", "stop"],
 	})) {
 		pi.events.emit(DEFER_CHANNEL, { name, keywords });
 	}
@@ -545,100 +925,45 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		},
 	});
 
-	const clearLoop = () => {
-		if (loop) {
-			clearInterval(loop.timer);
-			loop = undefined;
-		}
-	};
-	const clearWakeup = () => {
-		if (wakeup) {
-			clearTimeout(wakeup.timer);
-			wakeup = undefined;
+	// `/loop` is a bundled skill whose body depends on its arguments; build it
+	// for the skill extension (lib/skill-body.ts). Only our own SKILL.md: a
+	// project skill named "loop" keeps its file's body.
+	const loopSkillPath = join(BUNDLED_SKILLS_DIR, "loop", "SKILL.md");
+	pi.events.on(SKILL_BODY_CHANNEL, (data) => {
+		const query = data as SkillBodyQuery;
+		if (query.skill !== "loop" || resolve(query.path) !== loopSkillPath) return;
+		query.body = loopSkillPrompt(query.args, readLoopFile(query.cwd));
+	});
+
+	/** Arm the branch's scheduled jobs, with each wakeup's loop age and keepalive spend. */
+	const armFromBranch = (ctx: ExtensionContext) => {
+		const now = Date.now();
+		for (const job of scheduledJobsOnBranch(ctx.sessionManager.getBranch() as never)) {
+			if (!cron.restore(job, now) || job.source !== "wakeup") continue;
+			dynamicLoop.restoreChain(job.prompt, job.chainStartedAt ?? job.createdAt, job.fireAt ?? now, job.keepalive === true);
 		}
+		runCron();
 	};
-
-	registerLocalCommand(pi, "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-start", buildDynamicLoopPrompt(parsed.task), {});
-		},
+	// The jobs follow the branch: a /tree switch ends the abandoned branch's and
+	// arms the selected one's (a subagent's own jobs stay with the agent).
+	pi.on("session_tree", (_event, ctx) => {
+		lastCtx = ctx;
+		cron.deleteWhere((job) => job.agentId === undefined);
+		dynamicLoop.clear();
+		armFromBranch(ctx);
 	});
-
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", (event, ctx) => {
 		lastCtx = ctx;
-		if (pendingShutdownNotice) {
-			const notice = pendingShutdownNotice;
-			pendingShutdownNotice = undefined;
-			if (ctx.hasUI) ctx.ui.notify(notice, "info");
+		sessionCwd = ctx.cwd;
+		// A /reload keeps the process and the conversation, so the session's
+		// scheduled jobs come back from the branch (design.md section 13); a new
+		// process ends them, as Claude Code's session-only jobs end.
+		if (event.reason === "reload") armFromBranch(ctx);
+		const pending = shutdownNotice();
+		if (pending.text) {
+			const notice = pending.text;
+			pending.text = undefined;
+			if (ctx.hasUI) queueNotice(pi.events, ctx, "info", notice);
 		}
 	});
 	pi.on("agent_start", () => {
@@ -646,22 +971,63 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	});
 	pi.on("agent_settled", () => {
 		agentBusy = false;
+		// Claude Code's keepalive: a wakeup's turn that scheduled no next one gets
+		// one fallback, recorded so a /reload re-arms it (no tool result does).
+		if (dynamicLoop.settle(Date.now()) === "armed") {
+			const armed = cron.list().find((job) => job.source === "wakeup");
+			if (armed) pi.appendEntry(WAKEUP_ARMED_ENTRY, { id: armed.id, prompt: armed.prompt, fireAt: armed.nextFireAt, startedAt: dynamicLoop.chainStart(armed.prompt) });
+		}
+		runCron();
+	});
+	// Folded no-op ticks leave the model's context (noop-fold.ts); the note stands in for them.
+	pi.on("context", (event) => {
+		const messages = applyNoopFolds(event.messages as Array<AgentMessage & { role: string }>, (text, timestamp) => ({ role: "user", content: [{ type: "text", text }], timestamp }) as AgentMessage & { role: string });
+		return messages ? { messages } : undefined;
 	});
+	// A switch stops everything below, so ask first. pi can cancel a switch but
+	// not a quit; the widget line covers quitting (switch-guard.ts).
+	const confirmSwitch = async (ctx: ExtensionContext, action: string): Promise<{ cancel: true } | undefined> => {
+		if (!ctx.hasUI) return undefined;
+		const title = switchWarning(
+			registry.running().map((t) => ({ id: t.id, label: t.description })),
+			cron.list().map((j) => ({ id: j.id, label: describeCadence(j.cron) })),
+			action,
+		);
+		if (!title) return undefined;
+		const choice = await ctx.ui.select(title, [SWITCH_CANCEL, SWITCH_STOP]);
+		return choice === SWITCH_STOP ? undefined : { cancel: true };
+	};
+	pi.on("session_before_switch", (event, ctx) =>
+		confirmSwitch(ctx, event.reason === "resume" ? "Resuming another session" : "Starting a new session"),
+	);
+	pi.on("session_before_fork", (_event, ctx) => confirmSwitch(ctx, "Forking the session"));
 
 	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
+		// on it — and the replacement is told (see shutdownNotice); 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(", ");
+		// A reload re-arms the jobs from the branch: only the tasks stop.
+		const jobs = event.reason === "reload" ? [] : cron.list();
+		if ((running.length > 0 || jobs.length > 0) && event.reason !== "quit") {
 			const when = event.reason === "reload" ? "on reload" : "with the previous session";
-			pendingShutdownNotice = `Stopped ${running.length} background task${running.length === 1 ? "" : "s"} ${when}: ${names}.`;
+			const notices: string[] = [];
+			if (running.length > 0) {
+				const names = running.map((t) => `${t.id} (${t.description})`).join(", ");
+				notices.push(`Stopped ${running.length} background task${running.length === 1 ? "" : "s"} ${when}: ${names}.`);
+			}
+			if (jobs.length > 0) {
+				const names = jobs.map((j) => `${j.id} (${describeCadence(j.cron)})`).join(", ");
+				notices.push(`Cancelled ${jobs.length} scheduled job${jobs.length === 1 ? "" : "s"} ${when}: ${names}.`);
+			}
+			shutdownNotice().text = notices.join(" ");
 		}
 		registry.stopAll();
-		clearWakeup();
-		clearLoop();
+		cron.clear();
+		dynamicLoop.clear();
+		if (cronTimer) clearTimeout(cronTimer);
+		cronTimer = undefined;
 		lastCtx = undefined;
 	});
 }