one-code-extension 0.5.0 → 0.6.0

package/README.md

@@ -83,7 +83,7 @@ The [`@one-ai/one-code`](https://www.npmjs.com/package/@one-ai/one-code)
 app package bundles a pinned version of pi and provides the `onecode` command.
 The [`one-code-extension`](https://www.npmjs.com/package/one-code-extension)
 package uses your existing pi installation and is tested against pi versions
-0.84.3 through 1.3. For the extension package, use `pi` in place of `onecode`.
+1.0.0 through 1.4. For the extension package, use `pi` in place of `onecode`.
 
 The app opens in a full-screen terminal interface by default. See the
 [installation guide](docs/guide/installation.md) for display settings and more

package/docs/guide/differences-from-claude-code.md

@@ -102,12 +102,15 @@ from user and managed scope. `includeCoAuthoredBy`, `apiKeyHelper`, `forceLoginM
 `/doctor report` to see, per file, which keys were used, ignored, or
 refused.
 
-## Prompt layout on Anthropic models
-
-Claude Code delivers part of its reminder stack to Opus and Sonnet as a
-system-role message after the first user message. pi's message model can't
-express that, so One Code uses the layout Claude Code uses for Haiku on
-every model. The content is the same; only the placement differs.
+## Prompt layout
+
+Claude Code delivers part of its reminder stack (the environment, the tool
+and agent listings, the date) to Opus and Sonnet as a system-role message
+after the first user message. One Code does the same on every model that
+pi's model catalog marks as taking a system message at that spot, on
+Anthropic and on OpenAI. Every other model, Haiku 4.5 included, gets the
+same text inside the first user message, the layout Claude Code uses for
+Haiku. The content is the same either way; only the placement differs.
 
 ## Platform support
 

package/docs/guide/installation.md

@@ -102,10 +102,9 @@ pi install npm:one-code-extension
 ```
 
 Use `pi` in place of `onecode` for every command in this guide. The
-extension is tested against pi 0.84.3 through 1.3 and warns at startup when
-your pi is outside that range. It doesn't load on a pi older than 0.84.3;
-update pi first with `pi update`. pi 1.0 and later start in full-screen mode;
-on an older pi it's opt-in. See
+extension is tested against pi 1.0.0 through 1.4 and warns at startup when
+your pi is outside that range. It doesn't load on a pi older than 1.0.0;
+update pi first with `pi update`. pi starts in full-screen mode; see
 [Full-screen mode and themes](configuration.md#full-screen-mode-and-themes).
 
 pi 0.99 and later ship their own tool search and MCP as built-in

package/docs/guide/troubleshooting.md

@@ -39,7 +39,7 @@ pins pi itself.
 **`Failed to load extension` on startup.** The extension package and the
 pi it runs on are out of step. On the bundled app, reinstall it. On your own
 pi, run `pi update npm:one-code-extension`, and update pi itself with
-`pi update` if it's older than 0.84.3.
+`pi update` if it's older than 1.0.0.
 
 **The stock pi first-run wizard didn't appear.** The bundled app seeds
 pi's settings with the One Code theme, quiet startup, and full-screen mode

package/extensions/auto-mode/denials.ts

@@ -15,8 +15,9 @@
  * floor are checked before any grant (working-docs/decisions/auto-mode.md,
  * "Approving a denied call").
  *
- * The store lives in the permissions extension's memory for one session. It is
- * never persisted, and a new session starts empty.
+ * The store lives in the permissions extension's process state for one
+ * session, which a /reload keeps. It is never persisted, and a new session
+ * starts empty.
  */
 
 /** Claude Code's `MAX_DENIALS`. */

package/extensions/background/cron.ts

@@ -377,6 +377,133 @@ export class CronStore {
 	clear(): void {
 		this.jobs.clear();
 	}
+
+	/**
+	 * Put back a job the branch recorded (`scheduledJobsOnBranch`), keeping its
+	 * id: a /reload re-arms the session's jobs. A recurring job past its age is
+	 * not restored; a fire missed during the reload comes at once.
+	 */
+	restore(job: RecordedJob, now: number): boolean {
+		const fields = parseCron(job.cron);
+		if (!fields || this.jobs.has(job.id)) return false;
+		if (job.recurring && now - job.createdAt >= this.maxAgeMs) return false;
+		const base = { id: job.id, cron: job.cron, recurring: job.recurring, fields };
+		// Due after the job's last fire on the branch (or its creation), so one missed during the reload is due now.
+		const nextFireAt = job.fireAt ?? this.fireAfter(base, Math.max(job.lastFiredAt ?? 0, job.createdAt));
+		if (nextFireAt === null) return false;
+		this.jobs.set(job.id, { ...base, prompt: job.prompt, source: job.source, createdAt: job.createdAt, nextFireAt });
+		return true;
+	}
+}
+
+/** A job as the branch records it: what `CronStore.restore` takes. */
+export interface RecordedJob {
+	id: string;
+	cron: string;
+	prompt: string;
+	recurring: boolean;
+	source: CronSource;
+	createdAt: number;
+	/** A wakeup's exact fire time. */
+	fireAt?: number;
+	/** A recurring job's last fire on the branch: the next one is due after it. */
+	lastFiredAt?: number;
+	/** A wakeup's loop start, and whether the keepalive armed it (DynamicLoop.restoreChain). */
+	chainStartedAt?: number;
+	keepalive?: boolean;
+}
+
+type BranchEntry = { type?: string; timestamp?: string; customType?: string; details?: unknown; data?: unknown; message?: unknown };
+
+/**
+ * The custom entry a main-session job's fire writes (`{ jobId, final, source }`),
+ * whatever way its notification is then delivered: a fire sent as a plain user
+ * message (no turn prompted since a /reload) carries no details.
+ */
+export const JOB_FIRED_ENTRY = "one-code:job-fired";
+
+/**
+ * The custom entry the loop's keepalive writes when it arms a wakeup itself
+ * (`{ id, prompt, fireAt, startedAt }`): no `schedule_wakeup` result records that one.
+ */
+export const WAKEUP_ARMED_ENTRY = "one-code:wakeup-armed";
+type Message = { role?: string; toolName?: string; toolCallId?: string; isError?: boolean; details?: unknown; content?: unknown; timestamp?: number };
+
+/**
+ * The main session's scheduled jobs a branch still holds: cron_create and
+ * schedule_wakeup results (the prompt read from their calls), minus
+ * cron_delete results, a wakeup stop, and final fires. A wakeup supersedes the
+ * one before it, as `DynamicLoop.schedule` does. Pure.
+ */
+export function scheduledJobsOnBranch(branch: readonly BranchEntry[]): RecordedJob[] {
+	const calls = new Map<string, Record<string, unknown>>();
+	const jobs = new Map<string, RecordedJob>();
+	const dropWakeups = () => {
+		for (const [id, job] of jobs) if (job.source === "wakeup") jobs.delete(id);
+	};
+	for (const entry of branch) {
+		if (entry.type === "custom" && entry.customType === WAKEUP_ARMED_ENTRY) {
+			const armed = entry.data as { id?: unknown; prompt?: unknown; fireAt?: unknown; startedAt?: unknown } | undefined;
+			if (typeof armed?.id !== "string" || typeof armed.prompt !== "string" || typeof armed.fireAt !== "number") continue;
+			dropWakeups();
+			const target = new Date(armed.fireAt);
+			const createdAt = Date.parse(entry.timestamp ?? "") || 0;
+			jobs.set(armed.id, {
+				id: armed.id,
+				cron: `${target.getMinutes()} ${target.getHours()} * * *`,
+				prompt: armed.prompt,
+				recurring: false,
+				source: "wakeup",
+				createdAt,
+				fireAt: armed.fireAt,
+				chainStartedAt: typeof armed.startedAt === "number" ? armed.startedAt : createdAt,
+				keepalive: true,
+			});
+			continue;
+		}
+		const fired = entry.type === "custom" && entry.customType === JOB_FIRED_ENTRY;
+		if (fired || (entry.type === "custom_message" && (entry.customType === "wakeup" || entry.customType === "cron"))) {
+			const details = (fired ? entry.data : entry.details) as { jobId?: unknown; final?: unknown; source?: unknown } | undefined;
+			const wakeup = fired ? details?.source === "wakeup" : entry.customType === "wakeup";
+			if (details?.final !== true) {
+				const job = typeof details?.jobId === "string" ? jobs.get(details.jobId) : undefined;
+				const at = Date.parse(entry.timestamp ?? "");
+				if (job && !Number.isNaN(at)) job.lastFiredAt = at;
+				continue;
+			}
+			if (wakeup) dropWakeups();
+			else if (typeof details.jobId === "string") jobs.delete(details.jobId);
+			continue;
+		}
+		if (entry.type !== "message") continue;
+		const message = entry.message as Message | undefined;
+		if (message?.role === "assistant" && Array.isArray(message.content)) {
+			for (const block of message.content as Array<{ type?: string; id?: string; arguments?: unknown }>) {
+				if (block?.type === "toolCall" && typeof block.id === "string" && block.arguments && typeof block.arguments === "object") calls.set(block.id, block.arguments as Record<string, unknown>);
+			}
+			continue;
+		}
+		if (message?.role !== "toolResult" || message.isError || !message.toolCallId) continue;
+		const args = calls.get(message.toolCallId) ?? {};
+		const details = (message.details ?? {}) as Record<string, unknown>;
+		const at = message.timestamp ?? (Date.parse(entry.timestamp ?? "") || 0);
+		if (message.toolName === "cron_create" && typeof details.jobId === "string" && typeof details.cron === "string" && typeof args.prompt === "string") {
+			jobs.set(details.jobId, { id: details.jobId, cron: details.cron, prompt: args.prompt, recurring: details.recurring !== false, source: "model", createdAt: at });
+		} else if (message.toolName === "cron_delete" && typeof details.jobId === "string") {
+			jobs.delete(details.jobId);
+		} else if (message.toolName === "schedule_wakeup") {
+			// A schedule replaces the pending wakeup; one past the loop's age (scheduledFor 0) cancels it.
+			if (details.stopped === true || typeof details.scheduledFor === "number") dropWakeups();
+			if (typeof details.scheduledFor === "number" && details.scheduledFor > 0 && typeof args.prompt === "string") {
+				const target = new Date(details.scheduledFor);
+				// The store's own id, so a cron_delete of the wakeup removes it here too.
+				const id = typeof details.jobId === "string" ? details.jobId : `w-${message.toolCallId}`;
+				const chainStartedAt = typeof details.startedAt === "number" ? details.startedAt : at;
+				jobs.set(id, { id, cron: `${target.getMinutes()} ${target.getHours()} * * *`, prompt: args.prompt, recurring: false, source: "wakeup", createdAt: at, fireAt: details.scheduledFor, chainStartedAt });
+			}
+		}
+	}
+	return [...jobs.values()];
 }
 
 function publicJob(job: CronJob & { fields?: CronFields }): CronJob {

package/extensions/background/index.ts

@@ -44,7 +44,16 @@ import {
 	SCHEDULE_WAKEUP_PARAMS,
 	WAKEUP_ERRORS,
 } from "./wakeup.ts";
-import { freshDeliveryState, type LoopDeliveryState, readLoopFile, resolveLoopFire } from "./loop-fire.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,
@@ -62,6 +71,9 @@ import {
 	formatDeleteResult,
 	formatJobList,
 	formatUnknownJob,
+	JOB_FIRED_ENTRY,
+	scheduledJobsOnBranch,
+	WAKEUP_ARMED_ENTRY,
 } from "./cron.ts";
 import {
 	createTaskNotifier,
@@ -88,7 +100,7 @@ import {
 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, formatNotOwner } from "../lib/agent-cron.ts";
+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";
@@ -97,6 +109,10 @@ 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";
 
 /** Claude Code's `task_output` limit (`TASK_MAX_OUTPUT_DEFAULT`). */
 const TASK_OUTPUT_MAX_CHARS = 32_000;
@@ -115,15 +131,16 @@ function tail(text: string, cap: number): string {
 }
 
 /**
- * `/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).
  */
-let pendingShutdownNotice: string | undefined;
+const shutdownNotice = () => processState<{ text?: string }>("background:shutdown-notice", () => ({}));
 
 /**
  * `<sessionDir>/monitor/<taskId>/output.log`, beside background shells'
@@ -188,16 +205,6 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	let lastCtx: ExtensionContext | undefined;
 	const cron = new CronStore();
 	const dynamicLoop = new DynamicLoop(cron);
-	// What the no-prompt /loop sentinels already delivered, per recipient (the
-	// main session, or a subagent by task id): each conversation has its own
-	// record. The main session's compaction resets its own (loop-fire.ts).
-	const MAIN_OWNER = "main";
-	const loopDelivery = new Map<string, LoopDeliveryState>();
-	const deliveryFor = (owner: string): LoopDeliveryState => {
-		let state = loopDelivery.get(owner);
-		if (!state) loopDelivery.set(owner, (state = freshDeliveryState()));
-		return state;
-	};
 	let sessionCwd = process.cwd();
 	// The main session's worktree while it is in one (enter_worktree), where its fires resolve.
 	let worktreeCwd: string | undefined;
@@ -255,7 +262,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		const live = liveUiCtx(lastCtx);
 		if (!live) return;
 		// Every running task and scheduled job, panel-owned ones included: the
-		// line is the warning that /clear, /reload or quitting stops them (switch-guard.ts).
+		// 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);
 	};
@@ -286,7 +293,52 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 
 	// 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
@@ -295,14 +347,14 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	 * 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): string => {
+	const fireText = (job: CronJob, conversation: FireConversation | undefined): { text: string; delivery?: LoopDeliveryState } => {
 		const { prompt } = job;
 		const cwd = job.cwd ?? worktreeCwd ?? sessionCwd;
-		const resolved = resolveLoopFire(deliveryFor(job.agentId ?? MAIN_OWNER), prompt, cwd, autonomousPreamble());
-		if (resolved !== prompt || !prompt.startsWith("/")) return resolved;
+		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 query.expanded ?? prompt;
+		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 => {
@@ -319,18 +371,32 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		const { job, final } = fire;
 		if (job.agentId !== undefined) {
 			// A subagent's job goes to that agent, or is dropped once it has ended.
-			const delivery: AgentCronFire = { agentId: job.agentId, jobId: job.id, prompt: fireText(job) };
+			// 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);
-			if (!delivery.delivered) {
-				// The agent has ended: its job and what it was sent go with it.
-				cron.delete(job.id);
-				loopDelivery.delete(job.agentId);
-			}
+			// 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;
-		notify(job.source === "wakeup" ? "wakeup" : "cron", fireText(job), { jobId: job.id, cron: job.cron, source: job.source, final, ...fold });
+		// 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 = () => {
@@ -869,12 +935,34 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		query.body = loopSkillPrompt(query.args, readLoopFile(query.cwd));
 	});
 
-	pi.on("session_start", (_event, ctx) => {
+	/** 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();
+	};
+	// 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) => {
 		lastCtx = ctx;
 		sessionCwd = ctx.cwd;
-		if (pendingShutdownNotice) {
-			const notice = pendingShutdownNotice;
-			pendingShutdownNotice = undefined;
+		// 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);
 		}
 	});
@@ -883,8 +971,12 @@ 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.
-		dynamicLoop.settle(Date.now());
+		// 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.
@@ -892,11 +984,6 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 		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;
 	});
-	// The first fire after a compaction resends the full loop instructions, as in Claude Code.
-	pi.on("session_compact", () => {
-		loopDelivery.delete(MAIN_OWNER);
-	});
-
 	// 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> => {
@@ -918,10 +1005,11 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 	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();
-		const jobs = cron.list();
+		// 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";
 			const notices: string[] = [];
@@ -933,7 +1021,7 @@ export default function backgroundExtension(pi: ExtensionAPI) {
 				const names = jobs.map((j) => `${j.id} (${describeCadence(j.cron)})`).join(", ");
 				notices.push(`Cancelled ${jobs.length} scheduled job${jobs.length === 1 ? "" : "s"} ${when}: ${names}.`);
 			}
-			pendingShutdownNotice = notices.join(" ");
+			shutdownNotice().text = notices.join(" ");
 		}
 		registry.stopAll();
 		cron.clear();

package/extensions/background/loop-fire.ts

@@ -12,6 +12,7 @@
  */
 
 import { projectConfigDir, userConfigDir } from "../lib/config-mode.ts";
+import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -35,7 +36,12 @@ export interface LoopFile {
 	content: string;
 }
 
-/** What went out already this session; compaction resets it (the first fire after it resends everything). */
+/**
+ * What one conversation was already sent; compaction resets it (the first
+ * fire after it resends everything). `lastLoopFileDelivered` is the delivered
+ * loop.md's fingerprint (`loopFileMark`), not its text, so the record stays
+ * small on the branch.
+ */
 export interface LoopDeliveryState {
 	autonomousPreambleDelivered: boolean;
 	lastLoopFileDelivered: string | null;
@@ -45,6 +51,37 @@ export function freshDeliveryState(): LoopDeliveryState {
 	return { autonomousPreambleDelivered: false, lastLoopFileDelivered: null };
 }
 
+/**
+ * The `one-code:state` key the record lives under, on the branch of the
+ * conversation the fires land in (the main session's, or a subagent's own):
+ * it follows `/tree`, survives `/reload` and resume, and a compaction resets
+ * it (lib/ledger/state.ts `stateSinceCompaction`).
+ */
+export const LOOP_DELIVERY_STATE = "loop-delivery";
+
+/**
+ * The key a main-session fire's notification details carry its record
+ * under. The record is written when that message is delivered (the
+ * notifier's `onDelivered`), not when the text is built: the notifier may
+ * still hold it, and a `/reload` or `/clear` then drops it unsent.
+ */
+export const LOOP_DELIVERY_DETAILS_KEY = "loopDelivery";
+
+/** A stored record read back, or a fresh one when it is missing or malformed. */
+export function deliveryFromState(value: unknown): LoopDeliveryState {
+	const stored = value as Partial<LoopDeliveryState> | undefined;
+	if (!stored || typeof stored !== "object") return freshDeliveryState();
+	return {
+		autonomousPreambleDelivered: stored.autonomousPreambleDelivered === true,
+		lastLoopFileDelivered: typeof stored.lastLoopFileDelivered === "string" ? stored.lastLoopFileDelivered : null,
+	};
+}
+
+/** What a delivered loop.md is remembered by: equal texts, equal marks. */
+export function loopFileMark(content: string): string {
+	return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+
 export function isAutonomousSentinel(prompt: string): boolean {
 	return prompt === AUTONOMOUS_LOOP || prompt === AUTONOMOUS_LOOP_DYNAMIC;
 }
@@ -112,7 +149,7 @@ export function readLoopFile(cwd: string, home = homedir()): LoopFile | null {
 	return readLoopFileAt(join(projectConfigDir(cwd), "loop.md")) ?? readLoopFileAt(join(userConfigDir(home), "loop.md"));
 }
 
-function resolveLoopFile(e: LoopDeliveryState, t: string, o: LoopFile | null, preamble: string): string {let n=t===LOOP_FILE_DYNAMIC_SENTINEL;if(o){let s=n?loopFileDynamicTick():loopFileCronTick();if(e.lastLoopFileDelivered===o.content)return s;return e.lastLoopFileDelivered=o.content,`# /loop tick \u2014 tasks from ${o.path}
+function resolveLoopFile(e: LoopDeliveryState, t: string, o: LoopFile | null, preamble: string): string {let n=t===LOOP_FILE_DYNAMIC_SENTINEL;if(o){let s=n?loopFileDynamicTick():loopFileCronTick(),m=loopFileMark(o.content);if(e.lastLoopFileDelivered===m)return s;return e.lastLoopFileDelivered=m,`# /loop tick \u2014 tasks from ${o.path}
 
 The user configured a loop-tasks file. Work through the tasks defined below; these are the instructions for this tick and every subsequent tick (the reminder on later fires refers back to this message).
 

package/extensions/background/switch-guard.ts

@@ -1,10 +1,12 @@
 /**
  * What a session switch or quit would stop (pure). Running background tasks and
- * scheduled jobs belong to the session: `/clear`, `/new`, `/resume` and a fork
- * stop them, and so do `/reload` and quitting. pi lets an extension cancel a
- * switch (`session_before_switch`, `session_before_fork`), so a switch asks
- * first; reloading and quitting have no such hook, so the standing widget line
- * says it up front.
+ * scheduled jobs belong to the session: `/clear`, `/new`, `/resume`, a fork and
+ * quitting stop them. A `/reload` stops the running tasks only: it keeps the
+ * conversation, so the scheduled jobs come back from the branch
+ * (background/index.ts `armFromBranch`). pi lets an extension cancel a switch
+ * (`session_before_switch`, `session_before_fork`), so a switch asks first;
+ * reloading and quitting have no such hook, so the standing widget line says
+ * it up front.
  */
 
 /** A running task or scheduled job, as the dialog and widget name it. */
@@ -48,5 +50,7 @@ export function switchWarning(tasks: readonly SessionWork[], jobs: readonly Sess
 /** The standing widget line while anything runs, or undefined when nothing does. */
 export function workWidgetLine(tasks: number, jobs: number): string | undefined {
 	if (tasks === 0 && jobs === 0) return undefined;
-	return ` ${counts(tasks, jobs)} · stopped by /clear, /reload or quitting${tasks > 0 ? " · /tasks to manage" : ""}`;
+	// A /reload stops only the running tasks; the jobs re-arm from the branch.
+	const stoppedBy = jobs === 0 ? "/clear, /reload or quitting" : tasks === 0 ? "/clear or quitting" : "/clear or quitting, the tasks by /reload too";
+	return ` ${counts(tasks, jobs)} · stopped by ${stoppedBy}${tasks > 0 ? " · /tasks to manage" : ""}`;
 }

package/extensions/background/wakeup.ts

@@ -40,6 +40,10 @@ export interface WakeupSchedule {
 	scheduledFor: number;
 	clampedDelaySeconds: number;
 	wasClamped: boolean;
+	/** The store's job id, so a cron_delete of it is matched when the branch is replayed. */
+	jobId?: string;
+	/** When this prompt's loop started: its age carries across a /reload. */
+	startedAt: number;
 }
 
 interface PromptAge {
@@ -59,6 +63,11 @@ export class DynamicLoop {
 		private readonly maxAgeMs = RECURRING_MAX_AGE_MS,
 	) {}
 
+	/** When the loop for `prompt` started, if it is running. */
+	chainStart(prompt: string): number | undefined {
+		return this.ages.get(prompt)?.startedAt;
+	}
+
 	/** A pending wakeup exists. */
 	hasPending(): boolean {
 		return this.store.list().some((job) => job.source === "wakeup");
@@ -82,10 +91,20 @@ export class DynamicLoop {
 		const wasClamped = !(delaySeconds >= MIN_DELAY_SECONDS && delaySeconds <= MAX_DELAY_SECONDS);
 		const scheduledFor = now + clamped * 1000;
 		const target = new Date(scheduledFor);
-		this.store.create({ cron: `${target.getMinutes()} ${target.getHours()} * * *`, prompt, recurring: false, source: "wakeup", fireAt: scheduledFor }, now);
+		const created = this.store.create({ cron: `${target.getMinutes()} ${target.getHours()} * * *`, prompt, recurring: false, source: "wakeup", fireAt: scheduledFor }, now);
 		this.ages.set(prompt, { startedAt, lastScheduledFor: scheduledFor });
 		if (viaKeepalive) this.misses++;
-		return { scheduledFor, clampedDelaySeconds: clamped, wasClamped };
+		return { scheduledFor, clampedDelaySeconds: clamped, wasClamped, startedAt, ...(created.ok ? { jobId: created.job.id } : {}) };
+	}
+
+	/**
+	 * Take back a pending wakeup's loop state from the branch (a /reload, a
+	 * /tree switch): its age, and whether the keepalive armed it, which spends
+	 * the loop's one fallback.
+	 */
+	restoreChain(prompt: string, startedAt: number, scheduledFor: number, viaKeepalive: boolean): void {
+		this.ages.set(prompt, { startedAt, lastScheduledFor: scheduledFor });
+		this.misses = viaKeepalive ? 1 : 0;
 	}
 
 	/**