@alphacoder-v0/pi-loops 0.22.8 → 0.24.1

package/src/pi-loops.ts

@@ -5,7 +5,9 @@
  * is an in-process `AgentSession` through pi's SDK (`src/sdk-runner.ts`) — never a child process —
  * so it shares this session's MCP clients, extensions and model. A loop's state is Markdown on
  * disk, findings go to a global JSONL inbox, and `/inbox claim` turns a finding into a real user
- * turn via `pi.sendUserMessage()`.
+ * turn. Every prompt pi-loops has for the chat (a plain job, a push, a claim, a goal continuation)
+ * is a request addressed to the conversation (src/requests.ts), and reaches pi through the window
+ * executor only (src/window-executor.ts), once pi is idle.
  *
  * Commands, tools and their arguments are documented in `docs/` (loops.md, triggers.md, goal.md,
  * configuration.md); this file is where they are registered.
@@ -14,45 +16,58 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { ProjectTrustStore, VERSION as PI_VERSION, getAgentDir, readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { ProjectTrustStore, SessionManager, VERSION as PI_VERSION, copyToClipboard, getAgentDir, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { ARCHIVE_EXT, type ActivateMode, applyImport, automationOf, defaultExportPath, exportSession, importSession, offerToEnable, parseActivateMode } from "./archive.ts";
 import { Box, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { parseAddArgs, parseSetArgs, splitCommand, tokenize } from "./args.ts";
 import { envFlag, loadConfig } from "./config.ts";
-import { GOAL_ENTRY, type GoalAction, type GoalState, MAX_CONTINUATIONS, abortedTurn, applyDecision, branchMovedSince, continuationPrompt, evaluatorPrompt, latestGoal, newGoal, parseDecision, pauseFor, transcriptFromMessages } from "./goal.ts";
-import { sameProject } from "./presence.ts";
-import { isExactlyTrusted, sessionTrustCovers } from "./trust.ts";
+import { GOAL_ENTRY, type GoalAction, type GoalState, MAX_CONTINUATIONS, abortedTurn, applyDecision, branchMovedSince, continuationPrompt, evaluationApplies, evaluatorPrompt, goalPursued, judgeCaughtUp, latestGoal, newGoal, parseDecision, pauseFor, resumeGoal, settledTurn, transcriptFromMessages } from "./goal.ts";
+import { sameProject } from "./paths.ts";
+import { olderPiOnSession } from "./presence.ts";
+import { isExactlyTrusted, projectNeedsTrust, sessionTrustCovers, windowTrusted } from "./trust.ts";
 import { HookRunner, type HookEventData, messageKind, messageSummary, resultSummary, runEndEvent, runStartEvent, truncateSummary } from "./hooks.ts";
-import { failingSummary } from "./job-health.ts";
+import { failingSummary, ruleFailureMark } from "./job-health.ts";
 import { loopSignal, signalSummary } from "./job-signal.ts";
 import { LoopsLog, pruneLogs } from "./log.ts";
-import { type InboxEntry, belongsToProject, inProject, resolveInboxRef } from "./inbox.ts";
+import { type Inbox, type InboxEntry, belongsToProject, inProject, resolveInboxRef } from "./inbox.ts";
 import { McpPool } from "./mcp-pool.ts";
 import { McpSource, PI_BUILTIN_TOOL_NAMES, type McpServerConfig, type McpToolDef, droppedNotificationMessage, loadMcpConfigFiles, mapNotification, mcpToolDefinitions, mcpTokenFromEnv } from "./mcp.ts";
 import { capRedacted, previewRedacted, redact } from "./redact.ts";
+import { cardLines, cardOrigin, claimPrompt, dismissOutcome, dismissTail, inboxCard, screenText } from "./inbox-card.ts";
 import { shouldEmitSnapshot, snapshotFingerprint } from "./snapshot.ts";
-import { type ShareMessage, renderShare, shareSummary } from "./share.ts";
-import { installLauncherWithConfirm, installedByPi, launcherSource, launcherState, launcherTarget, refreshLauncher } from "./cli.ts";
+import { FRESH_RUNS_READ, burstLine, freshRuns, panelRuns, placeRunCards, runCardDelivery, runCardLines, runCardsHere, runLine } from "./run-card.ts";
+import { type ShareMessage, renderShare, shareSummary, shareableMessages } from "./share.ts";
+import { UsageError, addLauncher, installLauncherWithConfirm, installedByPi, launcherAction, launcherSource, launcherState, launcherTarget, openPage, pageLaunchHost, refreshLauncher, slashDir, stopAndWait, stopService, uninstallLauncher, webPageRequest } from "./cli.ts";
+import { copyText, isRemoteTty } from "./browser-open.ts";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { computeDue, computeNext, formatLocal, formatSchedule, localOffset, parseSchedule, stamp } from "./schedule.ts";
 import { applyJobEdit } from "./job-edit.ts";
 import { jobLines as cronJobLines } from "./job-lines.ts";
-import { runsIn } from "./job-owner.ts";
-import { AUTONOMY_LEVELS, type AutonomyLevel, INSTALL_ROOT, RECIPE_TIERS, type Recipe, type UpdateResult, addLineFor, ensureExcluded, installDirFor, installFiles, installedRecipes, isRecipeName, listRecipes, MAX_SETUP_SHOWN, TRACKER_FILE, loadRecipe, neverSection, packagedRecipesDir, parseAddWords, planInstall, playbookFiles, preflightChecks, purgeInstall, readRecord, renderPreflight, requireRecipeName, resolveRecipeRef, runPreflight, updateFiles } from "./recipe.ts";
+import { openWhere, runsHere } from "./job-owner.ts";
+import { type AcquireOutcome, LeaseBinding, LeaseStore, TURN_EVENTS, type TurnMarks, closedConversation, markTurnEvent, openWindowPids, procStart, turnSinceOf } from "./lease.ts";
+import { type DrainOptions, type EngineSinks, type HandOverDeps, type HandOverOutcome, type Producer, type RowAddress, armRetry, cancelRow, coalesced, drain, dropContinuations, goalRow, handOver as engineHandOver, handOverTarget, heldTurnFor, inboxClaimRow, newTriggerRow, promotionTarget, promotionView, pushRunRow, recipeRow, releaseLocalRows, ringProduced, ruleResultRow, stopRow, waitingLine } from "./engine.ts";
+import { PANEL_RUN_LIMIT, heldJobsNotice, leftConversationLine, panelLines, pickQueued, plural, queueLines, toolsCapNotice } from "./job-lines.ts";
+import { RequestStore, type SessionRequest } from "./requests.ts";
+import { WindowExecutor, unattendedTurn } from "./window-executor.ts";
+import { type GuardAnswer, WINDOW_GUARD_CONFIRM_MS, askRefusingFirst, windowGuard } from "./window-guard.ts";
+import { AUTONOMY_LEVELS, type AutonomyLevel, INSTALL_ROOT, installScope, RECIPE_TIERS, type Recipe, type UpdateResult, addLineFor, ensureExcluded, installDirFor, installFiles, installedRecipes, isRecipeName, listRecipes, MAX_SETUP_SHOWN, TRACKER_FILE, loadRecipe, neverSection, packagedRecipesDir, parseAddWords, planInstall, playbookFiles, preflightChecks, purgeInstall, readRecord, renderPreflight, requireRecipeName, resolveRecipeRef, runPreflight, updateFiles } from "./recipe.ts";
 import { LoopScheduler, type SessionSnapshot } from "./scheduler.ts";
 import { MAX_PROMPT_BYTES, type LoopJob, type RunRecord, defaultLoopsDir, newId, resolveJobRef, sessionExists } from "./store.ts";
 import { parentRuntimeFlags, type SubagentRequest } from "./runner.ts";
 import { createInProcessRunner } from "./sdk-runner.ts";
 import { SubagentSlots } from "./slots.ts";
-import { askHost, renderHostSnapshot } from "./host-control-channel.ts";
-import { waitForHost, HOST_LOG, crashedHost, hostPushWork, liveHost, piPackageDir, shouldHandOff, spawnHost, stopHost } from "./host-control.ts";
+import { askHost, noticesToShow, renderHostSnapshot, ringHost, type HostSnapshot } from "./host-control-channel.ts";
+import { HOST_LOG, crashPaused, crashPauseText, decideEviction, ensureHost, evictHost, heartbeatFresh, hostPushWork, hostServiceAlive, LEAVE_WAIT_MS, RESTART_WAIT_LINE, piPackageDir, readHostService, readSpawnLog, type HostServiceRecord } from "./host-control.ts";
 import { summarizeSessionFile } from "./transcript.ts";
-import { TriggerRuntime, type TriggerOutcome } from "./trigger-runtime.ts";
-import { auditArgs, auditCronFinish, auditCronStart, TriggerStore, buildPeriodicCheckTrigger, controlPlanePreflight, resolveRuleRef } from "./triggers.ts";
-import { type ControlPlaneRequest, type CreateJobInput, type JobScope, type ToolHost, automationTools, checkJobName, createLoopJob, resolveJobRefScoped } from "./tools.ts";
-import { panelEnabled, readUiPrefs, writeUiPref } from "./ui-prefs.ts";
+import { TriggerRuntime, type TriggerOutcome, promotionToInbox } from "./trigger-runtime.ts";
+import { scheduleAudit } from "./job-tune.ts";
+import { auditArgs, auditCronFinish, auditCronStart, newTraceId, TriggerStore, buildPeriodicCheckTrigger, controlPlanePreflight, resolveRuleRef } from "./triggers.ts";
+import { type ControlPlaneRequest, type CreateJobInput, type JobScope, type ToolHost, automationTools, checkJobName, createLoopJob, resolveJobRefScoped, toolsDropped } from "./tools.ts";
+import { claimPageChild } from "./page-children.ts";
+import { clearUiPref, panelEnabled, readUiPrefs, writeUiPref } from "./ui-prefs.ts";
+import { ALL_PROJECTS, awayIn, awayLine, markProjectSeen } from "./seen.ts";
 import * as fs from "node:fs";
 import * as os from "node:os";
 
@@ -62,6 +77,10 @@ const GOAL_STATUS_KEY = "pi-loops-goal";
 /** The evaluator is one tool-less read of a capped transcript; it must not hold a turn for 15 minutes. */
 const GOAL_EVALUATOR_TIMEOUT_MS = 120_000;
 import { PI_LOOPS_VERSION } from "./version.ts";
+import { pidAlive } from "./lock.ts";
+import { shortSessionId } from "./session-head.ts";
+import { ruleLines as listRules, triggerStatusLines } from "./rule-lines.ts";
+import { projectLabel } from "./conversation-rows.ts";
 
 interface ViewData {
 	title: string;
@@ -71,14 +90,6 @@ interface ViewData {
 export default function piLoops(pi: ExtensionAPI) {
 	/** Trigger hop, for cycle suppression: the interactive pi is 0; the sub-agents it runs are 1. */
 	const hop = 0;
-	/** `/cron host start|stop`: this pi's override of `[host] auto` for the hand-off when it quits. */
-	let handOffOnQuit: boolean | undefined;
-	/**
-	 * The hand-off rule, in one place: this pi's `/cron host start|stop` if it said anything, else
-	 * `[host] auto`. Three sites read it — the card, the scheduler line and the shutdown decision —
-	 * and each used to spell it out again, one of them leaning on `??` binding tighter than `?:`.
-	 */
-	const handsOffOnQuit = (): boolean => handOffOnQuit ?? config.hostAuto;
 	const dir = defaultLoopsDir(getAgentDir());
 	/** Everything this process diagnoses, kept after the window is gone. */
 	const log = new LoopsLog(dir, `pi-${process.pid}.log`);
@@ -87,6 +98,52 @@ export default function piLoops(pi: ExtensionAPI) {
 
 	let session: SessionSnapshot = { cwd: process.cwd() };
 	let lastCtx: ExtensionContext | undefined;
+	/**
+	 * This instance's claim on its conversation (src/lease.ts). Its plain jobs fire and its requests
+	 * are delivered only while it holds the lease; a second window on the same conversation is a viewer.
+	 * The scheduler's presence entry carries the same instance id.
+	 */
+	const instance = newId("pi");
+	const ownStart = procStart(process.pid);
+	let leaseMode: "tui" | "rpc" | "print" | "json" | "unbound" = "unbound";
+	/** A conversation open in the browser page: the background process starts its pi for it (src/page-children.ts `claimPageChild`: read once, kept across this factory's re-runs, not inherited by tool processes). */
+	const pageChild = claimPageChild();
+	// A page child and a terminal say on the lease when a turn runs (markTurn): `turns` tells a reader to expect it.
+	const binding = new LeaseBinding(new LeaseStore(dir), instance, () => ({ kind: "terminal", pid: process.pid, procStart: ownStart, mode: leaseMode, pushServers: [], ...(pageChild ? { page: true as const } : {}), ...(pageChild || leaseMode === "tui" ? { turns: true as const } : {}) }));
+	/** What happened in this project since anyone looked, in a terminal or the page (src/seen.ts): the page's away card says the same. */
+	function awayHere() {
+		return awayIn(dir, session.cwd, session.sessionId);
+	}
+	/** Listing `/inbox` is the terminal's Mark all seen: for this project, or every project with `--all`. */
+	function markSeenIfShown(everywhere: boolean): void {
+		markProjectSeen(dir, everywhere ? ALL_PROJECTS : session.cwd, stamp());
+	}
+	/** Closed, and the host may take it (src/lease.ts closedConversation); a 0.22 window counts as open. */
+	/** A conversation a pi-loops 0.22 window has open: it has no lease, and never reads requests/. */
+	const legacyOpen = (id: string): boolean => scheduler.presenceList().some((e) => e.sessionId === id && !e.leases && e.kind !== "host");
+	function closedHere(sessionId: string | undefined): boolean {
+		return closedConversation(binding.store, sessionId, legacyOpen);
+	}
+	const requests = new RequestStore(dir);
+	/** The engine's executor here: the pi this extension runs in (src/window-executor.ts). */
+	/** This process, as the rows it produces name it: the one that runs them while it is on the conversation. */
+	const self: Producer = { pid: process.pid, procStart: ownStart };
+	const executor = new WindowExecutor(
+		pi,
+		binding,
+		() => lastCtx,
+		self,
+		undefined,
+		() => {
+			const sessionId = binding.here().sessionId;
+			return sessionId ? requests.list(sessionId) : [];
+		},
+		(row) => requests.images(row),
+	);
+	let requestWatch: fs.FSWatcher | undefined;
+	let storeWatch: fs.FSWatcher | undefined;
+	/** The holder pid this window last told the person about, so the viewer line is said once per change. */
+	let viewerNoticeFor: number | undefined;
 	let schedulerStarted = false;
 	/**
 	 * Whether this extension instance has already had its `session_start`.
@@ -102,22 +159,28 @@ export default function piLoops(pi: ExtensionAPI) {
 	 * what this counts.
 	 */
 	let startHandled = false;
-	/** The two trigger sources this process *is*: the local crontab, and the dynamic-rule checker. */
+	/** From session_shutdown on: the lease goes back during it, and another window may write next. */
+	let leaving = false;
+	/** The two local trigger sources the host runs: the crontab, and the dynamic-rule checker. */
 	const LOCAL_SOURCES = 2;
-	/**
-	 * Whether those two are connected. They are this process's own scheduler, so they are live only
-	 * while it is scheduling *and* owns the clock; on a non-leader the enumeration below has always
-	 * called them `standby`, and the count above it used to call them connected in the same breath.
-	 */
-	const localSourcesConnected = (): boolean => schedulerStarted && scheduler.isLeader;
+	/** Whether those two are connected: they run in the always-on host, so they are live while it is. */
+	const localSourcesConnected = (): boolean => !!liveHostRecord();
+	/** The host this loops directory has, when its process is really there. */
+	const liveHostRecord = (): HostServiceRecord | undefined => {
+		const rec = readHostService(dir);
+		return rec && hostServiceAlive(rec) ? rec : undefined;
+	};
 
+	/** `pi --approve` (pi's own spelling of it): trust for this process, which pi grants without asking. */
+	const APPROVED = process.argv.slice(2).some((arg) => arg === "--approve" || arg === "-a");
 	/** This session as the schedulers see it: the project, the model and the thinking level of the chat. */
 	const sessionSnapshot = (ctx: ExtensionContext): SessionSnapshot => ({
 		sessionId: ctx.sessionManager.getSessionId(),
 		cwd: ctx.cwd,
 		model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
 		thinking: ctx.thinkingLevel,
-		trusted: ctx.isProjectTrusted(),
+		trusted: windowTrusted(getAgentDir(), ctx.cwd, ctx.isProjectTrusted(), APPROVED),
+		builtinTools: pi.getActiveTools().filter((t) => PI_BUILTIN_TOOL_NAMES.includes(t)),
 	});
 	/**
 	 * Sub-agents run inside this process through pi's SDK: the same
@@ -174,6 +237,7 @@ export default function piLoops(pi: ExtensionAPI) {
 	const subagentSlots = new SubagentSlots(() => config.maxConcurrentRuns);
 
 	const scheduler: LoopScheduler = new LoopScheduler({
+		writesNextRuns: () => !liveHostRecord(),
 		dir,
 		hop,
 		slots: subagentSlots,
@@ -181,15 +245,20 @@ export default function piLoops(pi: ExtensionAPI) {
 		getSettings: () => ({ maxConcurrentRuns: config.maxConcurrentRuns, catchUp: config.cronCatchUp, dailyBudgetUsd: config.dailyBudgetUsd }),
 		runner,
 		kind: "interactive",
+		instance,
+		leases: {
+			heldEpoch: (id) => binding.heldEpoch(id),
+			holderOf: (id) => binding.holderOf(id),
+			standsAside: () => binding.standingAside,
+			holderKind: (id) => binding.holderKindOf(id),
+			hostRuns: (id) => closedHere(id),
+			hostPaused: () => hostPauseReason(),
+		},
+		// A window fires only the plain jobs of the conversation it holds; every loop runs in the host.
+		owns: (job, view) => !job.stateful && runsHere(job, view),
 		// A plain job whose session is gone is parked, /cron gc removes it.
 		sessionExists: (id) => sessionExists(path.join(getAgentDir(), "sessions"), id),
 		hooks: {
-			onInject: (_job, prompt, runId) => {
-				if (!lastCtx) return;
-				const idle = lastCtx.isIdle();
-				pi.sendUserMessage(prompt, idle ? undefined : { deliverAs: "followUp" });
-				triggeredTurnLine(runId, idle);
-			},
 			onRunStart: (job, runId) => {
 				auditCronStart(triggers.store, job, runId);
 				refreshBadge();
@@ -199,20 +268,36 @@ export default function piLoops(pi: ExtensionAPI) {
 				if (lastCtx?.hasUI && sameProject(job.cwd, session.cwd)) lastCtx.ui.notify(`cron ${job.name ?? job.id}: catching up the run missed at ${formatLocal(dueAt)}`, "info");
 			},
 			onJobRetired: (job) => cronControlAudit("remove", "scheduler", job, undefined),
-			onRunFinished: ({ job, record, findings, result }) => {
+			// A row this window wrote is its own (`/cron run`'s is the person's). While pi is busy the row
+			// waits in the file, where nothing else shows it: said once, as pi said a queued follow-up.
+			onRowWritten: (row, job) => {
+				executor.produced(row);
+				const line = waitingLine(row.source, row.id, job.name ?? job.id);
+				if (line && lastCtx?.hasUI && !lastCtx.isIdle()) lastCtx.ui.notify(line, "info");
+				refreshBadge();
+			},
+			onRunFinished: ({ job, record, result }) => {
 				auditCronFinish(triggers.store, job, record, result.stopReason === "aborted");
 				refreshBadge();
 				fireRunHook(runEndEvent(job, record));
 				if (!lastCtx?.hasUI) return;
 				// Another project's findings and prompt previews do not belong in this transcript; the
 				// audit sink below and the inbox already carry them to where they do.
-				if (sameProject(job.cwd, session.cwd)) showRunCard(lastCtx, job, record, findings);
+				if (sameProject(job.cwd, session.cwd)) showRunCard(lastCtx, job.name, record);
 			},
 			onInboxChanged: () => refreshBadge(),
-			// Dynamic triggers piggyback on the same 30s tick (leader only). MCP pushes are consumed
-			// by every interactive process and deduplicated machine-wide (see startMcpSources).
-			onTick: (now, leader): Promise<void> => triggers.tick(now, leader),
-			onLeadership: async () => refreshBadge(),
+			// Rule checks run in the host. A window handles only the inject_* pushes for the
+			// conversation it holds, deduplicated machine-wide (see startMcpSources).
+			onTick: () => {
+				leaseTick();
+				showFinishedRuns();
+				// A change inside the snapshot's minimum gap is held back, not lost: the next tick writes it.
+				emitSnapshot();
+				// Runs happen in the background now, so nothing else tells the status line and the panel
+				// that one started, finished or filed a finding: redraw them after each look.
+				if (binding.here().holds) hostTick(true).then(() => refreshBadge()).catch((err: any) => log.info(`host: ${err?.message ?? err}`));
+				else refreshBadge();
+			},
 			// These carry "job disabled", "state write failed", "cannot read jobs"; the scheduler says
 			// which of its lines are routine instead of leaving it to be guessed from the wording.
 			log: (msg, level) => diagnostic(msg, level),
@@ -236,26 +321,34 @@ export default function piLoops(pi: ExtensionAPI) {
 		// same counter rather than on a second one of their own.
 		slots: subagentSlots,
 		budget: () => scheduler.budgetState(),
+		inbox: scheduler.inbox,
 		hop,
-		// A project's checks run in a pi open in that project, so a result lands in the conversation it belongs to.
-		self: scheduler.self,
-		presence: () => scheduler.presenceList(),
-		isLeader: () => scheduler.isLeader,
 		hooks: {
-			onPromote: async (content, trigger) => {
-				// Promotion = the result becomes visible to future turns (inserting a `[Trigger …]` user
-				// message into the parent session). Only into a chat that belongs to the rule's project;
-				// a different project's chat gets nothing — the finding goes to the inbox instead.
-				if (trigger.cwd && !sameProject(trigger.cwd, session.cwd)) {
-					await scheduler.inbox.append({ source: `trigger:${trigger.sourceLabel}`, text: content.replace(/^\[Trigger [^\]]+\]\s*/, ""), run_id: trigger.traceId, job_id: trigger.sourceLabel, cwd: trigger.cwd });
+			onPromote: async (content, trigger, forSession) => {
+				// A rule's result is a request addressed to a conversation (src/engine.ts promotionTarget):
+				// the creating one while a window holds it, else one a window holds in the rule's project,
+				// this one included, else the closed creating one; delivered here when this window holds the
+				// target, by the holding window or the background process otherwise. A rule with no cwd of its
+				// own is this project's.
+				const here = binding.here();
+				const route = promotionTarget(forSession, promotionView(binding.store, trigger.cwd ?? session.cwd, legacyOpen));
+				if (route.to === "inbox") {
+					// The check decided this result's finding already (TriggerRuntime's inbox); a push with no rule did not.
+					await promotionToInbox(scheduler.inbox, triggers.store, content, trigger, { cwd: trigger.cwd ?? session.cwd, sessionId: route.sessionId });
 					refreshBadge();
 					return "inbox";
 				}
-				// Idle → inserted without a model call; streaming → follow-up queue, which runs a turn
-				// once the current one ends so the agent sees it without waiting for the next prompt.
-				if (lastCtx?.isIdle() ?? true) pi.sendMessage({ customType: "pi-loops:trigger", content, display: true }, { triggerTurn: false });
-				else pi.sendMessage({ customType: "pi-loops:trigger", content, display: true }, { triggerTurn: true, deliverAs: "followUp" });
-				return "chat";
+				const target = route.sessionId;
+				requests.append(ruleResultRow(target, content, { ...trigger, cwd: trigger.cwd ?? session.cwd }, createdBy()));
+				if (target !== here.sessionId || !here.holds) {
+					// Another window's conversation drains on its own watcher; a closed one is the background
+					// process's, which hears this instead of waiting for its tick. Never awaited: the row is
+					// on disk, and a lost ring costs one tick.
+					void ringHost(dir, `request:${target}`).catch(() => undefined);
+					return "queued";
+				}
+				const result = await drainRequests();
+				return result?.removed.includes(trigger.traceId) ? "chat" : "queued";
 			},
 			onInjectAndRun: async (prompt, trigger) => {
 				if (trigger.cwd && !sameProject(trigger.cwd, session.cwd)) {
@@ -263,10 +356,9 @@ export default function piLoops(pi: ExtensionAPI) {
 					refreshBadge();
 					return "inbox";
 				}
-				const idle = lastCtx?.isIdle() ?? true;
-				pi.sendUserMessage(prompt, idle ? undefined : { deliverAs: "followUp" });
-				triggeredTurnLine(trigger.traceId, idle);
-				return "chat";
+				// The turn is a row like a plain job's: pi gets it while idle, Esc has nothing of ours to drop.
+				const { written, result } = await handOver(pushRunRow(prompt, trigger, rowAddress()));
+				return handOverTarget(written, result, trigger.traceId);
 			},
 			onStarted: () => refreshBadge(),
 			onFinished: (outcome) => {
@@ -283,14 +375,20 @@ export default function piLoops(pi: ExtensionAPI) {
 	});
 	// Trigger audit is kept as session custom entries (trigger / trigger_result / trigger_promotion),
 	// so it resumes with the session and travels in archives, on top of the machine-wide JSONL.
+	/**
+	 * Whether this window may write entries into its conversation. A viewer writes nothing into the
+	 * conversation another window holds: an entry on its own stale branch made the holder's later turns
+	 * a dead branch once this window took the conversation over.
+	 */
+	const mayAppend = (): boolean => !!lastCtx && !leaving && binding.viewerOf === undefined && !binding.standingAside;
 	triggers.store.onAudit = (record) => {
-		if (!lastCtx) return;
-		// Only this project's rows: the leader covering another project must not put that project's
+		if (!mayAppend()) return;
+		// Only this project's rows: a result for another project must not put that project's
 		// output into this session (and its archives).
 		if (record.cwd && !sameProject(record.cwd, session.cwd)) return;
 		pi.appendEntry(record.type, record);
 	};
-	pi.registerFlag("trigger-poll-secs", { type: "string", description: "Dynamic trigger poll interval in seconds (pi-loops; default 600 or config.toml [triggers].poll_interval_secs)" });
+	pi.registerFlag("trigger-poll-secs", { type: "string", description: "Ignored: pi-loops checks rules every [triggers] poll_interval_secs in config.toml (pi-loops)" });
 
 	const mcpSources: McpSource[] = [];
 	/** Project-level MCP servers of *other* projects, connected on demand for their loops. */
@@ -383,9 +481,9 @@ export default function piLoops(pi: ExtensionAPI) {
 			const source = new McpSource(cfg, {
 				onConnected: (src) => registerMcpTools(src),
 				onNotification: (n) => {
-					// Every interactive process consumes what it receives; the machine-wide dedup window
-					// (dedup.json) guarantees a push that several pi processes see is handled exactly
-					// once, and the promotion hooks route results to the right project's chat or inbox.
+					// A window handles only the inject_* pushes for the conversation it holds; the
+					// machine-wide dedup window (dedup.json) makes a push that several processes see count
+					// once. Rule pushes are the host's (below).
 					const trigger = mapNotification(cfg.name, n);
 					if (!trigger) {
 						source.status.droppedCount++;
@@ -394,6 +492,23 @@ export default function piLoops(pi: ExtensionAPI) {
 					}
 					trigger.cwd = session.cwd;
 					const delivery = cfg.injectAndRun ? "inject_and_run" : cfg.injectSummary ? "inject_summary" : "sub_agent";
+					// Rules are evaluated by the host alone, on its own connection to the server. It connects a
+					// project's own servers only once pi has saved trust for that directory: before that, this
+					// push reaches no rule, and the source says so rather than dropping it without a word.
+					if (delivery === "sub_agent") {
+						if (cfg.source === "project" && !isExactlyTrusted(getAgentDir(), session.cwd)) {
+							source.status.droppedCount++;
+							source.status.lastError = "rule pushes are checked in the background, which connects this project's servers only after /trust saves trust for it";
+						}
+						return;
+					}
+					// The window holding this conversation injects it; a second window on it would put it there twice.
+					if (binding.viewerOf !== undefined) return;
+					if (binding.standingAside) {
+						source.status.droppedCount++;
+						source.status.lastError = "this window shows an older copy of its conversation; /resume it to take pushes again";
+						return;
+					}
 					void triggers
 						.handle(trigger, delivery)
 						.then((out) => {
@@ -424,10 +539,13 @@ export default function piLoops(pi: ExtensionAPI) {
 		await Promise.all(sources.map((s) => s.stop()));
 	}
 
-	/** Trigger output as a bounded card in the transcript, never an LLM message. */
+	/**
+	 * Trigger output as a bounded card in the transcript, never an LLM message. A rule check cards
+	 * only when it failed: a match is a finding in the inbox (and in the chat with `promote_to_chat`),
+	 * and the panel's Polling line says it; a quiet check stays in /triggers status and the audit.
+	 */
 	function showTriggerCard(ctx: ExtensionContext, outcome: TriggerOutcome): void {
-		const quiet = outcome.ok && outcome.delivery === "sub_agent" && outcome.matchedRules.length === 0;
-		if (quiet) return; // quiet checks stay in /triggers status + audit, not in the panel
+		if (outcome.ok && outcome.delivery === "sub_agent") return;
 		const secs = Math.round(outcome.durationMs / 1000);
 		const cost = outcome.cost ? ` · $${outcome.cost.toFixed(3)}` : "";
 		const title = outcome.ok
@@ -469,7 +587,8 @@ export default function piLoops(pi: ExtensionAPI) {
 	/* ------------------------------------------------------------ panel */
 
 	const PANEL_KEY = "pi-loops-panel";
-	const PANEL_RULE_LIMIT = 5; // more than five rules is a list, not a panel
+	/** This project's latest finished runs, oldest first, as showFinishedRuns last read them. */
+	let recentRuns: RunRecord[] = [];
 	let panelOn = panelEnabled(readUiPrefs(dir));
 
 	function setPanelEnabled(on: boolean): void {
@@ -482,8 +601,9 @@ export default function piLoops(pi: ExtensionAPI) {
 	}
 
 	/**
-	 * The panel (Triggers / Polling / Inbox / Cron / sources), rendered as a widget
-	 * above the editor. Hidden when there is nothing to show.
+	 * The panel (Rules / Last check / Loops / Runs / MCP / Hooks; src/job-lines.ts panelLines), rendered as a widget
+	 * above the editor. Hidden when there is nothing to show. A run that writes no card into the
+	 * conversation is seen here, in the Runs block.
 	 */
 	function refreshPanel(): void {
 		try {
@@ -499,71 +619,402 @@ export default function piLoops(pi: ExtensionAPI) {
 			lastCtx.ui.setWidget(PANEL_KEY, undefined);
 			return;
 		}
-		const rules = triggers.store.load().filter((r) => sameProject(r.cwd, session.cwd));
-		const jobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd));
-		const inboxNew = scheduler.inbox.newCount();
-		const poll = triggers.lastPoll;
-		const sources = mcpSources.map((src) => ({ name: src.config.name, state: src.status.state, tools: (mcpToolNames.get(src.config.name) ?? []).length }));
-		if (!rules.length && !jobs.length && !inboxNew && !sources.length) {
+		const lines = panelLines({
+			rules: triggers.store.load().filter((r) => sameProject(r.cwd, session.cwd)).map((r) => ({ ...r, failureMark: ruleFailureMark(r) })),
+			poll: lastPoll(),
+			jobs: scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd)),
+			runs: recentRuns,
+			runText: runLine,
+			sources: mcpSources.map((src) => ({ name: src.config.name, state: src.status.state, tools: (mcpToolNames.get(src.config.name) ?? []).length })),
+			hookEvents: hookRunner?.hooks.map((h) => h.event) ?? [],
+		});
+		if (!lines.length) {
 			lastCtx.ui.setWidget(PANEL_KEY, undefined);
 			return;
 		}
-		const clip = (x: string, n: number) => previewRedacted(x, n);
 		lastCtx.ui.setWidget(PANEL_KEY, (_tui, theme) => {
-			const dim = (x: string) => theme.fg("dim", x);
-			const head = (x: string) => theme.fg("accent", x);
-			const ok = (x: string) => theme.fg("success", x);
-			const warn = (x: string) => theme.fg("warning", x);
-			const lines: string[] = [];
-			if (rules.length) {
-				lines.push(head("Triggers"));
-				for (const r of rules.slice(0, PANEL_RULE_LIMIT)) {
-					lines.push((r.enabled ? ok : dim)(`${r.id.slice(0, 12)} [${r.enabled ? "enabled" : "disabled"}, ${r.fireOnce ? "once" : "repeat"}]`) + dim(`  when ${clip(r.condition, 40)}  do ${clip(r.action, 40)}`));
+			const colour = { head: "accent", ok: "success", dim: "dim", warn: "warning" } as const;
+			return new Text(lines.map((l) => theme.fg(colour[l.tone], l.text)).join("\n"), 0, 0);
+		});
+	}
+
+	/** The engine's sinks here: the jobs the rows name, the inbox for dead letters, the audit. */
+	const engineSinks = (): EngineSinks => ({ jobs: { exists: (id) => scheduler.store.load().some((j) => j.id === id), enabled: (id) => scheduler.store.load().find((j) => j.id === id)?.enabled ?? false, goalActive: () => goalPursued(goal) }, inbox: scheduler.inbox, audit: triggers.store });
+	/** One drain per session for when a wait ends on its own (the ring wait on a page's row), replaced, never stacked. */
+	const retryTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	/**
+	 * What is addressed to this conversation, delivered through the executor: everything while this
+	 * window holds it, its own local rows regardless (src/engine.ts). `tick` marks the scheduler's
+	 * drain, the one that may judge a hand-over pi never answered.
+	 */
+	async function drainRequests(opts: DrainOptions = {}) {
+		const sessionId = binding.here().sessionId;
+		if (!sessionId) return undefined;
+		const now = Date.now();
+		const result = await drain(sessionId, requests, executor, now, engineSinks(), opts);
+		if (result.retryAt !== undefined) armRetry(retryTimers, sessionId, result.retryAt - now + 50, () => void drainRequests().catch((err: any) => log.info(`requests: ${err?.message ?? err}`)));
+		// The badge counts what waits in the file: a drain is when that changes.
+		if (result.delivered.length || result.removed.length || result.dead.length) refreshBadge();
+		return result;
+	}
+	const createdBy = (): SessionRequest["created_by"] => ({ pid: process.pid, instance, procStart: ownStart, version: PI_LOOPS_VERSION });
+	/** Where a row this window produces is addressed: this conversation, in this project. */
+	const rowAddress = (): RowAddress => ({ sessionId: binding.here().sessionId ?? session.sessionId ?? "", cwd: session.cwd, createdBy: createdBy() });
+	/** Whether a row's proof is in this conversation already (src/engine.ts landed): such a row collapses nothing, and `agent_settled` no longer waits for it. */
+	const delivered = (id: string) => executor.delivered(id);
+	const handOverDeps = (): HandOverDeps => ({ store: requests, delivered, produced: (row) => executor.produced(row), drain: drainRequests });
+	/** A prompt one of this window's sources has for the chat (src/engine.ts handOver), and the line that says it waits. */
+	async function handOver(row: SessionRequest, claim?: { inbox: Inbox; entryId: string }): Promise<HandOverOutcome> {
+		const out = await engineHandOver(handOverDeps(), row, claim);
+		if (out.line && lastCtx?.hasUI) lastCtx.ui.notify(out.line, "info");
+		return out;
+	}
+
+	function noteBinding(outcome: AcquireOutcome): void {
+		if (outcome.outcome === "acquired" && outcome.tookFromPid) log.info(`took session ${shortSessionId(outcome.lease.sessionId)} from dead pid ${outcome.tookFromPid}`);
+		if (outcome.outcome === "acquired" && outcome.tookFromPage) sayInfo("[cron] this conversation was open in the page; it is yours now, and the page shows it is answered here");
+		if (outcome.outcome === "acquired") noteUnseenEntries(outcome.lease.sessionFile, !!outcome.tookFromHost?.runId);
+		const holder = outcome.outcome === "viewer" ? outcome.holderPid : undefined;
+		if (holder === viewerNoticeFor) return;
+		viewerNoticeFor = holder;
+		if (holder !== undefined) sayInfo(`[cron] this conversation is also ${openWhere(binding.holderKindOf(outcome.lease.sessionId))}; its scheduled messages and rule results arrive there, not in this window`);
+	}
+
+	/**
+	 * pi read the conversation before this window held it, so anything written in between — a rule
+	 * result pi-loops appended, or the turns of the window that held it before this one — is on disk
+	 * and not in this window. A turn fired from here would branch off the
+	 * old last entry and leave those on a dead branch, so the window stands aside until the person
+	 * resumes the conversation: it keeps the lease, and its plain jobs and rule results wait.
+	 */
+	function noteUnseenEntries(file: string | undefined, interruptedHost: boolean): void {
+		const ctx = lastCtx;
+		if (!ctx || !file || !fs.existsSync(file)) return;
+		// pi read the turn's entries as it opened the conversation, so the counts below agree: say it
+		// anyway. What the stopped turn writes after this is its tail, and this window's next entry
+		// takes the conversation's last place back, so there is no reason to stand aside for it.
+		if (interruptedHost) return sayInfo("[cron] pi-loops was answering a scheduled job in this conversation when you opened it, and stopped; /tree shows what it wrote");
+		try {
+			// `getEntries().length`, not `getEntryCount()`: the latter is newer than the pi floor.
+			if (SessionManager.open(file).getEntries().length <= ctx.sessionManager.getEntries().length) return;
+		} catch (err: any) {
+			log.info(`could not compare the session with what is on disk: ${err?.message ?? err}`);
+			return;
+		}
+		binding.standAside();
+		log.info(`session ${shortSessionId(binding.here().sessionId ?? "?")} is ahead on disk; standing aside until it is resumed`);
+		if (ctx.hasUI) afterHistory(ctx, () => ctx.ui.notify("[cron] this window shows an older copy of this conversation: it changed after this window read it. /resume this session to see it; until then its scheduled messages and rule results wait", "warning"));
+	}
+
+	/**
+	 * Take this conversation's lease, or become its viewer. Called from session_start and from the
+	 * first callbacks that carry a context, for a runtime that never sends session_start.
+	 */
+	function bindSession(ctx: ExtensionContext): void {
+		const sessionId = ctx.sessionManager.getSessionId();
+		if (!sessionId || binding.here().sessionId === sessionId) return;
+		leaseMode = ctx.mode === "tui" || ctx.mode === "rpc" || ctx.mode === "print" || ctx.mode === "json" ? ctx.mode : "unbound";
+		try {
+			leaveSession();
+		} catch (err: any) {
+			log.info(`requests: ${err?.message ?? err}`);
+		}
+		try {
+			noteBinding(binding.bind(sessionId, { sessionFile: ctx.sessionManager.getSessionFile(), cwd: ctx.cwd }));
+			watchRequests();
+		} catch (err: any) {
+			log.info(`lease: ${err?.message ?? err}`);
+		}
+	}
+
+	/** Leaving the conversation this window is on (`/new`, `/resume`, quitting): the local rows it produced there are the holder's to run now. */
+	function leaveSession(): void {
+		const sessionId = binding.here().sessionId;
+		if (!sessionId) return;
+		const left = releaseLocalRows(requests, sessionId, self, (id) => executor.delivered(id));
+		if (left.length) log.info(`left ${left.length} queued request(s) of session ${shortSessionId(sessionId)} to its holder`);
+	}
+
+	/** A request written for this conversation lands without waiting for the tick; the tick drains as well, because fs.watch can miss events. */
+	function watchRequests(): void {
+		if (requestWatch) return;
+		const sessionId = binding.here().sessionId;
+		if (!sessionId) return;
+		const requestsDir = path.join(dir, "requests");
+		fs.mkdirSync(requestsDir, { recursive: true });
+		// One drain at a time and one more after it (src/engine.ts coalesced): every removal is a
+		// rewrite, and a rewrite is another event, so a burst of rows used to be three drains each.
+		const drainOnChange = coalesced(() => drainRequests().catch((err: any) => log.info(`requests: ${err?.message ?? err}`)));
+		requestWatch = fs.watch(requestsDir, (_event, name) => {
+			if (name !== `${sessionId}.jsonl`) return;
+			drainOnChange();
+		});
+		requestWatch.on("error", (err) => log.info(`requests watch: ${err?.message ?? err}`));
+	}
+
+	/**
+	 * A run in the background starting or finishing, a finding filed: shown when the file changes, not
+	 * up to 30 s later on the next tick. In 0.22 the run happened in this window and redrew it at once.
+	 * The tick still redraws as well, because fs.watch can miss events.
+	 */
+	const STORE_FILES = new Set(["runs.jsonl", "inbox.jsonl", "jobs.json"]);
+	let storeWatchTimer: ReturnType<typeof setTimeout> | undefined;
+	function watchStore(): void {
+		if (storeWatch || !lastCtx?.hasUI) return;
+		try {
+			storeWatch = fs.watch(dir, (_event, name) => {
+				if (!name || !STORE_FILES.has(String(name)) || storeWatchTimer) return;
+				storeWatchTimer = setTimeout(() => {
+					storeWatchTimer = undefined;
+					// A timer has nobody to throw to: an unreadable store would take pi down from here.
+					try {
+						showFinishedRuns();
+					} catch (err: any) {
+						storeReadFailed(err);
+					}
+					refreshBadge();
+				}, 250);
+				storeWatchTimer.unref();
+			});
+			storeWatch.on("error", (err) => log.info(`store watch: ${err?.message ?? err}`));
+		} catch (err: any) {
+			log.info(`store watch: ${err?.message ?? err}`); // the tick still redraws
+		}
+	}
+
+	/** Every scheduler tick: keep the lease (a viewer retries), list the injecting servers on it, and deliver this conversation's requests. */
+	function leaseTick(): void {
+		try {
+			const outcome = binding.refresh();
+			if (outcome) noteBinding(outcome);
+			binding.setPushServers(mcpSources.filter((src) => (src.config.injectSummary || src.config.injectAndRun) && src.status.state === "connected").map((src) => src.config.name));
+			drainRequests({ tick: true }).catch((err: any) => log.info(`requests: ${err?.message ?? err}`));
+		} catch (err: any) {
+			log.info(`lease: ${err?.message ?? err}`);
+		}
+	}
+
+	/** Why the host is not running when it should be, as the badge and `/cron host` say it; undefined while it runs or has nothing to run. */
+	/**
+	 * Why the loops are not running in a host right now, when they are not: it could not start, it kept
+	 * crashing and is paused, or it runs but its control socket does not answer. One value per state, so
+	 * a warning is said once per state change and not once per wording of the same failure.
+	 */
+	let hostState: { kind: "start-failed" | "crash-paused" | "channel-broken"; detail: string } | undefined;
+	const HOST_STATE_BADGE = { "start-failed": "loops paused: pi-loops could not start", "crash-paused": "loops paused: pi-loops keeps crashing", "channel-broken": "pi-loops is not answering" } as const;
+	/** The one-line reason, where a line has room for it. */
+	const hostProblemText = (): string | undefined => (hostState ? `${HOST_STATE_BADGE[hostState.kind]} — ${hostState.detail}` : undefined);
+	/**
+	 * Why loops, checks and the plain jobs of closed conversations will not run right now, or undefined
+	 * while a host runs or is about to. One answer for the badge, the `/cron` listing, the session-start
+	 * line and `/cron host`: a stop by hand, `[host] auto = false` and `PI_LOOPS_HOST=off` each pause
+	 * everything, and each used to leave every surface saying it would run.
+	 */
+	function hostPauseReason(): string | undefined {
+		if (liveHostRecord()) return undefined;
+		if (readUiPrefs(dir).host === "stopped") return "pi-loops is stopped — /pi-loops start";
+		if (process.env.PI_LOOPS_HOST?.toLowerCase() === "off") return "PI_LOOPS_HOST=off in this pi's environment";
+		// `[host] auto = false` pauses nothing while a window is open: this window starts the process, and
+		// it leaves with the last window (src/host-control.ts leavesWithWindows).
+		const spawns = readSpawnLog(dir);
+		if (crashPaused(spawns, Date.now())) return crashPauseText(spawns);
+		if (hostState?.kind === "start-failed") return `pi-loops could not start — ${hostState.detail}`;
+		return undefined;
+	}
+	/** Whether anything waits on the host: a pause with nothing to run is not news. */
+	const hostHasWork = (): boolean => {
+		const work = automationCounts();
+		return !!(work.loops || work.rules || work.pushServers || work.closedSessionJobs || work.closedMailboxes);
+	};
+	let hostChannelBroken: string | undefined;
+	/** The pause reason last said to the person, so a pause is announced once. */
+	let shownPause: string | undefined;
+	/** The host's last status answer (every tick's probe): loops and checks run there, so what is running is there. */
+	let hostSnapshot: HostSnapshot | undefined;
+	/** A fresh answer for a command that is about to show or act on what runs: the tick's may be 30 s old. */
+	async function refreshHostSnapshot(): Promise<HostSnapshot | undefined> {
+		const answer = liveHostRecord() ? await askHost(dir, { op: "status" }) : undefined;
+		hostSnapshot = answer?.ok ? answer.snapshot : undefined;
+		return hostSnapshot;
+	}
+	/**
+	 * Runs and checks in flight for this machine: this window's own (`/goal`, `/triggers run`) and the
+	 * host's. Every view of "what is running" reads this, or it showed only the window and missed every loop.
+	 */
+	function machineRuns(): Array<{ id: string; source: string; event: string; label: string; startedAt: string; promptPreview: string; sessionFile?: string; check: boolean; inHost: boolean }> {
+		return [
+			...triggers.runningList().map((r) => ({ id: r.traceId, source: r.sourceLabel, event: r.eventLabel, label: r.sourceLabel === "local:dynamic" ? "trigger-check" : r.sourceLabel, startedAt: r.startedAt, promptPreview: r.promptPreview, check: r.sourceLabel === "local:dynamic", inHost: false })),
+			...scheduler.runningRuns().map((r) => ({ id: r.runId, source: "Cron", event: r.jobId, label: r.label, startedAt: r.startedAt, promptPreview: r.promptPreview, sessionFile: r.sessionFile, check: false, inHost: false })),
+			...(hostSnapshot?.runs ?? []).map((r) => ({ id: r.runId, source: "Cron", event: r.jobId, label: r.label, startedAt: r.startedAt, promptPreview: r.promptPreview, sessionFile: r.sessionFile, check: false, inHost: true })),
+			// A run the background process started since this window last asked it: its marker is in
+			// jobs.json at once (see watchStore), the snapshot only on the next tick.
+			...storeRunning().filter((r) => !scheduler.runningRuns().some((x) => x.runId === r.id) && !(hostSnapshot?.runs ?? []).some((x) => x.runId === r.id)),
+			...(hostSnapshot?.checks ?? []).map((c) => ({ id: c.traceId, source: c.sourceLabel, event: c.eventLabel, label: c.sourceLabel === "local:dynamic" ? "trigger-check" : c.sourceLabel, startedAt: c.startedAt, promptPreview: `${c.sourceLabel}/${c.eventLabel} in ${c.cwd}`, check: c.sourceLabel === "local:dynamic", inHost: true })),
+		];
+	}
+	/** Runs the store has a `running` marker for (src/store.ts RunningMarker), in machineRuns' shape. */
+	function storeRunning(): Array<{ id: string; source: string; event: string; label: string; startedAt: string; promptPreview: string; check: boolean; inHost: boolean }> {
+		try {
+			// A marker whose process is gone is not a run (the background process clears it on its tick).
+			return scheduler.store.load().filter((j) => j.running && (!j.running.host || j.running.host === os.hostname()) && pidAlive(j.running.pid)).map((j) => ({ id: j.running!.runId, source: "Cron", event: j.id, label: j.name ?? j.id, startedAt: j.running!.startedAt, promptPreview: previewRedacted(j.prompt, 80), check: false, inHost: true }));
+		} catch {
+			return []; // an unreadable store is said elsewhere (storeReadFailed)
+		}
+	}
+	/** The latest rule check, this window's or the host's. */
+	const lastPoll = () => {
+		const mine = triggers.lastPoll;
+		// The host checks every project's rules; another project's result is not this one's to show.
+		const theirs = hostSnapshot?.lastPolls?.find((p) => sameProject(p.cwd, session.cwd));
+		if (!mine) return theirs;
+		if (!theirs) return mine;
+		return Date.parse(theirs.at) > Date.parse(mine.at) ? theirs : mine;
+	};
+	/** How far this window has read the background process's warnings (src/host-control-channel.ts noticesToShow). */
+	let noticesSeen: { pid: number; seq: number } | undefined;
+	function showNotices(snapshot: HostSnapshot, pid: number): void {
+		const out = noticesToShow(snapshot.notices ?? [], noticesSeen, pid, session.cwd, sameProject);
+		noticesSeen = out.seen;
+		for (const n of out.show) diagnostic(n.text);
+	}
+	/**
+	 * This project's latest rule check, as a card, when it failed: checks run in the background now.
+	 * A match is a finding in the inbox and the panel's Polling line, as in showTriggerCard.
+	 */
+	let checkShown: string | undefined;
+	let checkLooked = false;
+	function showCheckCard(snapshot: HostSnapshot): void {
+		const poll = snapshot.lastPolls?.find((p) => sameProject(p.cwd, session.cwd));
+		// The first look records what is there, even nothing: the first check after it is news.
+		const first = !checkLooked;
+		checkLooked = true;
+		if (!poll || poll.traceId === checkShown) return;
+		checkShown = poll.traceId;
+		if (first || poll.outcome === "no match" || /^matched/.test(poll.outcome) || !lastCtx?.hasUI) return; // the first look only records where things are
+		const title = `trigger ${poll.sourceLabel} FAILED (${poll.outcome})`;
+		const lines = [...(poll.summary ? previewRedacted(poll.summary, 600).split("\n").slice(0, 8) : []), `trace ${poll.traceId.slice(0, 8)} · /triggers audit`];
+		if (lastCtx.mode === "tui") show(lastCtx, title, lines);
+		else lastCtx.ui.notify([title, ...lines].join("\n"), "warning");
+	}
+	/** This window's count of failed probes of the host's socket (src/host-control.ts decideEviction). */
+	let hostProbeFailures = 0;
+	let hostTickRunning = false;
+	/** The host pid the badge, panel and snapshot last showed: one that came, went or changed is redrawn. */
+	let shownHostPid: number | undefined;
+
+	/** What there is for the host to run, as `ensureHost` counts it. */
+	function automationCounts(): { loops: number; rules: number; pushServers: number; closedSessionJobs: number; closedMailboxes: number } {
+		// Each store on its own: a damaged rules file stopped the loops too, because nothing then started
+		// the background process.
+		const rules = loadOrNone(() => triggers.store.load()).filter((r) => r.enabled).length;
+		const jobs = loadOrNone(() => scheduler.store.load()).filter((j) => j.enabled);
+		return {
+			loops: jobs.filter((j) => j.stateful).length,
+			rules,
+			pushServers: hostPushWork(loadMcpConfigFiles({ dir, projectTrusted: false }).servers, rules),
+			closedSessionJobs: jobs.filter((j) => !j.stateful && closedHere(j.sessionId)).length,
+			closedMailboxes: requests.sessions().filter((id) => closedHere(id)).length,
+		};
+	}
+
+	/**
+	 * Keep the host there: probe it (only a tick's probe counts toward evicting a wedged one, so a
+	 * host that is still starting when a window opens is never killed for it), then start it, or ask
+	 * an older one to make way, when there is automation to run. Returns what ensure decided.
+	 */
+	async function hostTick(fromTick: boolean, asked = false, wait = true): Promise<Awaited<ReturnType<typeof ensureHost>> | undefined> {
+		if (hostTickRunning) return undefined;
+		hostTickRunning = true;
+		try {
+			const rec = liveHostRecord();
+			if (rec) {
+				const answer = await askHost(dir, { op: "status" });
+				hostSnapshot = answer?.ok ? answer.snapshot : undefined;
+				if (hostSnapshot) {
+					showNotices(hostSnapshot, rec.pid);
+					showCheckCard(hostSnapshot);
 				}
-				if (rules.length > PANEL_RULE_LIMIT) lines.push(dim(`… ${rules.length - PANEL_RULE_LIMIT} more`));
-			}
-			if (poll) {
-				// Polling: checked_at · outcome, source / event, trace, summary.
-				lines.push(head("Polling") + warn(`  ${formatLocal(Date.parse(poll.at))} · ${poll.outcome}`));
-				lines.push(dim(`  ${poll.sourceLabel} / ${poll.eventLabel}  trace ${poll.traceId.slice(0, 8)}`));
-				lines.push(dim(`    ${clip(poll.summary, 80)}`));
-			}
-			if (inboxNew > 0) lines.push(warn(`Inbox  ${inboxNew} new — /inbox`));
-			if (jobs.length) {
-				const enabled = jobs.filter((j) => j.enabled).length;
-				lines.push(head("Cron") + (enabled === jobs.length ? ok : warn)(`  enabled ${enabled} · disabled ${jobs.length - enabled}`));
-				for (const j of jobs.slice(0, PANEL_RULE_LIMIT)) {
-					const label = j.name ?? j.id.slice(0, 12);
-					lines.push((j.enabled ? ok : dim)(`${label} [${j.enabled ? "enabled" : "disabled"}${j.stateful ? ", stateful" : ""}] ${formatSchedule(j.schedule)}`) + dim(`  do ${clip(j.prompt, 48)}`) + (j.skippedOverlap ? warn(`  skipped overlaps ${j.skippedOverlap}`) : ""));
+				const verdict = decideEviction({ failures: hostProbeFailures, probeOk: !!answer?.ok, fromTick, pidMatches: hostServiceAlive(rec), heartbeatFresh: heartbeatFresh(rec, Date.now()) });
+				hostProbeFailures = verdict.failures;
+				if (answer?.ok) hostChannelBroken = undefined;
+				if (verdict.channelBroken && !hostChannelBroken) {
+					// An answer that is an error is the process saying what is wrong (EMFILE, say): show that.
+					const said = answer && !answer.ok && answer.error ? `answers only with an error (${answer.error})` : "does not answer";
+					hostChannelBroken = `pid ${rec.pid} is running (its heartbeat is fresh) but its control socket ${said}; see ${homeRel(path.join(dir, HOST_LOG))}`;
+					log.write("warn", `pi-loops (pid ${rec.pid}) does not answer on its socket but is still ticking; leaving it running`);
+				}
+				if (verdict.evict) {
+					log.write("warn", `pi-loops (pid ${rec.pid}) stopped answering for three ticks; replacing it`);
+					// Waited on, and killed, only while that pid is still this host (its start time and entry).
+					await evictHost(dir, rec.pid, { alive: () => hostServiceAlive(rec) });
 				}
-				if (jobs.length > PANEL_RULE_LIMIT) lines.push(dim(`… ${jobs.length - PANEL_RULE_LIMIT} more`));
 			}
-			if (sources.length) {
-				const tools = sources.reduce((n, s) => n + s.tools, 0);
-				lines.push(head("MCP") + dim(`  servers ${sources.length} · tools ${tools} · notification hooks ${sources.length}`));
-				lines.push(sources.map((src) => (src.state === "connected" ? ok : src.state === "disabled" ? dim : warn)(`  ${src.name} ${src.state}${src.tools ? ` · ${src.tools} tool${src.tools === 1 ? "" : "s"}` : ""}`)).join(""));
+			const out = await ensureHost({ dir, packageDir: PACKAGE_DIR, piPackage: piPackageDir(), startedBy: `the pi window pid ${process.pid}`, automation: automationCounts(), auto: config.hostAuto, stopped: readUiPrefs(dir).host === "stopped", asked, myVersion: PI_LOOPS_VERSION, myPiVersion: PI_VERSION, wait });
+			const before = hostProblemText();
+			// The spawn log's reason in both branches: the attempt's own error and the backoff's are the
+			// same failure, and wording it twice warned twice.
+			const startError = () => readSpawnLog(dir).lastError ?? out.error ?? `pi-loops did not start; see ${homeRel(path.join(dir, HOST_LOG))}`;
+			// Started without waiting (a quitting window): whether it came up is the next window's to see.
+			if (out.action.kind === "spawn" && out.pid && out.up === undefined && !out.error) log.info(`starting pi-loops (pid ${out.pid}); not waiting for it`);
+			else if (out.action.kind === "spawn") {
+				hostState = out.up ? undefined : { kind: "start-failed", detail: startError() };
+				if (out.up) log.info(`started pi-loops (pid ${out.pid})`);
+			} else if (out.action.kind === "upgrade") log.info("asked pi-loops to make way for this version");
+			else if (out.action.reason === "running" || out.action.reason === "nothing to run" || out.action.reason.startsWith("a newer pi-loops")) hostState = undefined;
+			else if (out.action.reason.startsWith("backing off")) hostState = { kind: "start-failed", detail: startError() };
+			else if (out.action.reason.startsWith("paused:")) hostState = { kind: "crash-paused", detail: out.action.reason.slice("paused: ".length) };
+			if (hostChannelBroken && liveHostRecord()) hostState = { kind: "channel-broken", detail: hostChannelBroken };
+			const now = hostProblemText();
+			// A crash-pause is said by the pause line below, in the same words: once, not twice.
+			if (now && now !== before && hostState?.kind !== "start-failed" && hostState?.kind !== "crash-paused" && lastCtx?.hasUI) lastCtx.ui.notify(`[cron] ${now}`, "warning");
+			// A pause is said once when it begins (another window stopped the host, a config edit), not per tick.
+			const pause = hostHasWork() ? hostPauseReason() : undefined;
+			if (pause && pause !== shownPause && lastCtx?.hasUI) lastCtx.ui.notify(`[cron] loops paused: ${pause}`, "warning");
+			if (pause !== shownPause) {
+				shownPause = pause;
+				refreshBadge();
 			}
-			const hookCount = hookRunner?.hooks.length ?? 0;
-			lines.push(head("Hooks") + dim(hookCount ? `  cli_hooks ${hookCount} rule${hookCount === 1 ? "" : "s"} (${[...new Set(hookRunner!.hooks.map((h) => h.event))].join(", ")})` : "  none"));
-			lines.push(head("Runtime") + dim("  dedup · cycle suppress · fire-once rules · inject-and-run"));
-			const text = new Text(lines.join("\n"), 0, 0);
-			return text;
-		});
+			// Whoever started or stopped it: another window, `pi-loops host stop`, a crash.
+			const livePid = liveHostRecord()?.pid;
+			if (now !== before || livePid !== shownHostPid) {
+				shownHostPid = livePid;
+				refreshBadge();
+			}
+			return out;
+		} finally {
+			hostTickRunning = false;
+		}
 	}
 
 	/**
-	 * The system line when an inject-and-run turn starts (or is queued behind the current one). The id
-	 * is a rule's trace for a trigger and a run id for a cron inject, which has no trace; the line
-	 * calls it a trace either way, because that is the word people have learned to look for.
+	 * Loops run in the host, so their cards come from the run log: on each tick, every run of this
+	 * project that finished since the last look. The carded ones (src/run-card.ts) are shown, at most
+	 * five, and the rest of a burst is one line; the panel lists the latest runs whatever they carded.
 	 */
-	function triggeredTurnLine(runId: string, idle: boolean): void {
-		if (!lastCtx?.hasUI) return;
-		lastCtx.ui.notify(idle ? `running triggered turn (trace ${runId.slice(0, 8)})` : `queued triggered turn (trace ${runId.slice(0, 8)}) after the current one`, "info");
+	let runsShownAfter = stamp();
+	function showFinishedRuns(): void {
+		const ctx = lastCtx;
+		if (!ctx?.hasUI) return;
+		const all = scheduler.store.listRuns(undefined, FRESH_RUNS_READ);
+		recentRuns = panelRuns(all, (cwd) => sameProject(cwd, session.cwd), PANEL_RUN_LIMIT);
+		const { fresh, cursor } = freshRuns(all, runsShownAfter);
+		if (!fresh.length) return;
+		runsShownAfter = cursor;
+		// The record's own cwd and name: a one-shot loop is removed from jobs.json by the time its
+		// record is read here, and its card is still this conversation's.
+		const jobs = new Map(scheduler.store.load().map((j) => [j.id, j]));
+		const label = (r: RunRecord) => jobs.get(r.jobId)?.name ?? r.jobName;
+		// Which conversation each card belongs to is src/run-card.ts: where a person asked, else where
+		// the loop was made.
+		const here = binding.here().sessionId ?? session.sessionId;
+		const placed = placeRunCards(runCardsHere(fresh, { sessionId: here, inProject: (cwd) => sameProject(cwd, session.cwd) }));
+		for (const record of placed.cards) showRunCard(ctx, label(record), record);
+		if (placed.more) ctx.ui.notify(burstLine(placed), placed.failed ? "warning" : "info");
 	}
 
 	/**
 	 * A corrupt or truncated store must not take the session down with it. Both of these read the
-	 * stores, and both are reached from the tick (`onLeadership` → `refreshBadge`) which runs as
+	 * stores, and both are reached from the tick (`onTick` → `refreshBadge`) which runs as
 	 * `void this.tick()` — pi installs no `unhandledRejection` handler, so a throw here kills pi.
 	 */
 	function refreshBadge(): void {
@@ -578,23 +1029,28 @@ export default function piLoops(pi: ExtensionAPI) {
 	 * The same state the TUI panel draws, written into the session as a `pi_loops_snapshot` entry so
 	 * a front end that is not a terminal can read it. Everything here lives in this process — which
 	 * MCP servers actually connected, what they exposed, which tools are active, whether this pi
-	 * owns the clock — and none of it is in the store files a reader could open instead.
+	 * the host runs — and none of it is in the store files a reader could open instead.
 	 */
 	function snapshotData(): Record<string, unknown> {
 		const rules = triggers.store.load().filter((r) => sameProject(r.cwd, session.cwd));
 		const jobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd));
-		const poll = triggers.lastPoll;
+		const poll = lastPoll();
 		return {
 			version: PI_LOOPS_VERSION,
 			cwd: session.cwd,
 			host: os.hostname(),
 			scheduler: {
 				running: schedulerStarted,
-				leader: schedulerStarted && scheduler.isLeader,
-				runs: scheduler.runningCount,
-				checks: triggers.runningList().filter((r) => r.sourceLabel === "local:dynamic").length,
+				host: (() => {
+					const rec = liveHostRecord();
+					return rec ? { running: true, pid: rec.pid } : { running: false };
+				})(),
+				runs: machineRuns().filter((r) => !r.check).length,
+				checks: machineRuns().filter((r) => r.check).length,
 				deduped: triggers.dedupedCount,
 			},
+			// Why nothing runs, when that is so: the browser panel shows it in place of next runs.
+			paused: hostHasWork() ? hostPauseReason() : undefined,
 			counts: { jobs: jobs.length, jobsEnabled: jobs.filter((j) => j.enabled).length, rules: rules.length, rulesEnabled: rules.filter((r) => r.enabled).length, inboxNew: scheduler.inbox.newCount() },
 			mcp: mcpSources.map((src) => ({
 				name: src.config.name,
@@ -622,7 +1078,7 @@ export default function piLoops(pi: ExtensionAPI) {
 
 	/** Write the snapshot when `src/snapshot.ts` says this change deserves a permanent entry. */
 	function emitSnapshot(force = false): void {
-		if (!lastCtx) return;
+		if (!mayAppend()) return;
 		try {
 			const data = snapshotData();
 			const fingerprint = snapshotFingerprint(data);
@@ -638,6 +1094,16 @@ export default function piLoops(pi: ExtensionAPI) {
 		}
 	}
 
+	/** A store that cannot be read counts as empty where a count only decides what to say or start, and says so once. */
+	function loadOrNone<T>(read: () => T[]): T[] {
+		try {
+			return read();
+		} catch (err: any) {
+			storeReadFailed(err);
+			return [];
+		}
+	}
+
 	let storeErrorShown: string | undefined;
 	function storeReadFailed(err: any): void {
 		const message = err?.message ?? String(err);
@@ -660,45 +1126,33 @@ export default function piLoops(pi: ExtensionAPI) {
 		// going quiet.
 		const failing = failingSummary(scheduler.store.load());
 		if (failing) parts.push(failing);
-		const running = [...scheduler.runningLabels(), ...triggers.runningList().map((r) => (r.sourceLabel === "local:dynamic" ? "trigger-check" : r.sourceLabel))];
+		const running = machineRuns().map((r) => r.label);
 		if (running.length) parts.push(`running: ${running.join(", ")}`);
+		// What waits for this conversation and pi does not have yet (a prompt behind a busy turn, after
+		// Esc): the one place it shows without a command. `/cron queue` lists and cancels it.
+		const here = binding.here().sessionId;
+		const queued = here ? requests.list(here).filter((r) => r.kind === "input" && !executor.handedOver.has(r.id)).length : 0;
+		if (queued) parts.push(`queued ${queued}`);
 		const attention = mcpSources.filter((s) => s.status.state === "disconnected" || s.status.state === "auth_failed").length;
 		if (attention) parts.push(`mcp: ${attention} source${attention === 1 ? "" : "s"} down`);
-		if (schedulerStarted && !scheduler.isLeader) parts.push("loops standby");
+		const paused = hostPauseReason();
+		if (paused && hostHasWork()) parts.push(`loops paused: ${paused}`);
+		else if (hostState?.kind === "channel-broken") parts.push(HOST_STATE_BADGE["channel-broken"]);
 		lastCtx.ui.setStatus(STATUS_KEY, parts.length ? parts.join(" · ") : undefined);
 	}
 
-	/** A run that fell back or retried looks identical to a clean one unless it is said out loud. */
-	function runNotes(record: { warning?: string; retries?: number; compactions?: number }): string[] {
-		const notes: string[] = [];
-		if (record.warning) notes.push(`! ${previewRedacted(record.warning, 200)}`);
-		if (record.retries) notes.push(`  ${record.retries} provider retry/retries`);
-		if (record.compactions) notes.push(`  ${record.compactions} context compaction(s)`);
-		return notes;
-	}
-
-	function showRunCard(ctx: ExtensionContext, job: LoopJob, record: RunRecord, findings: string[]): void {
-		const label = job.name ?? job.id;
-		const secs = Math.max(0, Math.round((Date.parse(record.finishedAt) - Date.parse(record.startedAt)) / 1000));
-		const cost = record.usage?.cost ? ` · $${record.usage.cost.toFixed(3)}` : "";
-		const title = record.ok
-			? `cron ${label} · ${secs}s${cost} · ${findings.length} finding${findings.length === 1 ? "" : "s"}${record.checker?.ok ? " (verified)" : ""}${record.stateUpdated ? " · state updated" : ""}`
-			: `cron ${label} FAILED · ${secs}s`;
-		const lines: string[] = [];
-		if (!record.ok) lines.push(`! ${record.error ?? "unknown error"}`);
-		lines.push(...runNotes(record as any));
-		if (record.summary) lines.push(...record.summary.split("\n").slice(0, 6));
-		for (const f of findings) lines.push(`• ${previewRedacted(f, 160)}`);
-		if (record.droppedFindings) lines.push(`(${record.droppedFindings} more findings dropped: per-run cap)`);
-		if (record.checker) {
-			const checker = record.checker;
-			if (!checker.ok) lines.push(`checker FAILED (${checker.error}); findings entered unverified`);
-			else lines.push(`checker kept ${checker.kept}, dropped ${checker.dropped.length}${checker.unreviewed ? `, ${checker.unreviewed} unreviewed` : ""}${checker.cost ? ` · $${checker.cost.toFixed(3)}` : ""} — /cron trace ${label} 1 checker`);
-			for (const drop of checker.dropped) lines.push(`  ✗ ${previewRedacted(drop.text, 100)} — ${previewRedacted(drop.reason, 100)}`);
-		}
-		lines.push(`/cron trace ${label} · /inbox`);
-		if (ctx.mode === "tui") show(ctx, title, lines);
-		else ctx.ui.notify([title, ...lines].join("\n"), record.ok ? "info" : "warning");
+	/**
+	 * A finished run in this conversation (src/run-card.ts): a loop's first three runs and every failed
+	 * run are one compact card; every other run is a line in the panel only. A failure is also said as
+	 * a warning, so it is seen when the card has scrolled by.
+	 */
+	function showRunCard(ctx: ExtensionContext, name: string | undefined, record: RunRecord): void {
+		// A window that does not hold the conversation writes nothing into it (see mayAppend).
+		const how = runCardDelivery(record, { mode: ctx.mode, mayAppend: mayAppend() });
+		const line = runLine(record, name);
+		const lines = runCardLines(record);
+		if (how.save) pi.appendEntry<ViewData>(VIEW_ENTRY, { title: line, lines });
+		if (how.notify) ctx.ui.notify([line, ...lines].join("\n"), how.notify);
 	}
 
 	/* ------------------------------------------------------------ views */
@@ -712,29 +1166,31 @@ export default function piLoops(pi: ExtensionAPI) {
 	});
 
 	function show(ctx: ExtensionContext, title: string, lines: string[]): void {
-		if (ctx.mode === "tui") pi.appendEntry<ViewData>(VIEW_ENTRY, { title, lines });
+		// A window that does not hold the conversation writes nothing into it (see mayAppend).
+		if (ctx.mode === "tui" && mayAppend()) pi.appendEntry<ViewData>(VIEW_ENTRY, { title, lines });
 		else if (ctx.hasUI) ctx.ui.notify([title, ...lines].join("\n"), "info");
 		else console.log([title, ...lines].join("\n"));
 	}
 
 	const short = (s: string, n: number) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
-	const homeRel = (p: string) => {
-		const home = process.env.HOME ?? "";
-		return home && p.startsWith(home) ? `~${p.slice(home.length)}` : p;
-	};
+	const homeRel = (p: string) => projectLabel(p, process.env.HOME ?? "");
 
-	function jobLines(jobs: LoopJob[]): string[] {
+	function jobLines(jobs: LoopJob[], showCwd = false): string[] {
 		// Read once for the whole listing: the run log and the inbox are each one file, and a
 		// project with a dozen loops would otherwise parse them a dozen times per `/cron`. The shape
 		// of the lines is src/job-lines.ts, where a test can see a marker go.
 		const runs = jobs.some((j) => j.stateful) ? scheduler.store.allRuns() : [];
 		const inbox = jobs.some((j) => j.stateful) ? scheduler.inbox.list() : [];
-		return cronJobLines(jobs, { runs, inbox, sessionId: session.sessionId, now: Date.now(), home: process.env.HOME ?? "", cwdExists: (cwd) => fs.existsSync(cwd) });
+		return cronJobLines(jobs, { runs, inbox, requests: (sessionId) => requests.list(sessionId), view: scheduler.ownerView(), now: Date.now(), home: process.env.HOME ?? "", cwdExists: (cwd) => fs.existsSync(cwd), showCwd });
 	}
 
 	/* --------------------------------------------------------- creation */
 
-	const createJob = (input: CreateJobInput, scope?: JobScope) => createLoopJob(toolHost, input, scope);
+	/**
+	 * A slash command's job: the person typed it, so it gets this chat's built-ins even when a scheduled
+	 * turn happens to be running (pi runs extension commands while it streams). The tools' host caps.
+	 */
+	const createJob = (input: CreateJobInput, scope?: JobScope) => createLoopJob({ ...toolHost, session: () => session }, input, scope);
 
 	/**
 	 * The `cron_control_plane` audit: every add / enable / disable / remove, from a slash
@@ -745,6 +1201,8 @@ export default function piLoops(pi: ExtensionAPI) {
 		const next = after?.enabled ? computeNext({ schedule: after.schedule, createdAt: Date.parse(after.createdAt), lastFiredAt: after.lastFiredAt ? Date.parse(after.lastFiredAt) : undefined }, Date.now()) : undefined;
 		// pi.appendEntry returns no id; mint one so tool results can point at the entry.
 		const auditEntryId = newId("audit");
+		// The scheduler's own retirements happen on every window's tick: a viewer leaves them to the holder.
+		if (actor === "scheduler" && !mayAppend()) return auditEntryId;
 		pi.appendEntry("cron_control_plane", {
 			audit_entry_id: auditEntryId,
 			op,
@@ -771,25 +1229,25 @@ export default function piLoops(pi: ExtensionAPI) {
 		"    --verify: maker/checker — a second adversarial sub-agent reviews findings before they enter /inbox (--checker-model <provider/id> to use another model)",
 		"    more flags: --name <n> --cwd <dir> --model <provider/id> --thinking <lvl> --tools a,b --timeout 20m --catchup|--no-catchup (default: loops catch up a missed tick, plain jobs do not)",
 		"/cron enable|disable|remove <n|id|name>      /cron run <n|id|name>   fire now",
-		"/cron set <n|id|name> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-] [--name <n>|-]   change what a job runs with (- = use the session's current)",
+		"/cron set <n|id|name> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-] [--name <n>|-] [--tools a,b|-]   change what a job runs with (- = clear it: a loop then uses pi's default, a plain job its conversation's; --tools - uncaps a plain job's turns)",
 		'    also [--prompt "<text>"] [--schedule "<expr>"]: reword a loop or move it to another hour in place — the job keeps its id, and a stateful loop keeps its notes',
+		"/cron queue [cancel <n|id>|clear]   what waits to run in this conversation while the agent is busy (a plain job's prompt, a claim, a rule's result), numbered; cancel one by its number or id, or clear them all",
 		"/cron state <n|id|name>        the loop's notes (state spine)",
 		"/cron runs [n|id|name]         recent runs          /cron trace [n|id|name] [k] [checker]   k-th latest run's transcript (maker, or its checker)",
-		"/cron scheduler                who owns the timer     /cron panel on|off   side panel above the editor",
-		"/cron snapshot                 what only this process knows — connected MCP servers and their tools, who owns the clock — written into the session, for a front end that is not a terminal",
+		"/cron scheduler                this window, its conversation, pi-loops     /cron panel on|off   side panel above the editor",
+		"/cron snapshot                 what only this process knows — connected MCP servers and their tools, whether pi-loops runs — written into the session, for a front end that is not a terminal",
 		"/cron gc                       remove plain jobs whose session was deleted (they are parked as disabled first)",
 		"/cron cost [today|7d|all]      what automation has cost, by job, and today's budget if one is set",
 		"/cron clear <n|id|name>        clear a stuck `running` marker left by a process that is gone",
 		"/cron remove <ref> [--purge]   remove a job; its loop state is kept unless --purge",
 		"/cron disable --all            pause every job in this project (--all-projects for the machine); /cron enable --all resumes",
-		"/cron host [start|stop]        the headless host that keeps the clock after the last pi quits; start = hand off on quit even with [host] auto = false",
 		"/inbox                         triage findings from stateful jobs (/inbox help)",
 		`/session-export [path] [--exclude-triggers]      transcript + this project's cron jobs, trigger rules and loop state as one ${ARCHIVE_EXT} archive`,
 		"/session-import <path> [--activate-triggers=off|ask|on] [--cwd <dir>] [--resume]   restore it here (automation stays off unless activated)",
 	];
 
 	const cronCompletions = (prefix: string) => {
-		const subs = ["add", "list", "all", "enable", "disable", "remove", "set", "clear", "cost", "gc", "host", "run", "state", "runs", "trace", "scheduler", "panel", "snapshot", "help"];
+		const subs = ["add", "list", "all", "enable", "disable", "remove", "set", "queue", "clear", "cost", "gc", "run", "state", "runs", "trace", "scheduler", "panel", "snapshot", "help"];
 		const items = subs.filter((s) => s.startsWith(prefix)).map((s) => ({ value: s, label: s }));
 		return items.length ? items : null;
 	};
@@ -807,7 +1265,7 @@ export default function piLoops(pi: ExtensionAPI) {
 			// Every subcommand, by name only: with five more of them the argument spellings no longer fit
 			// on a line a notification can show, and `/cron help` has them all. A name left out of here
 			// is a subcommand nobody finds, which is the worse of the two.
-			const CRON_USAGE = "[list|all|add|set|run|enable|disable|remove|state|runs|trace|cost|clear|gc|host|scheduler|panel|snapshot|help] — /cron help for the arguments";
+			const CRON_USAGE = "[list|all|add|set|run|queue|enable|disable|remove|state|runs|trace|cost|clear|gc|scheduler|panel|snapshot|help] — /cron help for the arguments";
 			try {
 				switch (sub) {
 					case "":
@@ -817,33 +1275,71 @@ export default function piLoops(pi: ExtensionAPI) {
 					case "all": {
 						const all = jobs();
 						if (!all.length) {
-							show(ctx, "Cron jobs: none", ['/cron add [--stateful] "0 9 * * *" <prompt>   (/cron help for more)']);
+							show(ctx, "Loops: none", ['/cron add [--stateful] "0 9 * * *" <prompt>   (/cron help for more)']);
 							return;
 						}
 						if (sub === "all") {
-							show(ctx, `Cron jobs (this machine, ${all.length}, times ${localOffset(Date.now())}):`, jobLines(all));
+							show(ctx, `Loops (this machine, ${all.length}, times ${localOffset(Date.now())}):`, jobLines(all, true));
 							return;
 						}
 						const here = all.filter((j) => sameProject(j.cwd, session.cwd));
 						const elsewhere = all.length - here.length;
 						const lines = here.length ? jobLines(here) : ["(none in this project)"];
-						if (elsewhere) lines.push(`+ ${elsewhere} job${elsewhere === 1 ? "" : "s"} in other projects — /cron all`);
-						show(ctx, `Cron jobs (${homeRel(session.cwd)}, ${here.length}, times ${localOffset(Date.now())}):`, lines);
+						if (elsewhere) lines.push(`+ ${plural(elsewhere, "loop")} in other projects — /cron all`);
+						show(ctx, `Loops (${homeRel(session.cwd)}, ${here.length}, times ${localOffset(Date.now())}):`, lines);
 						return;
 					}
 					case "help":
 						show(ctx, "/cron", CRON_HELP);
 						return;
+					case "queue": {
+						// What waits for this conversation, and the way to take it out: the file a plain job's
+						// prompt, a claim or a rule's result sits in while pi is busy, and runs from once pi is
+						// idle (Esc stops the turn, not the queue). The listing and the pick are src/job-lines.ts.
+						const sessionId = binding.here().sessionId;
+						if (!sessionId) {
+							ctx.ui.notify("no conversation here (--no-session): nothing can be queued for it", "warning");
+							return;
+						}
+						const { sub: action, rest: ref } = splitCommand(rest);
+						const rows = requests.list(sessionId);
+						const names = new Map(jobs().map((j) => [j.id, j.name ?? j.id] as const));
+						if (action === "" || action === "list") {
+							show(ctx, `Queued for this conversation (${rows.filter((r) => r.kind === "input").length}):`, [...queueLines(rows, { now: Date.now(), jobName: (id) => names.get(id), inFlight: executor.handedOver }), "/cron queue cancel <n|id>   /cron queue clear"]);
+							return;
+						}
+						if (action !== "cancel" && action !== "clear") {
+							ctx.ui.notify("usage: /cron queue [cancel <n|id>|clear]", "warning");
+							return;
+						}
+						const targets = action === "clear" ? rows.filter((r) => r.kind === "input") : [pickQueued(rows, ref)].filter((r): r is SessionRequest => r !== undefined);
+						if (!targets.length) {
+							ctx.ui.notify(action === "clear" ? "nothing is queued for this conversation" : `nothing queued matches '${ref}'; /cron queue lists what is`, "warning");
+							return;
+						}
+						// A cancel is a row too (src/engine.ts cancelRow): the holder removes the queued row and
+						// audits it, whoever holds the conversation; one pi already has is left to pi, where Esc stops it.
+						for (const row of targets) requests.append(cancelRow(sessionId, { id: row.id }, "window", createdBy()));
+						const result = await drainRequests();
+						const gone = targets.filter((row) => result?.removed.includes(row.id)).length;
+						ctx.ui.notify(gone === targets.length ? `cancelled ${gone} queued item${gone === 1 ? "" : "s"}` : `cancelled ${gone} of ${targets.length}; the rest are handed to pi already (Esc stops the turn) or are for the window that has this conversation to cancel`, "info");
+						refreshBadge();
+						return;
+					}
 					case "panel": {
 						const on = rest.trim() === "on" ? true : rest.trim() === "off" ? false : !panelOn;
 						setPanelEnabled(on);
-						ctx.ui.notify(`panel ${on ? "on" : "off"} (Triggers / Inbox / Cron / MCP widget above the editor)`, "info");
+						ctx.ui.notify(`panel ${on ? "on" : "off"} (Rules / Loops / Runs / MCP above the editor)`, "info");
 						return;
 					}
 					case "snapshot": {
 						// The panel's contents as a `pi_loops_snapshot` session entry: which MCP servers
-						// connected, what they exposed, the active tools, who owns the clock. A front end
+						// connected, what they exposed, the active tools, whether the host runs. A front end
 						// that is not a terminal (src/web.mjs) reads that instead of the widget.
+						if (!mayAppend()) {
+							ctx.ui.notify(binding.standingAside ? "this window shows an older copy of this conversation and writes nothing into it; /resume this session first" : `this conversation is also ${openWhere(binding.holderKindOf(binding.here().sessionId ?? ""))}, which writes its snapshot; this window writes nothing into it`, "info");
+							return;
+						}
 						emitSnapshot(true);
 						ctx.ui.notify("wrote a pi_loops_snapshot entry to the session", "info");
 						return;
@@ -866,9 +1362,19 @@ export default function piLoops(pi: ExtensionAPI) {
 						});
 						const next = computeNext({ schedule: job.schedule, createdAt: Date.parse(job.createdAt) }, Date.now());
 						cronControlAudit("add", "slash", undefined, job);
+						const dropped = toolsDropped(parsed.tools, job.tools);
 						show(ctx, `added cron job ${job.id}${job.name ? ` "${job.name}"` : ""}`, [
-							`  schedule: ${formatSchedule(job.schedule)}${next ? ` (next run ${formatLocal(next)})` : ""}`,
-							...(job.stateful ? [`  mode: stateful loop (findings go to /inbox${job.verify ? " after the checker" : ""})`] : ["  mode: inject-and-run (the result appears in this chat)"]),
+							...(dropped.length ? [`  dropped from --tools: ${dropped.join(", ")} (this chat does not have it)`] : []),
+							// A paused background process runs no loop: no next run is promised for a run that will not
+							// happen. This chat's own plain job runs here, paused or not.
+							`  schedule: ${formatSchedule(job.schedule)}${job.stateful && hostPauseReason() ? ` (paused: ${hostPauseReason()})` : next ? ` (next run ${formatLocal(next)})` : ""}`,
+							...(job.stateful
+								? [
+										`  mode: stateful loop (findings go to /inbox${job.verify ? " after the checker" : ""})`,
+										// It runs elsewhere: say what goes with it, and what stays with this window.
+										`  runs in the background with ${job.tools ? `the tools ${job.tools.join(", ")}` : job.builtinTools ? `this chat's built-in tools (${job.builtinTools.join(", ") || "none"})` : "pi's default tools"}${job.model ? ` on ${job.model}` : ""}${!projectNeedsTrust(job.cwd) ? "" : isExactlyTrusted(getAgentDir(), job.cwd) ? ", and this project's own settings and servers" : "; this project's own settings and servers only once /trust saves trust for it"}; not this window's -e extensions or flags`,
+									]
+								: ["  mode: inject-and-run (the result appears in this chat; while this chat is closed it still runs, in the background, and each run is a model turn)"]),
 							`  action: ${previewRedacted(job.prompt, 120)}`,
 						]);
 						refreshBadge();
@@ -877,11 +1383,15 @@ export default function piLoops(pi: ExtensionAPI) {
 					case "run": {
 						const job = pick(rest);
 						if (!job) return;
-						if (job.stateful && !schedulerStarted) {
-							ctx.ui.notify("the scheduler is not running in this session (non-interactive mode)", "warning");
-							return;
-						}
-						const ran = await scheduler.runNow(job.id);
+						// A loop runs in the host; a plain job only in the window holding its conversation.
+						let ran: true | string;
+						if (job.stateful) {
+							if (!liveHostRecord()) await hostTick(false);
+							// Who asked, so the run's card comes back here whatever its run number (src/run-card.ts).
+							const asker = binding.here().sessionId ?? session.sessionId;
+							const answer = await askHost(dir, { op: "run", jobId: job.id, ...(asker ? { requestedBy: { sessionId: asker } } : {}) });
+							ran = answer?.ok ? (answer.ran ?? true) : `did not start: pi-loops is not running${hostPauseReason() ? ` (${hostPauseReason()})` : hostState ? ` (${hostProblemText()})` : ""}; loops do not run in this window`;
+						} else ran = await scheduler.runNow(job.id);
 						// A refusal comes back as the reason, phrased to follow the job's name — the shape
 						// this line has always had ("nightly is already running").
 						ctx.ui.notify(ran === true ? `running ${job.name ?? job.id} in the background…` : `${job.name ?? job.id} ${ran}`, ran === true ? "info" : "warning");
@@ -901,19 +1411,25 @@ export default function piLoops(pi: ExtensionAPI) {
 							for (const j of targets) {
 								const after = await scheduler.store.update(j.id, (x) => {
 									x.enabled = enable;
-									if (enable) x.lastError = undefined;
+									if (enable) {
+										x.lastError = undefined;
+										x.interruptions = undefined;
+									}
 								});
 								cronControlAudit(enable ? "enable" : "disable", "slash", j, after ?? j);
 							}
 							refreshBadge();
-							ctx.ui.notify(`${enable ? "enabled" : "disabled"} ${targets.length} job(s)${everywhere ? " on this machine" : " in this project"}`, "info");
+							ctx.ui.notify(`${enable ? "enabled" : "disabled"} ${plural(targets.length, "loop")}${everywhere ? " on this machine" : " in this project"}`, "info");
 							return;
 						}
 						const job = pick(rest);
 						if (!job) return;
 						const after = await scheduler.store.update(job.id, (j) => {
 							j.enabled = enable;
-							if (enable) j.lastError = undefined;
+							if (enable) {
+								j.lastError = undefined;
+								j.interruptions = undefined;
+							}
 						});
 						cronControlAudit(enable ? "enable" : "disable", "slash", job, after ?? job);
 						ctx.ui.notify(`${enable ? "enabled" : "disabled"} cron job ${job.id}${job.name ? ` "${job.name}"` : ""}`, "info");
@@ -949,29 +1465,8 @@ export default function piLoops(pi: ExtensionAPI) {
 						return;
 					}
 					case "host": {
-						// While a pi is open it owns the clock; the host only ever runs when nobody is around.
-						const action = rest.trim();
-						if (action === "stop") {
-							handOffOnQuit = false;
-							const pid = stopHost(dir);
-							ctx.ui.notify(pid ? `stopped the background host (pid ${pid}); none will be started when this pi quits` : "no background host is running; none will be started when this pi quits", "info");
-							return;
-						}
-						if (action === "start") {
-							handOffOnQuit = true;
-							ctx.ui.notify("a background host will keep the clock when this pi quits (this pi owns it while open)", "info");
-							return;
-						}
-						const live = liveHost(dir);
-						const answer = live ? await askHost(dir, { op: "status" }) : undefined;
-						const hostSnapshot = answer?.ok ? answer.snapshot : undefined;
-						show(ctx, "Background host", [
-							live ? `  running: pid ${live.pid} since ${formatLocal(Date.parse(live.startedAt))} — unexpected while a pi is open; it exits on its next tick` : "  not running (it runs only while no pi is open)",
-							...(hostSnapshot ? renderHostSnapshot(hostSnapshot) : []),
-							`  hand-off on quit: ${handsOffOnQuit() ? "on" : "off"}${handOffOnQuit === undefined ? ` ([host] auto = ${config.hostAuto}; /cron host start|stop overrides it for this pi)` : handOffOnQuit ? " (/cron host start)" : " (/cron host stop)"}`,
-							`  log: ${homeRel(path.join(dir, HOST_LOG))}`,
-							"  /cron host start | stop",
-						]);
+						// 0.22.8's spelling of /pi-loops start | stop | status.
+						await backgroundCommand(rest.trim() || "status", ctx);
 						return;
 					}
 					case "clear": {
@@ -984,11 +1479,11 @@ export default function piLoops(pi: ExtensionAPI) {
 							return;
 						}
 						const marker = job.running;
-						const ok = await ctx.ui.confirm("Clear the running marker?", `${job.name ?? job.id} is marked as running since ${formatLocal(Date.parse(marker.startedAt))} by pid ${marker.pid}${marker.host && marker.host !== os.hostname() ? ` on ${marker.host}` : ""}.\n\nClear it only if that run is really gone — if it is still going, its result will still be written.`);
+						const ok = await ctx.ui.confirm("Clear the running marker?", `${job.name ?? job.id} is marked as running since ${formatLocal(Date.parse(marker.startedAt))}${marker.host && marker.host !== os.hostname() ? ` on ${marker.host}` : ""}.\n\nClear it only if that run is really gone — if it is still going, its result will still be written.`);
 						if (!ok) return;
 						const updated = await scheduler.store.update(job.id, (j) => {
 							j.running = undefined;
-							j.lastError = `running marker cleared by hand (was ${marker.runId.slice(0, 12)}, pid ${marker.pid})`;
+							j.lastError = `running marker cleared by hand (was ${marker.runId.slice(0, 12)})`;
 						});
 						refreshBadge();
 						ctx.ui.notify(updated ? `cleared the running marker on ${updated.name ?? updated.id}; it can fire again` : "job vanished", "info");
@@ -1020,12 +1515,12 @@ export default function piLoops(pi: ExtensionAPI) {
 						const runsInLog = scheduler.store.allRuns();
 						const inboxAll = scheduler.inbox.list();
 						const worthOf = (id: string) => signalSummary(loopSignal(id, runsInLog, inboxAll, since));
-						show(ctx, `Automation cost ${label}: $${spend.total.toFixed(3)} over ${spend.runs} run(s)`, [
+						show(ctx, `Automation cost ${label}: $${spend.total.toFixed(3)} over ${plural(spend.runs, "run")}`, [
 							...(spend.rotated > 0 ? [`  including $${spend.rotated.toFixed(3)} from runs the log has already rotated away`] : []),
 							...(budget.cap > 0 ? [`  today's budget: $${budget.spent.toFixed(2)} of $${budget.cap.toFixed(2)}${budget.over ? " — dispatching is paused" : ""}`] : ["  no budget cap set ([limits] daily_budget_usd)"]),
 							...byJob.slice(0, 12).map(([id, e]) => {
 								const worth = worthOf(id);
-								return `  $${e.cost.toFixed(3)}  ${e.runs} run(s)  ${e.name ?? id}${worth ? `  —  ${worth}` : ""}`;
+								return `  $${e.cost.toFixed(3)}  ${plural(e.runs, "run")}  ${e.name ?? id}${worth ? `  —  ${worth}` : ""}`;
 							}),
 							...(byJob.length > 12 ? [`  (+${byJob.length - 12} more)`] : []),
 							...(spend.runs ? [] : ["  nothing has run in this window"]),
@@ -1042,11 +1537,11 @@ export default function piLoops(pi: ExtensionAPI) {
 						const orphans = scheduler.store.orphanStates();
 						const purge = /(^|\s)--purge(\s|$)/.test(rest);
 						if (purge && orphans.length) for (const o of orphans) scheduler.store.purgeState(o.id);
-						show(ctx, `removed ${removed.length} job(s) whose session no longer exists${all ? " (every project)" : " in this project"}`, [
-							...removed.map((j) => `  - ${j.id}${j.name ? ` "${j.name}"` : ""}  (session ${(j.sessionId ?? "?").slice(0, 8)})`),
-							...(orphans.length && !purge ? [`  ${orphans.length} job(s) that are gone left loop state or transcripts behind (${Math.round(orphans.reduce((n, o) => n + o.bytes, 0) / 1024)} KB) — /cron gc --purge deletes them`] : []),
-							...(all ? [] : ["  --all also collects other projects' dead jobs"]),
-							...(purge && orphans.length ? [`  deleted the loop state and transcripts of ${orphans.length} job(s) that are gone`] : []),
+						show(ctx, `removed ${plural(removed.length, "plain job")} whose session no longer exists${all ? " (every project)" : " in this project"}`, [
+							...removed.map((j) => `  - ${j.id}${j.name ? ` "${j.name}"` : ""}  (session ${shortSessionId(j.sessionId ?? "?")})`),
+							...(orphans.length && !purge ? [`  ${plural(orphans.length, "loop")} that ${orphans.length === 1 ? "is" : "are"} gone left loop state or transcripts behind (${Math.round(orphans.reduce((n, o) => n + o.bytes, 0) / 1024)} KB) — /cron gc --purge deletes them`] : []),
+							...(all ? [] : ["  --all also collects other projects' dead plain jobs"]),
+							...(purge && orphans.length ? [`  deleted the loop state and transcripts of ${plural(orphans.length, "loop")} that ${orphans.length === 1 ? "is" : "are"} gone`] : []),
 						]);
 						refreshBadge();
 						return;
@@ -1071,6 +1566,10 @@ export default function piLoops(pi: ExtensionAPI) {
 						// that started a run in between has already set `running` on the copy it hands back.
 						const updated = await scheduler.store.update(job.id, (j) => Object.assign(j, applied.patch));
 						if (!updated) return;
+						// The row the page writes for a schedule change, in the shared audit; nothing for an edit
+						// that left the schedule alone (src/job-tune.ts scheduleAudit decides).
+						const setRow = scheduleAudit(job, updated, { sourceLabel: "slash" });
+						if (setRow) triggers.store.appendAudit({ ...setRow, traceId: newTraceId() });
 						for (const line of applied.changed) log.info(`cron ${updated.id}: ${line}`);
 						// A typo in a cron expression is invisible until it fails to fire, so the next run is
 						// part of the confirmation.
@@ -1089,6 +1588,7 @@ export default function piLoops(pi: ExtensionAPI) {
 							`  model: ${updated.model ?? "(the running session's current model)"}`,
 							`  thinking: ${updated.thinking ?? "(the running session's current level)"}`,
 							`  timeout: ${updated.timeoutMs ? `${Math.round(updated.timeoutMs / 1000)}s` : "default"}`,
+							`  tools: ${updated.tools?.length ? updated.tools.join(", ") : updated.stateful ? "(this chat's built-in tools)" : "(none: its turns run uncapped, as your own do)"}`,
 						]);
 						return;
 					}
@@ -1118,7 +1618,7 @@ export default function piLoops(pi: ExtensionAPI) {
 								const who = job ? "" : `${r.jobName ?? r.jobId} `;
 								const cost = r.usage?.cost ? ` $${r.usage.cost.toFixed(3)}` : "";
 								const chk = r.checker ? (r.checker.ok ? `, checker kept ${r.checker.kept}/${r.checker.kept + r.checker.dropped.length + r.checker.unreviewed}` : ", checker FAILED") : "";
-								const tail = r.ok ? `${r.findings} finding${r.findings === 1 ? "" : "s"}${chk}${r.stateUpdated ? ", state updated" : ""}` : `FAILED: ${previewRedacted(r.error ?? "?", 80)}`;
+								const tail = r.ok ? `${r.findings} finding${r.findings === 1 ? "" : "s"}${chk}${r.stateUpdated ? ", state updated" : ""}` : r.stoppedBy === "person" ? `stopped by you ${r.stoppedFrom === "page" ? "from the page" : "from a terminal"}` : r.aborted ? "stopped" : `FAILED: ${previewRedacted(r.error ?? "?", 80)}`;
 								return `${String(i + 1).padStart(2)}. ${formatLocal(Date.parse(r.startedAt))} ${who}${secs}s${cost} · ${tail}${r.sessionFile ? "" : " (no transcript)"}`;
 							}),
 							job ? `transcript: /cron trace ${job.name ?? job.id} <k>` : "transcript: /cron trace <job> <k>",
@@ -1166,14 +1666,15 @@ export default function piLoops(pi: ExtensionAPI) {
 						return;
 					}
 					case "scheduler": {
-						const leader = scheduler.readLeader();
-						const me = process.pid;
+						const live = liveHostRecord();
+						const here = binding.here();
 						show(ctx, `Cron scheduler (pi-loops ${PI_LOOPS_VERSION} on pi ${PI_VERSION})`, [
-							`this process: pid ${me}, ${schedulerStarted ? (scheduler.isLeader ? "owns the timer" : "standby") : "not scheduling (non-interactive)"}, ${scheduler.runningCount} run(s) in flight${scheduler.runningCount ? ` (${scheduler.runningLabels().join(", ")})` : ""}`,
-							`timer owner: ${leader ? `pid ${leader.pid}@${leader.host}${(leader as any).kind === "host" ? " (background host)" : ""}, heartbeat ${formatLocal(Date.parse(leader.heartbeatAt))}` : "none"}`,
-							`background host: ${liveHost(dir) ? `pid ${liveHost(dir)!.pid} (exits on its next tick: a pi is open)` : "not running (runs only while no pi is open)"} · hand-off on quit: ${handsOffOnQuit() ? "on" : "off"}`,
+							`this window: pid ${process.pid}, ${schedulerStarted ? "firing the plain jobs of its conversation" : "not scheduling (non-interactive)"}${here.sessionId ? ` · conversation ${shortSessionId(here.sessionId)} ${here.holds ? "runs here" : binding.viewerOf !== undefined ? "open in another window" : binding.standingAside ? "does not run here: this window's copy is older than the file, /resume it" : "does not run here"}` : ""}`,
+							`pi-loops: ${live ? `pid ${live.pid}, version ${live.version}, since ${formatLocal(Date.parse(live.startedAt))} (runs every loop and check in the background)` : `not running${hostPauseReason() ? ` — ${hostPauseReason()}` : hostState ? ` — ${hostProblemText()}` : ""}`}`,
+							...machineRuns().filter((r) => r.inHost).map((r) => `  running: ${r.label} since ${formatLocal(Date.parse(r.startedAt))}`),
 							`store: ${homeRel(dir)}`,
-							`log: ${homeRel(log.file)}`,
+							// Loops run in the background, and its log is where their trouble is written.
+							`log: ${homeRel(path.join(dir, HOST_LOG))} (loops and checks) · ${homeRel(log.file)} (this window)`,
 							`inbox: ${scheduler.inbox.newCount()} new`,
 						]);
 						return;
@@ -1186,6 +1687,57 @@ export default function piLoops(pi: ExtensionAPI) {
 			}
 	};
 
+	/**
+	 * `/pi-loops start | stop | restart | status`: the process that runs loops and rule checks while no
+	 * pi is open, by the name a person knows it by. "host" is the code's word for it, not theirs.
+	 */
+	async function backgroundCommand(action: string, ctx: ExtensionCommandContext): Promise<void> {
+		if (action === "stop" || action === "restart") {
+			const live = liveHostRecord();
+			const said: string[] = [];
+			if (!live) writeUiPref(dir, "host", "stopped");
+			else if (action === "stop") await stopService(dir, live, (l) => said.push(l));
+			// Started only once the old process has gone: until then a start finds it and does nothing.
+			else {
+				ctx.ui.notify(RESTART_WAIT_LINE, "info");
+				if (!(await stopAndWait(dir, live, (l) => said.push(l), { reason: "restart" }))) {
+					ctx.ui.notify(`pi-loops has not exited after ${LEAVE_WAIT_MS / 1000} s, and it is marked stopped: /pi-loops start once it has gone (see ${homeRel(path.join(dir, HOST_LOG))})`, "warning");
+					refreshBadge();
+					return;
+				}
+			}
+			if (action === "stop") {
+				ctx.ui.notify(live ? `${said.join("; ")}; loops and checks are paused` : "pi-loops is not running; nothing starts it until /pi-loops start, pi-loops start or pi-loops opening the page", "info");
+				refreshBadge();
+				return;
+			}
+		}
+		if (action === "start" || action === "restart") {
+			// Asked by name: kept after the last window under `[host] auto = false`, until a stop.
+			writeUiPref(dir, "host", "started");
+			const out = await hostTick(false, true);
+			const live = liveHostRecord();
+			ctx.ui.notify(live ? "pi-loops is running in the background" : `pi-loops is not running: ${out?.error ?? (out?.action.kind === "none" ? out.action.reason : "it did not start")}`, live ? "info" : "warning");
+			refreshBadge();
+			return;
+		}
+		if (action !== "status") {
+			ctx.ui.notify("usage: /pi-loops start | stop | restart | status", "warning");
+			return;
+		}
+		const live = liveHostRecord();
+		const answer = live ? await askHost(dir, { op: "status" }) : undefined;
+		const snapshot = answer?.ok ? answer.snapshot : undefined;
+		// A snapshot that answered says the pid, the version and the start itself.
+		show(ctx, "pi-loops in the background", [
+			...(snapshot
+				? renderHostSnapshot(snapshot)
+				: [live ? `  running: pid ${live.pid}, pi-loops ${live.version}, since ${formatLocal(Date.parse(live.startedAt))} — not answering on its socket` : `  not running${hostPauseReason() ? ` — ${hostPauseReason()}` : hostState ? ` — ${hostProblemText()}` : " (it starts when there is work to run)"}`]),
+			`  log: ${homeRel(path.join(dir, HOST_LOG))}`,
+			"  /pi-loops start | stop | restart",
+		]);
+	}
+
 	pi.registerCommand("cron", {
 		description: 'Scheduled jobs: /cron add [--stateful] "<schedule>" <prompt> — /cron help',
 		getArgumentCompletions: cronCompletions,
@@ -1194,7 +1746,7 @@ export default function piLoops(pi: ExtensionAPI) {
 	pi.registerCommand("crontab", { description: "Alias of /cron", getArgumentCompletions: cronCompletions, handler: cronHandler });
 	pi.registerCommand("loop", { description: "Alias of /cron", getArgumentCompletions: cronCompletions, handler: cronHandler });
 
-	const INBOX_USAGE = "[list|all|claim <n>|dismiss <n> [reason]|clear|help] [--all]";
+	const INBOX_USAGE = "[list|all|claim <n>|dismiss <n> [reason]|open <n>|clear|help] [--all]";
 
 	const INBOX_HELP = [
 		"/inbox                list new findings of this project    /inbox --all   every project on this machine",
@@ -1202,37 +1754,39 @@ export default function piLoops(pi: ExtensionAPI) {
 		"/inbox claim <n|id>   mark claimed and hand it to the agent as a real turn",
 		"/inbox dismiss <n|id> [reason]   mark dismissed; a reason is shown to the loop's next run",
 		"/inbox clear [--all]  dismiss the ones listed",
+		"/inbox open <n|id>    start a new conversation from the run that filed it",
 	];
 
 	/** The project a finding came from, as `/cron` shows a job's: the directory name is enough to tell them apart. */
 	const projectOf = (cwd: string) => (cwd ? path.basename(cwd) || homeRel(cwd) : "—");
 
-	/** List lines: the full (≤500-char) finding, id prefix, project, source, when it arrived. */
+	/**
+	 * List lines: the finding as src/inbox-card.ts splits it (a decision's clauses under it), id
+	 * prefix, project, source, when it arrived. The numbers are positions in `entries`, which is what
+	 * `claim` and `dismiss` resolve a number against.
+	 */
 	function inboxLines(entries: InboxEntry[], numbered: boolean): string[] {
-		return entries.map((e, i) => {
+		const names = new Map(scheduler.store.load().map((j) => [j.id, j.name]));
+		const ctx = { here: session.sessionId, loopName: (id: string) => names.get(id) };
+		return entries.flatMap((e, i) => {
+			const card = inboxCard(e, ctx);
+			if (!card) return [];
 			// Stored as an instant (ISO, UTC) and shown in this machine's timezone, like every other
 			// time pi-loops puts on a screen. It used to be the stored string with the `Z` sliced
 			// off — a UTC time wearing the shape of a local one, eight hours from the `next` on the
 			// `/cron` line above it, with nothing on either to say which was which.
 			const when = formatLocal(Date.parse(e.created_at));
-			// ⚑ is a checkpoint — a decision the finding asks of a person; ✓ is the checker's mark.
-			const mark = `${e.kind === "checkpoint" ? "⚑ " : ""}${e.verified ? "✓ " : ""}`;
 			// The project comes first of the three: with loops running in several checkouts it is what
 			// decides whether a finding is this morning's problem, and claiming runs it in that cwd.
-			const why = e.dismiss_reason ? ` — dismissed: ${redact(e.dismiss_reason)}` : "";
-			if (!numbered) return `  [${e.status}] ${mark}${redact(e.text)}${why}  (${projectOf(e.cwd)}, ${e.source})`;
-			return `  ${i + 1}. [${e.id.slice(0, 12)}] ${mark}${redact(e.text)}  (${projectOf(e.cwd)}, ${e.source}, ${when})`;
+			// Every field from the file goes through screenText, as the card's text does: none of them
+			// may repaint the terminal this prints in.
+			const why = e.dismiss_reason ? ` — dismissed: ${redact(screenText(e.dismiss_reason))}` : "";
+			const where = `${screenText(projectOf(e.cwd))}, ${screenText(cardOrigin(card))}`;
+			if (!numbered) return cardLines(card, `  [${e.status}] `, `${why}  (${where})`);
+			return cardLines(card, `  ${i + 1}. [${e.id.slice(0, 12)}] `, `  (${where}, ${when})`);
 		});
 	}
 
-	function claimPrompt(e: InboxEntry): string {
-		const verified = e.verified ? `\n(An independent checker reviewed and kept this finding${e.verified_reason ? `: ${e.verified_reason}` : ""}.)` : "";
-		// A checkpoint is a decision the loop prepared and left to a person; the claim is that
-		// person's yes, so the turn carries the decision out rather than re-investigating it.
-		const checkpoint = e.kind === "checkpoint" ? "\nThis finding is a checkpoint: claiming it is the person's approval of the decision it recommends — carry that decision out, and stop where the finding says a person acts." : "";
-		return `A recurring loop (${e.source}, running in ${e.cwd}) reported this finding — investigate and address it:\n${e.text}${verified}${checkpoint}`;
-	}
-
 	/* ------------------------------------------------------------------ /goal */
 
 	/**
@@ -1244,6 +1798,8 @@ export default function piLoops(pi: ExtensionAPI) {
 	let goal: GoalState | undefined;
 	let goalMessages: unknown[] = [];
 	let goalEvaluating = false;
+	/** A turn settled while the evaluator ran and was not judged; the running evaluation's settle judges it next (judgeCaughtUp). */
+	let goalSkippedTurn = false;
 	/** Set while the evaluator runs, so an abort or `/goal pause` can cut it short. */
 	let goalAbort: AbortController | undefined;
 	/** How the last turn ended: an aborted or failed turn says nothing about the goal. */
@@ -1256,13 +1812,29 @@ export default function piLoops(pi: ExtensionAPI) {
 		if (ctx?.hasUI) ctx.ui.setStatus(GOAL_STATUS_KEY, next.status === "cleared" ? undefined : `goal: ${next.status}`);
 	}
 
-	async function evaluateGoal(ctx: ExtensionContext): Promise<void> {
+	/**
+	 * A continuation still queued belongs to the goal being replaced or cleared: a new goal would
+	 * otherwise be handed the old condition's prompt as its first turn.
+	 */
+	function dropQueuedContinuations(): void {
+		const sessionId = binding.here().sessionId;
+		if (!sessionId) return;
+		dropContinuations(requests, sessionId, self, executor.view(sessionId).producerAlive);
+	}
+
+	/** Evaluates the goal at the end of a turn. True when it sent a continuation, which is the next turn. */
+	async function evaluateGoal(ctx: ExtensionContext): Promise<boolean> {
 		const pursued = goal;
-		if (!pursued || pursued.status !== "pursuing" || goalEvaluating) return;
+		if (!pursued || pursued.status !== "pursuing") return false;
+		if (goalEvaluating) {
+			goalSkippedTurn = true;
+			return false;
+		}
 		// A turn that the user interrupted, or that the provider failed, is not evidence about the
 		// goal — and re-prompting after an abort would leave Esc unable to stop a goal at all.
-		if (lastTurnStopReason === "aborted" || lastTurnStopReason === "error") return;
+		if (lastTurnStopReason === "aborted" || lastTurnStopReason === "error") return false;
 		goalEvaluating = true;
+		goalSkippedTurn = false; // only a turn that settles during this evaluation counts
 		const evaluatorStartedAt = Date.now();
 		// Where the session is now. The continuation the evaluator may ask for is a prompt about
 		// *this* point; if the user has taken the turn by the time it comes back, it must not be
@@ -1300,10 +1872,10 @@ export default function piLoops(pi: ExtensionAPI) {
 			});
 			// The user can pause, clear or replace the goal while the evaluator runs; a decision about
 			// the goal they had must not be written over the one they have now.
-			if (!goal || goal.status !== "pursuing" || goal.condition !== pursued.condition) return;
+			// An aborted evaluation is discarded: whoever aborted it has already written the goal.
+			if (!evaluationApplies(goal, pursued, ctrl.signal.aborted)) return false;
 			let outcome: { state: GoalState; action: GoalAction };
-			if (ctrl.signal.aborted) outcome = pauseFor(pursued, "goal evaluator cancelled");
-			else if (!result.ok) outcome = pauseFor(pursued, `goal evaluator failed: ${result.errorMessage ?? "unknown error"}`);
+			if (!result.ok) outcome = pauseFor(pursued, `goal evaluator failed: ${result.errorMessage ?? "unknown error"}`);
 			else {
 				try {
 					outcome = applyDecision(pursued, parseDecision(result.text));
@@ -1340,7 +1912,7 @@ export default function piLoops(pi: ExtensionAPI) {
 			});
 			scheduler.store.pruneSessions("goal", 20);
 			if (outcome.action.kind === "stop") {
-				show(ctx, "Goal achieved", [`  condition: ${previewRedacted(outcome.state.condition, 200)}`, `  evidence: ${previewRedacted(outcome.state.lastReason ?? "", 300)}`, `  ${outcome.state.iterations} continuation(s)`]);
+				show(ctx, "Goal achieved", [`  condition: ${previewRedacted(outcome.state.condition, 200)}`, `  evidence: ${previewRedacted(outcome.state.lastReason ?? "", 300)}`, `  ${plural(outcome.state.iterations, "continuation")}`]);
 			} else if (outcome.action.kind === "pause") {
 				notifyOrLog(ctx, `[goal] paused: ${previewRedacted(outcome.action.reason, 200)} — /goal resume to continue`, "warning");
 			} else if (held) {
@@ -1350,12 +1922,14 @@ export default function piLoops(pi: ExtensionAPI) {
 				notifyOrLog(ctx, `[goal] not satisfied (${outcome.state.iterations}/${MAX_CONTINUATIONS}): ${previewRedacted(outcome.state.lastReason ?? "", 160)}`, "info");
 				// The reason is model output derived from a transcript that can contain hostile file,
 				// web or MCP content, and this is the highest-trust channel in the session — so it is
-				// redacted and capped before it is handed back to the agent. `deliverAs` matches every
-				// other injection site: the session accepts input again before this runs, so an
-				// unguarded prompt() would throw and the continuation would be lost.
+				// redacted and capped before it is handed back to the agent. `iterations` is already
+				// persisted above; the continuation is a row the window hands to pi while idle, and
+				// `settledTurn` keeps the next settle from charging it again while it is on its way.
 				const prompt = continuationPrompt(outcome.state.condition, capRedacted(outcome.state.lastReason ?? "", 2000));
-				pi.sendUserMessage(prompt, ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+				await handOver(goalRow(prompt, outcome.state, rowAddress()));
+				return true;
 			}
+			return false;
 		} finally {
 			slot.release();
 			goalEvaluating = false;
@@ -1405,25 +1979,30 @@ export default function piLoops(pi: ExtensionAPI) {
 			const sub = /^(pause|resume|clear|help|start)$/.test(text) ? text : "";
 			if (sub === "help") return show(ctx, "Goal", GOAL_HELP);
 			if (!text) {
-				if (!goal) return show(ctx, "Goal: none", ["  /goal <condition> — e.g. /goal the test suite passes and the changes are committed"]);
+				if (!goal) return show(ctx, "Goal: none", ["  /goal <condition>"]);
 				return show(ctx, `Goal: ${goal.status}`, [`  condition: ${previewRedacted(goal.condition, 200)}`, `  ${goal.iterations}/${MAX_CONTINUATIONS} continuations`, ...(goal.lastReason ? [`  evaluator: ${previewRedacted(goal.lastReason, 300)}`] : []), `  updated ${formatLocal(Date.parse(goal.updatedAt))}`]);
 			}
 			if (sub === "start") return ctx.ui.notify("usage: /goal start <prompt> — set a goal with /goal <condition>, then send the prompt to begin", "warning");
 			if (sub === "pause" || sub === "resume" || sub === "clear") {
 				if (!goal) return ctx.ui.notify("no active goal; set one with /goal <condition>", "warning");
-				// An evaluation in flight was decided about the goal as it was; stop it here.
+				// An evaluation in flight was decided about the goal as it was; stop it here, and do not
+				// judge a turn it skipped against the goal as it is now.
 				goalAbort?.abort();
+				goalSkippedTurn = false;
 				if (sub === "clear") {
+					dropQueuedContinuations();
 					persistGoal(ctx, { ...goal, status: "cleared", updatedAt: stamp() });
 					return ctx.ui.notify("goal cleared", "info");
 				}
 				if (sub === "resume" && goal.status === "achieved") return ctx.ui.notify("this goal was achieved; set a new one with /goal <condition>", "warning");
-				// Resuming after the budget ran out starts the allowance again.
-				const next: GoalState = sub === "pause" ? { ...goal, status: "paused", updatedAt: stamp() } : { ...goal, status: "pursuing", iterations: goal.status === "budget_limited" ? 0 : goal.iterations, updatedAt: stamp() };
+				// Resuming with the allowance spent starts it again (resumeGoal).
+				const next: GoalState = sub === "pause" ? { ...goal, status: "paused", updatedAt: stamp() } : resumeGoal(goal);
 				persistGoal(ctx, next);
 				return ctx.ui.notify(`goal ${sub === "pause" ? "paused" : "resumed"}`, "info");
 			}
 			goalAbort?.abort(); // the old goal's evaluation is about a condition the user just replaced
+			goalSkippedTurn = false;
+			dropQueuedContinuations();
 			persistGoal(ctx, newGoal(text));
 			ctx.ui.notify(`goal set: ${previewRedacted(text, 160)} — send a prompt to begin; evaluated after every turn, up to ${MAX_CONTINUATIONS} continuations`, "info");
 		},
@@ -1432,7 +2011,7 @@ export default function piLoops(pi: ExtensionAPI) {
 	pi.registerCommand("inbox", {
 		description: "Triage findings from stateful cron jobs — /inbox help",
 		getArgumentCompletions: (prefix) => {
-			const subs = ["list", "all", "claim", "dismiss", "clear", "help", "--all"];
+			const subs = ["list", "all", "claim", "dismiss", "open", "clear", "help", "--all"];
 			const items = subs.filter((s) => s.startsWith(prefix)).map((s) => ({ value: s, label: s }));
 			return items.length ? items : null;
 		},
@@ -1454,15 +2033,16 @@ export default function piLoops(pi: ExtensionAPI) {
 						const all = scheduler.inbox.listNew();
 						const entries = scoped(all);
 						if (!entries.length) {
-							show(ctx, all.length ? `inbox: nothing new in ${homeRel(session.cwd)} — ${all.length} finding(s) elsewhere (/inbox --all)` : "inbox: empty — stateful loops (/cron add --stateful) report findings here", []);
+							show(ctx, all.length ? `inbox: nothing new in ${homeRel(session.cwd)} — ${plural(all.length, "finding")} elsewhere (/inbox --all)` : "inbox: empty", []);
+							markSeenIfShown(everywhere);
 							return;
 						}
 						const lines = inboxLines(entries, true);
 						const elsewhere = all.length - entries.length;
 						if (elsewhere) lines.push(`+ ${elsewhere} finding${elsewhere === 1 ? "" : "s"} in other projects — /inbox --all`);
-						lines.push("claim with /inbox claim <n>, dismiss with /inbox dismiss <n>");
 						const decisions = entries.filter((e) => e.kind === "checkpoint").length;
 						show(ctx, `Inbox (${where}, ${entries.length} new${decisions ? `, ${decisions} need${decisions === 1 ? "s" : ""} a decision` : ""}, times ${localOffset(Date.now())}):`, lines);
+						markSeenIfShown(everywhere);
 						return;
 					}
 					case "all": {
@@ -1474,7 +2054,8 @@ export default function piLoops(pi: ExtensionAPI) {
 						show(ctx, "inbox", INBOX_HELP);
 						return;
 					case "claim":
-					case "dismiss": {
+					case "dismiss":
+					case "open": {
 						// `/inbox dismiss 3 that file is generated`: the first word names the finding, the rest is
 						// why, and the reason goes to the loop that reported it, in its next run's prompt. A
 						// claim takes the whole argument as the ref, as it always has. For a dismiss, `--all`
@@ -1502,21 +2083,44 @@ export default function piLoops(pi: ExtensionAPI) {
 						const entry = resolveInboxRef(entries, target, { ordinals: true });
 						if (!entry) {
 							const n = Number(target);
-							ctx.ui.notify(!target ? "usage: /inbox claim <n or inb-id> | /inbox dismiss <n or inb-id> [reason]" : Number.isInteger(n) ? `no inbox entry #${n} in ${where} (have ${entries.length}; /inbox --all lists every project)` : `no new inbox entry matching '${target}'`, "warning");
+							ctx.ui.notify(!target ? "usage: /inbox claim <n or inb-id> | /inbox dismiss <n or inb-id> [reason] | /inbox open <n or inb-id>" : Number.isInteger(n) ? `no inbox entry #${n} in ${where} (have ${entries.length}; /inbox --all lists every project)` : `no new inbox entry matching '${target}'`, "warning");
+							return;
+						}
+						if (sub === "open") {
+							if (entry.source.startsWith("trigger:")) {
+								ctx.ui.notify(`inbox entry ${target} is a rule's result: a rule check keeps no run transcript to open`, "warning");
+								return;
+							}
+							// The run worked in its own project; a conversation forked from it here would be a
+							// conversation about that project with this one's directory and tools.
+							if (entry.cwd && !sameProject(entry.cwd, session.cwd)) {
+								ctx.ui.notify(`inbox entry ${target} is from ${homeRel(entry.cwd)}: open it from a pi in that project`, "warning");
+								return;
+							}
+							const transcript = entry.transcript ?? scheduler.store.allRuns().find((record) => record.runId === entry.run_id)?.sessionFile;
+							if (!transcript || !fs.existsSync(transcript)) {
+								ctx.ui.notify(`transcript for inbox entry ${target} is gone (pruned, or the run kept none)`, "warning");
+								return;
+							}
+							// Into this window's session directory: with `--session-dir`, pi's default one is not where `/resume` looks.
+							const forkedFile = SessionManager.forkFrom(transcript, ctx.cwd, ctx.sessionManager.getSessionDir()).getSessionFile();
+							if (forkedFile) await ctx.switchSession(forkedFile);
 							return;
 						}
-						await scheduler.inbox.setStatus(entry.id, sub === "claim" ? "claimed" : "dismissed", sub === "claim" ? session.sessionId : undefined, reason || undefined);
-						refreshBadge();
 						if (sub === "dismiss") {
+							const decided = await scheduler.inbox.decide(entry.id, "dismissed", { reason: reason || undefined });
+							refreshBadge();
+							if (!("ok" in decided)) {
+								ctx.ui.notify("missing" in decided ? `inbox entry ${target} is gone` : `inbox entry ${target} was already ${decided.already}`, "warning");
+								return;
+							}
 							const loop = scheduler.store.load().find((j) => j.id === entry.job_id);
-							// A trigger's finding carries its source label where a loop's carries a job id; a
-							// trigger has no notes and no next run to tell.
-							const gone = entry.job_id?.startsWith("cron-") ? "the loop that reported it is gone, so nobody is told" : "a trigger reported it, and a trigger keeps no notes, so nobody is told";
-							const told = reason ? ` — ${loop ? `${loop.name ?? loop.id} is told why on its next run` : gone}` : "";
-							ctx.ui.notify(`dismissed: ${previewRedacted(entry.text, 80)}${told}`, "info");
+							ctx.ui.notify(`dismissed: ${previewRedacted(screenText(entry.text), 80)}${dismissTail(dismissOutcome(entry, loop, reason))}`, "info");
 							return;
 						}
-						pi.sendUserMessage(claimPrompt(entry), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+						// The hand-off is queued before the finding is marked claimed (src/engine.ts handOver).
+						await handOver(inboxClaimRow(claimPrompt(entry), entry.id, rowAddress()), { inbox: scheduler.inbox, entryId: entry.id });
+						refreshBadge();
 						return;
 					}
 					case "clear": {
@@ -1544,8 +2148,8 @@ export default function piLoops(pi: ExtensionAPI) {
 	const TRIGGERS_USAGE = "[status|rules|sources|hooks|enable|disable|remove|set|run|running|audit|abort|panel|help] — /triggers help for the arguments";
 
 	const TRIGGERS_HELP = [
-		"/triggers                      rule counts, who owns the checker, its last check, push sources",
-		"/triggers rules [--all]        this project's dynamic rules        (--all: every project on this machine)",
+		"/triggers rules [--all]        this project's rules, as bare /triggers lists them   (--all: every project on this machine)",
+		"/triggers status               rule counts, what checks them, the last check, push sources",
 		"/triggers sources              MCP push sources, the local crontab, the dynamic checker — and what each has seen (/triggers hooks is the same view)",
 		"/triggers enable <n|id>        /triggers disable <n|id>            also --all (this project) | --all-projects (the machine)",
 		"/triggers remove <n|id>        also remove --all | remove --all-projects; /new-trigger creates one",
@@ -1554,22 +2158,12 @@ export default function piLoops(pi: ExtensionAPI) {
 		"/triggers running              actions in flight (dynamic checks and cron runs), and the sub-agent slots in use",
 		"/triggers audit [N] [--all]    recent decisions, with each run's transcript path (default 10)",
 		"/triggers abort <trace_id>     stop one running action             /triggers abort --all   stop every one",
-		"/triggers panel on|off         side panel above the editor (Triggers / Inbox / Cron / MCP)",
+		"/triggers panel on|off         side panel above the editor (Rules / Loops / Runs / MCP)",
 		"create one: /new-trigger when ~/build.done exists, run cargo test and show me the result",
 		"config: ~/.pi/agent/loops/config.toml [triggers] poll_interval_secs, mcp.toml for push sources, hooks.toml for lifecycle hooks",
 	];
 
-	function ruleLines(rules: ReturnType<TriggerStore["load"]>, numbered: boolean): string[] {
-		return rules.map((r, i) => {
-			const state = r.enabled ? "enabled" : "disabled";
-			const fire = r.fireOnce ? "fire_once" : "repeat";
-			const out = r.promoteToChat ? "promote_to_chat" : "audit_only";
-			const fired = r.firedAt ? `, fired_at=${r.firedAt}` : "";
-			const head = numbered ? `${String(i + 1).padStart(2)}. ` : "  - ";
-			const other = r.createdBy?.sessionId && r.createdBy.sessionId !== session.sessionId ? `  (session ${r.createdBy.sessionId.slice(0, 8)})` : "";
-				return `${head}${r.id} [${state}, ${fire}, ${out}${fired}] when ${previewRedacted(r.condition, 80)} -> ${previewRedacted(r.action, 80)}${!sameProject(r.cwd, session.cwd) ? `  (${homeRel(r.cwd)})` : ""}${other}`;
-		});
-	}
+	const ruleLines = (rules: ReturnType<TriggerStore["load"]>, numbered: boolean) => listRules(rules, { numbered, sessionId: session.sessionId, cwd: session.cwd, home: process.env.HOME ?? "", sameProject });
 
 	pi.registerCommand("triggers", {
 		description: "Show trigger sources, rules, running actions, and recent audit — /triggers help",
@@ -1590,25 +2184,27 @@ export default function piLoops(pi: ExtensionAPI) {
 			};
 			try {
 				switch (sub) {
-					case "":
 					case "status": {
-						const rules = store.load();
-						const enabled = rules.filter((r) => r.enabled).length;
-						const fireOnce = rules.filter((r) => r.fireOnce).length;
-						const promote = rules.filter((r) => r.promoteToChat).length;
-						const leader = scheduler.readLeader();
-						show(ctx, "Trigger status:", [
-							`  dynamic rules: ${rules.length} total, ${enabled} enabled, ${rules.length - enabled} disabled (${fireOnce} fire_once, ${rules.length - fireOnce} repeat, ${promote} promote_to_chat)`,
-							`  local dynamic checker: ${schedulerStarted ? `this process for ${homeRel(session.cwd)}${scheduler.isLeader ? " (and, as timer owner, for projects with no pi open)" : ` (timer owned by pid ${leader?.pid ?? "?"})`}` : "not running here"}, polls every ${triggers.pollIntervalSecs}s while enabled rules exist (checks run in a pi open in the rule's project)`,
-							`  last check: ${triggers.lastPoll ? `${formatLocal(Date.parse(triggers.lastPoll.at))} in ${homeRel(triggers.lastPoll.cwd)} — ${triggers.lastPoll.outcome}` : "none yet"}`,
-							`  push trigger sources: ${mcpConfigs.length} configured MCP server(s) feed server-pushed events into the same trigger runtime (deduplicated machine-wide, hop ${hop})${mcpConfigError ? ` (config error: ${mcpConfigError})` : ""}`,
-							`  sources: ${mcpSources.length + LOCAL_SOURCES} total, ${mcpSources.filter((s) => s.status.state === "connected").length + (localSourcesConnected() ? LOCAL_SOURCES : 0)} connected, ${mcpSources.filter((s) => s.status.requiresAttention).length} require attention`,
-							`  running: ${triggers.runningList().length} · deduped: ${triggers.dedupedCount} · cycle_suppressed: ${triggers.cycleSuppressedCount} · storage: ${homeRel(store.rulesFile)}`,
-							...(store.lastPersistenceError ? [`  ! ${store.lastPersistenceError}`] : []),
-							`  audit: ${homeRel(store.auditFile)} (/triggers audit [N])`,
-						]);
+						const [first, ...lines] = triggerStatusLines({
+							rules: store.load(),
+							pollIntervalSecs: triggers.pollIntervalSecs,
+							running: !!liveHostRecord(),
+							lastCheck: lastPoll(),
+							home: process.env.HOME ?? "",
+							pushSources: mcpConfigs.length,
+							configError: mcpConfigError,
+							sources: { total: mcpSources.length + LOCAL_SOURCES, connected: mcpSources.filter((s) => s.status.state === "connected").length + (localSourcesConnected() ? LOCAL_SOURCES : 0), attention: mcpSources.filter((s) => s.status.requiresAttention).length },
+							runningCount: machineRuns().length,
+							deduplicated: triggers.dedupedCount,
+							cyclesStopped: triggers.cycleSuppressedCount,
+							rulesFile: store.rulesFile,
+							auditFile: store.auditFile,
+							persistenceError: store.lastPersistenceError,
+						});
+						show(ctx, first, lines);
 						return;
 					}
+					case "":
 					case "rules": {
 						const all = store.load();
 						const here = all.filter((r) => sameProject(r.cwd, session.cwd));
@@ -1626,7 +2222,7 @@ export default function piLoops(pi: ExtensionAPI) {
 					case "hooks": {
 						// MCP hooks are registered first, then the cron hook, then the dynamic checker.
 						const lines: string[] = [];
-						const localState = localSourcesConnected() ? "connected" : schedulerStarted ? "standby" : "disabled";
+						const localState = localSourcesConnected() ? "connected" : "pi-loops is not running";
 						mcpSources.forEach((source, index) => {
 							const status = source.status;
 							lines.push(`  - source #${index + 1}: ${status.state}${status.reason ? ` (${previewRedacted(status.reason, 80)})` : ""} queued=${status.queuedCount} dropped=${status.droppedCount} deduped=${status.dedupedCount} last_event=${status.lastEventAt ?? "never"}${status.requiresAttention ? `  ! ${status.requiresAttention}` : ""}`);
@@ -1644,10 +2240,10 @@ export default function piLoops(pi: ExtensionAPI) {
 							.sort((a, b) => Date.parse(a) - Date.parse(b))
 							.at(-1);
 						lines.push(`  - source #${mcpSources.length + 1}: ${localState} queued=${scheduler.runningCount} dropped=0 deduped=0 last_event=${lastFired ?? "never"}`);
-						lines.push(`      subscriptions: ${jobs.length ? `local crontab: ${jobs.length} job(s), ${jobs.filter((j) => j.enabled).length} enabled` : "local crontab: 0 jobs"}`);
+						lines.push(`      subscriptions: ${jobs.length ? `local crontab: ${plural(jobs.length, "loop")}, ${jobs.filter((j) => j.enabled).length} enabled` : "local crontab: 0 loops"}`);
 						lines.push(`  - source #${mcpSources.length + LOCAL_SOURCES}: ${localState} queued=${triggers.runningList().filter((r) => r.sourceLabel === "local:dynamic").length} dropped=0 deduped=${triggers.dedupedCount} last_event=${triggers.lastPoll?.at ?? "never"}`);
 						lines.push("      subscriptions: dynamic trigger periodic check");
-						if (mcpSources.length) lines.push("  (pushes are deduplicated machine-wide; results go to this chat only for this project's rules, otherwise to /inbox)");
+						if (mcpSources.length) lines.push("  (pushes are deduplicated machine-wide; a rule's result goes to the conversation that created it)");
 						if (mcpConfigError) lines.push(`  ! ${mcpConfigError}`);
 						show(ctx, `Trigger sources (${LOCAL_SOURCES + mcpSources.length}):`, lines);
 						return;
@@ -1663,7 +2259,7 @@ export default function piLoops(pi: ExtensionAPI) {
 							const targets = store.load().filter((r) => (everywhere || sameProject(r.cwd, session.cwd)) && r.enabled !== enable);
 							for (const r of targets) await store.setEnabled(r.id, enable);
 							refreshBadge();
-							ctx.ui.notify(`${enable ? "enabled" : "disabled"} ${targets.length} rule(s)${everywhere ? " on this machine" : " in this project"}`, "info");
+							ctx.ui.notify(`${enable ? "enabled" : "disabled"} ${plural(targets.length, "rule")}${everywhere ? " on this machine" : " in this project"}`, "info");
 							return;
 						}
 						const rule = pickRule(rest);
@@ -1684,7 +2280,7 @@ export default function piLoops(pi: ExtensionAPI) {
 						if (rest.trim() === "--all" || rest.trim() === "--all-projects") {
 							const everywhere = rest.trim() === "--all-projects";
 							const n = await store.clear(everywhere ? undefined : session.cwd, sameProject);
-							ctx.ui.notify(`removed ${n} dynamic trigger rule(s)${everywhere ? " (every project on this machine)" : ` in ${homeRel(session.cwd)}`}`, "info");
+							ctx.ui.notify(`removed ${plural(n, "dynamic trigger rule")}${everywhere ? " (every project on this machine)" : ` in ${homeRel(session.cwd)}`}`, "info");
 							return;
 						}
 						const rule = pickRule(rest);
@@ -1748,17 +2344,14 @@ export default function piLoops(pi: ExtensionAPI) {
 						return;
 					}
 					case "running": {
+						await refreshHostSnapshot();
 						const now = Date.now();
-						const running = [
-							...triggers.runningList().map((r) => ({ traceId: r.traceId, sourceLabel: r.sourceLabel, eventLabel: r.eventLabel, startedAt: r.startedAt, promptPreview: r.promptPreview, sessionFile: undefined as string | undefined })),
-							...scheduler.runningRuns().map((r) => ({ traceId: r.runId, sourceLabel: "Cron", eventLabel: r.jobId, startedAt: r.startedAt, promptPreview: r.promptPreview, sessionFile: r.sessionFile })),
-						];
+						const running = machineRuns().map((r) => ({ traceId: r.id, sourceLabel: r.inHost ? `${r.source} (in the background)` : r.source, eventLabel: r.event, startedAt: r.startedAt, promptPreview: r.promptPreview, sessionFile: r.sessionFile }));
 						show(
 							ctx,
-							// The slot count is the whole machine's, not this list's: a run started by another
-							// project's job holds one too, and "why is nothing starting" is answered by the
-							// number, not by the rows.
-							`${running.length ? `Running triggers (${running.length}):` : "(no running triggers)"}  ${triggers.slots.inUseCount} of ${triggers.slots.limit} sub-agent slot(s) in use`,
+							// The machine's runs, here and in the background, against the limit both use: a run
+							// started by another project's job holds a slot too, and is in this list.
+							`${running.length ? `Running triggers (${running.length}):` : "(no running triggers)"}  ${running.length} of ${plural(triggers.slots.limit, "sub-agent slot")} in use`,
 							running.flatMap((r) => {
 								const secs = Math.max(0, Math.round((now - Date.parse(r.startedAt)) / 1000));
 								const elapsed = secs < 90 ? `${secs}s` : `${Math.round(secs / 60)}m`;
@@ -1798,15 +2391,47 @@ export default function piLoops(pi: ExtensionAPI) {
 						return;
 					}
 					case "abort": {
+						// Loops and checks run in the host: what is not running here is asked of the host.
+						const askHostAbort = async (id: string, isRun: boolean): Promise<boolean> => {
+							const answer = await askHost(dir, isRun ? { op: "abort", runId: id } : { op: "abort", traceId: id });
+							return !!answer?.ok && !!answer.aborted;
+						};
 						if (rest.trim() === "--all") {
 							let n = triggers.abortAll();
 							for (const r of scheduler.runningRuns()) if (scheduler.abortRun(r.runId)) n++;
-							ctx.ui.notify(`requested abort for ${n} running trigger(s)`, "info");
+							const host = await refreshHostSnapshot();
+							for (const r of host?.runs ?? []) if (await askHostAbort(r.runId, true)) n++;
+							for (const c of host?.checks ?? []) if (await askHostAbort(c.traceId, false)) n++;
+							ctx.ui.notify(`requested abort for ${plural(n, "running trigger")}`, "info");
 							return;
 						}
 						const target = rest.trim();
 						const hit = triggers.runningList().find((r) => r.traceId === target || r.traceId.startsWith(target));
 						const cronHit = scheduler.runningRuns().find((r) => r.runId === target || r.runId.startsWith(target));
+						if (target && !hit && !cronHit) {
+							// A turn in a closed conversation, run by pi-loops in the background: stopped through a
+							// request (src/engine.ts stopRow), which outlives a socket that does not answer. A loop
+							// run or a check belongs to no conversation and keeps the socket.
+							const held = heldTurnFor(binding.store.list(), target);
+							if (held?.kind === "ambiguous") {
+								ctx.ui.notify(`${target} is a prefix of ${held.matches.length} running turns; give more of the id: ${held.matches.join(", ")}`, "warning");
+								return;
+							}
+							if (held) {
+								requests.append(stopRow(held.sessionId, { id: held.runId }, "window", createdBy()));
+								void ringHost(dir, `request:${held.sessionId}`).catch(() => undefined);
+								ctx.ui.notify(`requested stop for ${held.runId} (session ${shortSessionId(held.sessionId)})`, "info");
+								return;
+							}
+							const host = await refreshHostSnapshot();
+							const hostRun = host?.runs.find((r) => r.runId === target || r.runId.startsWith(target));
+							const hostCheck = host?.checks.find((c) => c.traceId === target || c.traceId.startsWith(target));
+							if (hostRun || hostCheck) {
+								const ok = await askHostAbort(hostRun?.runId ?? hostCheck!.traceId, !!hostRun);
+								ctx.ui.notify(ok ? `requested abort for ${hostRun?.runId ?? hostCheck!.traceId} in the background` : `pi-loops did not abort ${target}: it may have just finished`, ok ? "info" : "warning");
+								return;
+							}
+						}
 						if (!target || (!hit && !cronHit)) {
 							ctx.ui.notify(target ? `no running trigger with trace_id '${target}'` : "usage: /triggers abort <trace_id>|--all", "warning");
 							return;
@@ -1840,10 +2465,64 @@ export default function piLoops(pi: ExtensionAPI) {
 	const ARCHIVE_WARNING = `warning: ${ARCHIVE_EXT} archives include transcript and tool history. They do not include separate auth stores, provider credentials, OAuth tokens, MCP config, or the inbox.`;
 
 	pi.registerCommand("pi-loops", {
-		description: "About this extension, and `install-launcher` to put the `pi-loops` command on your PATH",
+		description: "About this extension; start | stop | restart | status the part that runs loops while no pi is open; web opens this conversation in the browser page; install-launcher puts the `pi-loops` command on your PATH, uninstall-launcher removes it",
 		handler: async (args, ctx) => {
 			lastCtx = ctx;
 			const sub = args.trim().split(/\s+/)[0] ?? "";
+			if (sub === "start" || sub === "stop" || sub === "restart" || sub === "status") {
+				await backgroundCommand(sub, ctx);
+				return;
+			}
+			if (sub === "ring") {
+				// The browser page's doorbell (docs/design.md decision 23): drain now; with an id and a
+				// fingerprint, first believe that row's source, since this stdin is the page's own channel.
+				const [, id, fingerprint] = args.trim().split(/\s+/);
+				// A viewer retries its lease at every tick; the bell is a better moment: a holder that
+				// died since the last tick would otherwise keep the page's message waiting up to 30 s.
+				try {
+					const outcome = binding.refresh();
+					if (outcome) noteBinding(outcome);
+				} catch (err: any) {
+					log.info(`lease: ${err?.message ?? err}`);
+				}
+				const sessionId = binding.here().sessionId;
+				if (id && fingerprint && sessionId && !ringProduced(requests.list(sessionId), id, fingerprint, (row) => executor.produced(row))) log.info(`ring: no queued request ${id.slice(0, 8)} with that fingerprint; it runs capped`);
+				// A command handler, outside pi's own event cycle: this drain may judge a send pi refused
+				// (the page rings again once the grace has passed), as the tick may.
+				await drainRequests({ tick: true });
+				return;
+			}
+			if (sub === "web") {
+				// The page on this conversation with no `pi-loops` on PATH: the same page-open and opener
+				// the command line uses. Shown as a notice, not written into the conversation: the link
+				// carries a one-use key.
+				const lines: string[] = [];
+				const host = { ...pageLaunchHost(dir), packageDir: PACKAGE_DIR, piPackage: piPackageDir(), startedBy: `the pi window pid ${process.pid}`, myPiVersion: PI_VERSION };
+				const req = webPageRequest({ cwd: session.cwd, sessionId: binding.here().sessionId ?? session.sessionId, sessionFile: ctx.sessionManager.getSessionFile() });
+				// The link is shown and copied before the browser is tried: the wait for a browser to spend
+				// the key can take seconds, and the person may paste the link sooner.
+				const onLink = async (link: string) => {
+					// Said only when a clipboard command took the link. pi's copy can still get there through
+					// OSC 52, which no terminal confirms, so that try says nothing either way.
+					if (await copyText(link)) lines.push("  copied to the clipboard");
+					else await copyToClipboard(link).catch((err: any) => log.info(`/pi-loops web: copy: ${err?.message ?? err}`));
+					ctx.ui.notify(lines.join("\n"), "info");
+				};
+				const opened = await openPage(dir, req, { key: true, browser: isRemoteTty() ? "remote" : "yes", host }, (l) => lines.push(l), undefined, onLink);
+				// pi shows one notice at a time, so the last one repeats the link with the outcome.
+				ctx.ui.notify(lines.join("\n"), opened.code === 0 ? "info" : "warning");
+				refreshBadge();
+				return;
+			}
+			if (sub === "install-launcher" || sub === "uninstall-launcher") {
+				try {
+					slashDir(tokenize(splitCommand(args).rest).map((t) => t.value));
+				} catch (err: any) {
+					if (!(err instanceof UsageError)) throw err;
+					ctx.ui.notify(`${err.message}. usage: /pi-loops ${sub} [--dir <dir>]`, "warning");
+					return;
+				}
+			}
 			if (sub === "install-launcher") {
 				// The command line's own `install-launcher` cannot be reached until it has run once —
 				// `pi install` does not put the package on your PATH. You are already inside pi with
@@ -1858,12 +2537,21 @@ export default function piLoops(pi: ExtensionAPI) {
 				show(ctx, code === 0 ? "installed the pi-loops launcher" : "could not install the launcher", lines.map((l) => `  ${l.trim()}`));
 				return;
 			}
+			if (sub === "uninstall-launcher") {
+				const lines: string[] = [];
+				const code = uninstallLauncher(slashDir(tokenize(splitCommand(args).rest).map((t) => t.value)), (l) => lines.push(l));
+				show(ctx, code === 0 ? "the pi-loops launcher is gone" : "left the launcher alone", lines.map((l) => `  ${l.trim()}`));
+				return;
+			}
 			show(ctx, `pi-loops ${PI_LOOPS_VERSION}`, [
 				`  loops directory: ${homeRel(dir)}`,
 				`  package: ${homeRel(PACKAGE_DIR)}`,
 				"",
+				"  /pi-loops start | stop | restart | status",
+				"  /pi-loops web                              open this conversation in the browser page",
 				"  /pi-loops install-launcher [--dir <dir>]   put the `pi-loops` command on your PATH",
-				"  /cron · /triggers · /inbox · /goal   the automation itself",
+				"  /pi-loops uninstall-launcher [--dir <dir>] remove it, so no session writes it again",
+				"  /cron · /triggers · /inbox · /goal",
 			]);
 		},
 	});
@@ -1983,8 +2671,8 @@ export default function piLoops(pi: ExtensionAPI) {
 				return;
 			}
 			pendingRecipeAdd = { words, project };
-			pi.sendUserMessage(trackerSetupPrompt(recipe, project), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
-			ctx.ui.notify(`${m.name} reads ${TRACKER_FILE}, and this project has none yet — the agent will write it with you now, and the install continues here as soon as it exists`, "info");
+			const { written } = await handOver(recipeRow(trackerSetupPrompt(recipe, project), m.name, "tracker", rowAddress()));
+			ctx.ui.notify(written ? `${m.name} reads ${TRACKER_FILE}, and this project has none yet — the agent will write it with you now, and the install continues here as soon as it exists` : `${m.name} reads ${TRACKER_FILE}, and this project has none yet — the agent is already queued to write it with you; the install continues here as soon as it exists`, "info");
 			return;
 		}
 		let level: AutonomyLevel | undefined;
@@ -2003,7 +2691,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		const existing = scheduler.store.load();
 		const clash = m.jobs.map((j) => existing.find((e) => e.name === j.name)).filter((e): e is LoopJob => !!e);
 		if (clash.length) {
-			show(ctx, `not installed: ${clash.length} job name(s) already in use`, [
+			show(ctx, `not installed: ${plural(clash.length, "job name")} already in use`, [
 				...clash.map((e) => `  "${e.name}" — ${e.recipe ? `from recipe ${e.recipe}` : "created with /cron add"}, in ${homeRel(e.cwd)}`),
 				"",
 				`  ${clash.some((e) => e.recipe === m.name) ? `/recipe remove ${m.name}` : `/cron remove <name>`} first, then /recipe add ${ref} again`,
@@ -2014,7 +2702,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		const preflight = await preflightLines(recipe, project, level);
 		let overwrite = false;
 		if (plan.changed.length) {
-			overwrite = await ctx.ui.confirm(`Overwrite ${plan.changed.length} edited file(s)?`, [...plan.changed.map((f) => `  ${f}`), "", "These differ from what would be written. Yes replaces them with the packaged version; No keeps your copies (the record is still written, and /recipe update merges later)."].join("\n"));
+			overwrite = await ctx.ui.confirm(`Overwrite ${plural(plan.changed.length, "edited file")}?`, [...plan.changed.map((f) => `  ${f}`), "", "These differ from what would be written. Yes replaces them with the packaged version; No keeps your copies (the record is still written, and /recipe update merges later)."].join("\n"));
 		}
 		const setupText = m.setup ? fs.readFileSync(path.join(recipe.dir, m.setup), "utf8") : undefined;
 		// The confirmation is the only gate before `sh <script>` runs with this session's
@@ -2047,7 +2735,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		}
 		const lines: string[] = [];
 		const record = installFiles(recipe, project, level, { overwrite, source: resolved.source });
-		lines.push(`  ${record.files.length} file(s) → ${homeRel(plan.targetDir)}/`);
+		lines.push(`  ${plural(record.files.length, "file")} → ${homeRel(plan.targetDir)}/`);
 		const excluded = ensureExcluded(project, path.join(INSTALL_ROOT, m.name));
 		// The tracker description names an account and a workflow; it is the project's to keep, not
 		// the repository's to publish — so it stays out of history the same way the playbooks do.
@@ -2062,13 +2750,20 @@ export default function piLoops(pi: ExtensionAPI) {
 			}
 			lines.push(`  ${m.setup}: ok`, ...out);
 		}
+		// A conversation pi has not saved yet (a starter's Add in a new page conversation) cannot own a loop.
+		const owner = installScope(ctx.sessionManager.getSessionFile());
+		if (owner.projectOwned) lines.push("  the loops belong to this project: this conversation is not saved yet, so a finding runs in the conversation you claim it from");
 		for (const line of plan.addLines) {
 			const parsed = parseAddArgs(line);
-			const job = await createJob({ schedule: parsed.schedule, prompt: parsed.prompt, stateful: parsed.stateful, name: parsed.name, model: parsed.model, thinking: parsed.thinking, tools: parsed.tools, timeoutMs: parsed.timeoutMs, catchUp: parsed.catchUp, verify: parsed.verify, checkerModel: parsed.checkerModel, recipe: m.name });
+			const job = await createJob({ schedule: parsed.schedule, prompt: parsed.prompt, stateful: parsed.stateful, name: parsed.name, model: parsed.model, thinking: parsed.thinking, tools: parsed.tools, timeoutMs: parsed.timeoutMs, catchUp: parsed.catchUp, verify: parsed.verify, checkerModel: parsed.checkerModel, recipe: m.name }, owner);
 			cronControlAudit("add", "slash", undefined, job);
 			const next = computeNext({ schedule: job.schedule, createdAt: Date.parse(job.createdAt) }, Date.now());
-			lines.push(`  job ${job.name}: ${formatSchedule(job.schedule)}${next ? ` (next run ${formatLocal(next)})` : ""}`);
+			lines.push(`  job ${job.name}: ${formatSchedule(job.schedule)}${next ? ` (next run ${formatLocal(next)})` : ""}${job.stateful ? "" : " · runs in this chat, and in the background while it is closed (each run a model turn)"}`);
+			const dropped = toolsDropped(parsed.tools, job.tools);
+			if (dropped.length) lines.push(`    dropped from its tools: ${dropped.join(", ")} (this chat does not have it)`);
 		}
+		// What every loop here takes to the background, said once for the recipe rather than per job.
+		lines.push("", `  loops run in the background with this chat's built-in tools (${(session.builtinTools ?? []).join(", ") || "none"}), not this window's -e extensions or flags${projectNeedsTrust(session.cwd) && !isExactlyTrusted(getAgentDir(), session.cwd) ? "; this project's own settings and servers only once /trust saves trust for it" : ""}`);
 		lines.push("", `  edit the playbooks in ${path.join(INSTALL_ROOT, m.name)}/ — a run reads them fresh every time; /cron run <job> tries one now`);
 		show(ctx, `installed recipe ${m.name} (${level})`, lines);
 		refreshBadge();
@@ -2099,7 +2794,7 @@ export default function piLoops(pi: ExtensionAPI) {
 						const line = (r: Recipe) => {
 							const rec = installed.get(r.manifest.name);
 							const n = jobs.filter((j) => j.recipe === r.manifest.name).length;
-							return `  ${r.manifest.name.padEnd(17)} ${(rec ? `installed: ${rec.level}, ${n} job(s)` : "—").padEnd(28)} ${r.manifest.summary}`;
+							return `  ${r.manifest.name.padEnd(17)} ${rec ? `[installed: ${rec.level}, ${plural(n, "loop")}] ` : ""}${r.manifest.line ?? r.manifest.summary}`;
 						};
 						// Starters first: they read and file findings, and are the ones to install before
 						// anything that writes to a tracker or opens a pull request.
@@ -2107,7 +2802,7 @@ export default function piLoops(pi: ExtensionAPI) {
 						for (const tier of RECIPE_TIERS) {
 							const group = packaged.filter((r) => r.manifest.tier === tier);
 							if (!group.length) continue;
-							lines.push(tier === "starter" ? "  starter — reads, and files findings; install one of these first:" : "  advanced — writes to a worktree, a tracker or a pull request; read the playbooks first:");
+							lines.push(tier === "starter" ? "  starter" : "  advanced — writes to a worktree, a tracker or a pull request");
 							lines.push(...group.map(line));
 						}
 						for (const rec of installed.values()) {
@@ -2167,14 +2862,16 @@ export default function piLoops(pi: ExtensionAPI) {
 						}
 						const recipe = loadRecipe(path.isAbsolute(record.source) ? record.source : resolveRecipeRef(record.source, { cwd: project }).dir);
 						const result = updateFiles(recipe, project, record.level);
+						// Queued first, so the line says what became of it: an earlier conflict hand-off of this
+						// recipe still waiting collapses this one, and "handed to the agent" would then be false.
+						const conflicts = result.conflicts.length ? await handOver(recipeRow(mergeConflictPrompt(name, dir, result.conflicts), name, "merge", rowAddress())) : undefined;
 						const lines = [
 							...(result.updated.length ? [`  updated: ${result.updated.join(", ")}`] : []),
 							...(result.unchanged.length ? [`  unchanged: ${result.unchanged.join(", ")}`] : []),
 							...(result.noBase.length ? [`  left alone (no .orig to merge against): ${result.noBase.join(", ")}`] : []),
-							...(result.conflicts.length ? [`  conflicts, not written: ${result.conflicts.map((c) => c.file).join(", ")} — handed to the agent to resolve with you`] : []),
+							...(conflicts ? [`  conflicts, not written: ${result.conflicts.map((c) => c.file).join(", ")} — ${conflicts.written ? "handed to the agent to resolve with you" : "the agent is already queued to resolve this recipe's conflicts with you"}`] : []),
 						];
 						show(ctx, `recipe ${name}: merged pi-loops ${PI_LOOPS_VERSION} playbooks into ${homeRel(dir)}/`, lines);
-						if (result.conflicts.length) pi.sendUserMessage(mergeConflictPrompt(name, dir, result.conflicts), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
 						return;
 					}
 					case "remove":
@@ -2195,8 +2892,8 @@ export default function piLoops(pi: ExtensionAPI) {
 							return;
 						}
 						const ok = await ctx.ui.confirm(`Remove recipe ${name}?`, [
-							jobs.length ? `${jobs.length} job(s): ${jobs.map((j) => j.name ?? j.id).join(", ")}` : "no jobs of its own here",
-							purge ? `and delete what the install wrote in ${homeRel(dir)}/ (${record ? `${record.files.length} file(s) as installed — an edited one is kept — their untouched copies, the record` : "no record: only the directory if it is empty"}) and the loops' notes` : `the files in ${homeRel(dir)}/ and the loops' notes are kept (--purge deletes both)`,
+							jobs.length ? `${plural(jobs.length, "loop")}: ${jobs.map((j) => j.name ?? j.id).join(", ")}` : "no loops of its own here",
+							purge ? `and delete what the install wrote in ${homeRel(dir)}/ (${record ? `${plural(record.files.length, "file")} as installed — an edited one is kept — their untouched copies, the record` : "no record: only the directory if it is empty"}) and the loops' notes` : `the files in ${homeRel(dir)}/ and the loops' notes are kept (--purge deletes both)`,
 						].join("\n"));
 						if (!ok) {
 							ctx.ui.notify("not removed", "info");
@@ -2212,7 +2909,7 @@ export default function piLoops(pi: ExtensionAPI) {
 						if (purge) {
 							if (record) {
 								const { kept } = purgeInstall(dir, record, listRecipes().find((r) => r.manifest.name === name)?.manifest.setup);
-								if (kept.length > 0) keptNote = `; kept ${kept.length} edited file(s): ${kept.join(", ")}`;
+								if (kept.length > 0) keptNote = `; kept ${plural(kept.length, "edited file")}: ${kept.join(", ")}`;
 							} else {
 								try {
 									fs.rmdirSync(dir);
@@ -2223,7 +2920,7 @@ export default function piLoops(pi: ExtensionAPI) {
 						}
 						refreshBadge();
 						ctx.ui.notify(
-							`removed recipe ${name}: ${jobs.length} job(s)${purge ? ", its files and notes" : `; files kept in ${homeRel(dir)}/`}${aborted > 0 ? `; aborted ${aborted} running run(s)` : ""}${keptNote}`,
+							`removed recipe ${name}: ${plural(jobs.length, "loop")}${purge ? ", its files and notes" : `; files kept in ${homeRel(dir)}/`}${aborted > 0 ? `; aborted ${plural(aborted, "running run")}` : ""}${keptNote}`,
 							"info",
 						);
 						return;
@@ -2256,7 +2953,7 @@ export default function piLoops(pi: ExtensionAPI) {
 			}
 			let messages: ShareMessage[];
 			try {
-				messages = (ctx.sessionManager.buildContextEntries() as Array<{ message?: ShareMessage }>).map((e) => e.message).filter((m): m is ShareMessage => !!m);
+				messages = shareableMessages(ctx.sessionManager.buildContextEntries() as Array<{ type?: string; message?: ShareMessage }>);
 			} catch (err: any) {
 				ctx.ui.notify(`share: cannot read this session: ${err?.message ?? err}`, "error");
 				return;
@@ -2403,7 +3100,7 @@ export default function piLoops(pi: ExtensionAPI) {
 				const enabled = await offerToEnable(imp, store, triggers.store, mode === "ask" && ctx.hasUI ? (question, detail) => ctx.ui.confirm(question, detail) : undefined, (before, after) => cronControlAudit("enable", "slash", before, after));
 				if (enabled.jobs || enabled.rules) {
 					refreshBadge();
-					ctx.ui.notify(`enabled ${enabled.jobs} cron job(s) and ${enabled.rules} trigger rule(s)`, "info");
+					ctx.ui.notify(`enabled ${plural(enabled.jobs, "loop")} and ${plural(enabled.rules, "rule")}`, "info");
 				}
 				if (resume) await ctx.switchSession(imp.sessionPath);
 			} catch (err: any) {
@@ -2421,9 +3118,9 @@ export default function piLoops(pi: ExtensionAPI) {
 				return;
 			}
 			const prompt =
-				"The user asked pi to create a dynamic trigger. Extract the trigger condition and action from the request, then call new_trigger with structured condition and action fields. Dynamic triggers fire once by default; set fire_once=false only when the user explicitly asks for a repeating trigger. Trigger output is shown in the TUI and audit by default; set promote_to_chat=true only when the user explicitly asks for trigger results to enter the main chat context or be visible to future turns. Do not require a fixed syntax. If either the condition or action is missing, ask one concise clarification question instead of calling tools.\n\nUser request:\n" +
+				"The user asked pi to create a dynamic trigger. Extract the trigger condition and action from the request, then call new_trigger with structured condition and action fields. Dynamic triggers fire once by default; set fire_once=false only when the user explicitly asks for a repeating trigger. Do not require a fixed syntax. If either the condition or action is missing, ask one concise clarification question instead of calling tools.\n\nUser request:\n" +
 				args.trim();
-			pi.sendUserMessage(prompt, ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+			await handOver(newTriggerRow(prompt, rowAddress()));
 		},
 	});
 
@@ -2449,11 +3146,22 @@ export default function piLoops(pi: ExtensionAPI) {
 	const toolHost: ToolHost = {
 		scheduler,
 		triggers,
-		session: () => session,
+		// In a scheduled turn the chat is the row's declared tools, not this window's: a job made
+		// there gets no more built-ins than the turn, as a job a background run makes gets that run's.
+		session: () => {
+			const current = executor.currentTurn();
+			if (!unattendedTurn(current)) return session;
+			const capped = current.builtinTools ?? current.tools?.filter((t) => PI_BUILTIN_TOOL_NAMES.includes(t));
+			return capped ? { ...session, builtinTools: [...capped] } : session;
+		},
 		createJob: (input, scope) => createLoopJob(toolHost, input, scope),
 		cronControlAudit,
 		confirmTool,
 		refreshBadge,
+		// A runtime that never sends session_start still gets its host this way (cron_create, new_trigger).
+		ensureHost: () => void hostTick(false).catch((err: any) => log.info(`host: ${err?.message ?? err}`)),
+		// The create tools ask only in the person's own turn: a scheduled turn keeps the window guard's gate.
+		scheduledTurn: () => unattendedTurn(executor.currentTurn()),
 	};
 	/** The same host, bound to one sub-agent run: its project and its model, not this chat's. */
 	function toolHostFor(req: Pick<SubagentRequest, "cwd" | "model" | "thinking">): ToolHost {
@@ -2466,7 +3174,8 @@ export default function piLoops(pi: ExtensionAPI) {
 	}
 	/**
 	 * Trigger creation/removal and trigger/cron enable need a person's yes: pi has no permission
-	 * popups, so the tool asks through `ctx.ui.confirm` itself. A sub-agent has no UI, so
+	 * popups, so the tool asks itself, through `ctx.ui.confirm` in the person's own turn and through
+	 * the window guard's refuse-first `ctx.ui.select` in a scheduled one. A sub-agent has no UI, so
 	 * `controlPlanePreflight` denies fail-closed (`ToolCallEventResult`).
 	 */
 	async function confirmTool(ctx: ExtensionContext, req: ControlPlaneRequest, atHop: number): Promise<string | undefined> {
@@ -2475,16 +3184,23 @@ export default function piLoops(pi: ExtensionAPI) {
 		// The approval card: Action / Tool / Reason / Args hash / Preview, then a feed line per decision.
 		const argsHash = createHash("sha256").update(JSON.stringify(req.args ?? null)).digest("hex").slice(0, 12);
 		ctx.ui.notify(`approval required: ${req.label}`, "info");
-		const ok = await ctx.ui.confirm("Control-plane approval required", [`Action: ${req.label}`, `Tool: ${req.tool}`, `Reason: ${req.reason}`, `Args hash: ${argsHash}`, `Preview: ${previewRedacted(req.preview, 200)}`].join("\n"));
-		ctx.ui.notify(ok ? `approved control-plane action: ${req.label}` : `denied control-plane action: ${req.label} (denied by user)`, "info");
-		return ok ? undefined : `user declined: ${req.label}`;
+		const card = [`Action: ${req.label}`, `Tool: ${req.tool}`, `Reason: ${req.reason}`, `Args hash: ${argsHash}`, `Preview: ${previewRedacted(req.preview, 200)}`].join("\n");
+		// In a scheduled turn the question is the window guard's (design §6.3): its minute and no more,
+		// since nobody may be there, and the refusing answer focused, so a reflexive Enter refuses.
+		const scheduled = unattendedTurn(executor.currentTurn());
+		const answer: GuardAnswer = scheduled ? await askRefusingFirst(ctx, "Control-plane approval required", card, WINDOW_GUARD_CONFIRM_MS) : (await ctx.ui.confirm("Control-plane approval required", card)) ? "yes" : "no";
+		ctx.ui.notify(answer === "yes" ? `approved control-plane action: ${req.label}` : `denied control-plane action: ${req.label} (${answer === "no" ? "denied by user" : "not answered in time"})`, "info");
+		return answer === "yes" ? undefined : answer === "no" ? `user declined: ${req.label}` : `nobody answered in time: ${req.label}`;
 	}
 	for (const def of automationTools({ hop, actor: "tool" }, toolHost)) pi.registerTool(def);
+	// The cap on a scheduled turn's calls while this window runs it (src/window-guard.ts): the
+	// decision is there, this only hands it what pi is in and what config.toml says.
+	pi.on("tool_call", windowGuard({ current: () => executor.currentTurn(), config: () => ({ windowGuard: config.windowGuard, allowCommands: config.allowCommands }), log: (line) => log.info(line) }));
 
 	/* -------------------------------------------------------- lifecycle */
 
 	/**
-	 * The `pi-loops` command, kept on the PATH of whoever asked for it there.
+	 * The `pi-loops` command, put on the PATH and kept working there.
 	 *
 	 * `pi install` puts this package under pi's directory and nothing on the PATH, so until 0.22.1
 	 * the first thing a new user had to do was type a bare `node …/cli-entry.mjs install-launcher`
@@ -2493,114 +3209,259 @@ export default function piLoops(pi: ExtensionAPI) {
 	 * it runs and where a launcher would go, so the step belongs here.
 	 *
 	 * This is the extension's only write outside the loops directory (AGENTS.md). Its limit is one
-	 * file, `pi-loops` in a directory already on the PATH, and only where a launcher of ours already
-	 * is or after a yes. A file with no marker of ours is somebody's own wrapper and is left alone;
-	 * one naming another copy of this package that is still on disk is that copy's to keep current,
-	 * so an install and a checkout both being opened never trade the file back and forth; a no is
-	 * remembered in `ui.json`, so it is asked once rather than in every window; and a checkout is
-	 * never asked for a launcher that is not there at all — nobody ran `pi install`, so nothing is
-	 * missing from their PATH — though one written from a checkout is still kept working.
+	 * file, `pi-loops` in a directory already on the PATH. With nothing there, the first interactive
+	 * session of a copy `pi install` put in place writes it with no question and says so in one line,
+	 * as pi's own installer does for `pi` (#180); after that only a launcher of ours is rewritten. A
+	 * file that does not open with our header is somebody's own wrapper and is left alone; one naming another
+	 * copy of this package that is still on disk is that copy's to keep current, so an install and a
+	 * checkout both being opened never trade the file back and forth; `uninstall-launcher` is
+	 * remembered in `ui.json`, so no later session writes it again; a write that failed is
+	 * remembered with its directory, so it is not tried in every window; and a checkout never writes
+	 * a launcher that is not there at all — nobody ran `pi install`, so nothing is missing from their
+	 * PATH — though one written from a checkout is still kept working. The decision is
+	 * `launcherAction` in src/cli.ts.
 	 */
 	async function keepLauncher(ctx: ExtensionContext): Promise<void> {
 		const { entryDir, node, agentDir } = launcherSource();
 		const target = launcherTarget(undefined);
-		// Nothing on the PATH to write into. `/pi-loops install-launcher`, run by hand, is where that
-		// is explained; a session start saying it unprompted would be a warning about nothing.
-		if (!target) return;
-		const { state } = launcherState(entryDir, node, agentDir, target);
-		if (state === "stale") {
+		const prefs = readUiPrefs(dir);
+		const state = target ? launcherState(entryDir, node, agentDir, target).state : undefined;
+		const action = launcherAction({ target, state, hasUI: ctx.hasUI, declined: prefs.launcher === "declined", failedIn: prefs.launcher === "failed" ? prefs.launcherFailedIn : undefined, installedByPi: state === "absent" && installedByPi() });
+		if (!target || action === "none") return;
+		if (action === "refresh") {
 			const done = refreshLauncher(entryDir, node, agentDir, target);
 			if (!done) return;
 			log.info(`launcher: ${done.message}`);
-			// No question: they asked for a launcher once, and keeping that one working is what they
-			// asked for. The line is so that a file changing under them is never a silent change.
+			// They have a launcher of ours, and keeping that one working is what it is for. The line is
+			// so that a file changing under them is never a silent change.
 			if (ctx.hasUI) ctx.ui.notify(`[pi-loops] ${done.message}`, done.ok ? "info" : "warning");
 			return;
 		}
-		if (state !== "absent") return; // ours and current, another copy's, or somebody else's entirely
-		if (!ctx.hasUI || readUiPrefs(dir).launcher === "declined" || !installedByPi()) return;
-		const lines: string[] = [];
-		const code = await installLauncherWithConfirm([], (title, body) => ctx.ui.confirm(title, body), (l) => lines.push(l));
-		if (code === undefined) {
-			writeUiPref(dir, "launcher", "declined");
-			ctx.ui.notify("[pi-loops] not installed — `/pi-loops install-launcher` writes one whenever you want it", "info");
+		const added = addLauncher(entryDir, node, agentDir, target);
+		if (added.kind === "none") return;
+		if (added.kind === "added") {
+			// A failed write into another directory is not news any more.
+			clearUiPref(dir, "launcher");
+			clearUiPref(dir, "launcherFailedIn");
+			log.info(`launcher: wrote ${added.file}`);
+			ctx.ui.notify(`[pi-loops] added pi-loops to ${homeRel(target)}; /pi-loops uninstall-launcher removes it`, "info");
 			return;
 		}
-		ctx.ui.notify(`[pi-loops] ${lines.map((l) => l.trim()).join(" · ")}`, code === 0 ? "info" : "warning");
+		writeUiPref(dir, "launcher", "failed");
+		writeUiPref(dir, "launcherFailedIn", target);
+		ctx.ui.notify(`[pi-loops] ${added.message}; /pi-loops install-launcher --dir <dir> writes it elsewhere`, "warning");
+	}
+
+	/**
+	 * Run `say` once pi has drawn the session's history. pi draws a resumed conversation after
+	 * `session_start` returns, and keeps only what fits the screen: a line said before that was cut
+	 * from any conversation longer than a screen.
+	 */
+	function afterHistory(ctx: ExtensionContext, say: () => void): void {
+		if (ctx.mode !== "tui") return say();
+		// pi hands each event a new context object, so the session is told apart by a count instead.
+		const generation = sessionGeneration;
+		setTimeout(() => {
+			if (generation === sessionGeneration) say();
+		}, 1000).unref();
+	}
+	/** Bumped at every session_shutdown: a line meant for the session that left is not said in the next. */
+	let sessionGeneration = 0;
+
+	/**
+	 * The info lines a session start says, gathered into one notice. pi shows back-to-back info
+	 * notices on one line, each replacing the one before, so said one by one only the last was seen.
+	 * `startShown` runs once that notice is on the screen.
+	 */
+	let startLines: string[] | undefined;
+	let startShown: (() => void)[] = [];
+	/** What the window left behind on `/new` or `/resume` (src/job-lines.ts leftConversationLine), said at the next session's start, where pi draws again. */
+	let leftLine: string | undefined;
+	function sayInfo(line: string): void {
+		if (startLines) startLines.push(line);
+		else if (lastCtx?.hasUI) lastCtx.ui.notify(line, "info");
+	}
+	function flushStartLines(ctx: ExtensionContext): void {
+		const lines = startLines ?? [];
+		const shown = startShown;
+		startLines = undefined;
+		startShown = [];
+		if (!lines.length || !ctx.hasUI) return;
+		afterHistory(ctx, () => {
+			ctx.ui.notify(lines.join("\n"), "info");
+			for (const done of shown) done();
+		});
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
 		lastCtx = ctx;
 		if (startHandled) return; // the same start, delivered a second time by a second rebind
 		startHandled = true;
+		leaving = false;
 		session = sessionSnapshot(ctx);
-		config = loadConfig(dir);
-		// The goal lives in the session, so `--resume` picks up where it left off.
-		goal = latestGoal(ctx.sessionManager.getEntries() as any);
-		if (goal && ctx.hasUI) ctx.ui.setStatus(GOAL_STATUS_KEY, `goal: ${goal.status}`);
-		const flagRaw = pi.getFlag("trigger-poll-secs");
-		const flagSecs = Number(flagRaw);
-		if (flagRaw !== undefined && flagRaw !== "" && !(Number.isFinite(flagSecs) && flagSecs >= 1)) config.errors.push(`triggers: ignoring invalid --trigger-poll-secs ${JSON.stringify(flagRaw)}: must be a whole number of seconds ≥ 1`);
-		triggers.pollIntervalSecs = Number.isFinite(flagSecs) && flagSecs >= 1 ? Math.floor(flagSecs) : config.triggerPollIntervalSecs;
-		triggers.runTimeoutMs = config.triggerRunTimeoutMs;
-		// Without a UI, hook failures go to stderr instead of vanishing.
-		const warnHook = (message: string) => (ctx.hasUI ? ctx.ui.notify(`[hooks] ${message}`, "warning") : process.stderr.write(`[pi-loops hooks] ${message}\n`));
-		hookRunner = new HookRunner({ loopsDir: dir, projectCwd: ctx.cwd, allowProjectHooks: config.allowProjectHooks, getSession: () => session, warn: warnHook, log: (msg) => log.info(msg) });
-		hookRunner.load();
-		for (const e of [...config.errors, ...hookRunner.diagnostics]) if (ctx.hasUI) ctx.ui.notify(`[pi-loops] ${e}`, "warning");
-		loadMcpConfig(ctx.isProjectTrusted());
-		for (const d of mcpDiagnostics) if (ctx.hasUI) ctx.ui.notify(`[pi-loops] ${d}`, "warning");
-		await startMcpSources(); // tools for every process; pushes are consumed by interactive processes only
-		// Not awaited: the question below is a dialog, and the clock must not wait behind someone who
-		// has walked away from it.
-		void keepLauncher(ctx).catch((err: any) => log.info(`launcher: ${err?.message ?? err}`));
-		// tui and rpc processes stay alive and host the timer; `PI_LOOPS_HOST=1` lets a `pi -p`
-		// run (a long headless prompt) host it too.
-		const hostMode = ctx.mode === "tui" || ctx.mode === "rpc" || envFlag("LOOPS_HOST");
-		if (!hostMode) return;
-		// Take the clock back from the headless host, if one kept it while nothing was open; a record
-		// with no process behind it means the host died (it removes its record on a clean exit).
-		const dead = crashedHost(dir);
-		if (dead && ctx.hasUI) ctx.ui.notify(`[cron] the background host (pid ${dead.pid}, started ${formatLocal(Date.parse(dead.startedAt))}) died; see ${homeRel(path.join(dir, HOST_LOG))}`, "warning");
-		const hostPid = stopHost(dir);
-		if (hostPid && ctx.hasUI) ctx.ui.notify(`[cron] took the clock back from the background host (pid ${hostPid})`, "info");
-		scheduler.start();
-		schedulerStarted = true;
-		refreshBadge();
-		pruneLogs(dir);
-		// What was loaded is printed on every start; without a line here a session
-		// can begin with loops and rules the user has entirely forgotten about.
-		// "Active here" means it: a plain job of another session is asleep, not active.
-		const myJobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd) && j.enabled && runsIn(j, session.sessionId));
-		const myRules = triggers.store.load().filter((r) => sameProject(r.cwd, session.cwd) && r.enabled);
-		// What is scheduled says nothing about what is working: a loop that has failed every night
-		// since Tuesday is still counted as active, and this line is the only one a user reads.
-		const failing = failingSummary(myJobs);
-		log.info(`session start: ${myJobs.length} enabled loop(s), ${myRules.length} enabled rule(s)${failing ? `, ${failing}` : ""} in ${session.cwd}`);
-		if (ctx.hasUI && (myJobs.length || myRules.length)) {
-			const next = myJobs
-				.map((j) => computeNext({ schedule: j.schedule, createdAt: Date.parse(j.createdAt), lastFiredAt: j.lastFiredAt ? Date.parse(j.lastFiredAt) : undefined }, Date.now()))
-				.filter((n): n is number => n !== undefined)
-				.sort((a, b) => a - b)[0];
-			ctx.ui.notify(`[cron] ${myJobs.length} loop(s) and ${myRules.length} rule(s) active here${next ? ` · next ${formatLocal(next)}` : ""}${failing ? ` · ${failing} — /cron runs` : ""}`, "info");
+		startLines = [];
+		startShown = [];
+		try {
+			bindSession(ctx);
+			// A 0.22.x pi on the same conversation has no lease and fires its plain jobs regardless.
+			const older = olderPiOnSession(scheduler.presenceList(), session.sessionId, scheduler.self);
+			if (older && ctx.hasUI) ctx.ui.notify("[cron] this conversation is also open in a window with an older pi-loops; both windows may run its plain jobs — close or restart that window", "warning");
+			config = loadConfig(dir);
+			// The goal lives in the session, so `--resume` picks up where it left off.
+			goal = latestGoal(ctx.sessionManager.getEntries() as any);
+			if (goal && ctx.hasUI) ctx.ui.setStatus(GOAL_STATUS_KEY, `goal: ${goal.status}`);
+			// Rules are checked by the host, which reads config.toml and no window's flags: the flag is kept
+			// so a command line that passes it still starts, and says where the interval is set now.
+			const flagRaw = pi.getFlag("trigger-poll-secs");
+			if (flagRaw !== undefined && flagRaw !== "") config.errors.push(`triggers: --trigger-poll-secs is ignored: pi-loops checks rules every [triggers] poll_interval_secs in config.toml (now ${config.triggerPollIntervalSecs}s)`);
+			triggers.pollIntervalSecs = config.triggerPollIntervalSecs;
+			triggers.runTimeoutMs = config.triggerRunTimeoutMs;
+			// Without a UI, hook failures go to stderr instead of vanishing.
+			const warnHook = (message: string) => (ctx.hasUI ? ctx.ui.notify(`[hooks] ${message}`, "warning") : process.stderr.write(`[pi-loops hooks] ${message}\n`));
+			hookRunner = new HookRunner({ loopsDir: dir, projectCwd: ctx.cwd, allowProjectHooks: config.allowProjectHooks, getSession: () => session, warn: warnHook, log: (msg) => log.info(msg) });
+			hookRunner.load();
+			for (const e of [...config.errors, ...hookRunner.diagnostics]) if (ctx.hasUI) ctx.ui.notify(`[pi-loops] ${e}`, "warning");
+			loadMcpConfig(windowTrusted(getAgentDir(), ctx.cwd, ctx.isProjectTrusted(), APPROVED));
+			for (const d of mcpDiagnostics) if (ctx.hasUI) ctx.ui.notify(`[pi-loops] ${d}`, "warning");
+			await startMcpSources(); // tools for every process; pushes are consumed by interactive processes only
+			// A launcher that cannot be written or kept is logged, and never stops the session starting.
+			void keepLauncher(ctx).catch((err: any) => log.info(`launcher: ${err?.message ?? err}`));
+			// tui and rpc processes stay alive and run the clock; `PI_LOOPS_HOST=1` starts it in a `pi -p`
+			// run too, which queues its conversation's due prompts but hands none to pi (the window
+			// executor delivers only in tui and rpc mode): a window or pi-loops in the background does.
+			const hostMode = ctx.mode === "tui" || ctx.mode === "rpc" || envFlag("LOOPS_HOST");
+			if (!hostMode) return;
+			// The host runs the loops; this window only makes sure there is one. Not awaited: a start can
+			// take seconds, and the session must not wait behind it. A probe here never counts toward
+			// evicting a host that is still starting.
+			watchStore();
+			// The session-start line below says a pause already in place when this project has loops or rules;
+			// the tick does not say it a second time. Elsewhere the tick is what says it.
+			const saysPause = loadOrNone(() => scheduler.store.load()).some((j) => sameProject(j.cwd, session.cwd) && j.enabled && j.stateful) || loadOrNone(() => triggers.store.load()).some((r) => sameProject(r.cwd, session.cwd) && r.enabled);
+			shownPause = saysPause && hostHasWork() ? hostPauseReason() : undefined;
+			hostTick(false).catch((err: any) => log.info(`host: ${err?.message ?? err}`));
+			runsShownAfter = stamp();
+			scheduler.start();
+			schedulerStarted = true;
+			refreshBadge();
+			pruneLogs(dir);
+			// What was loaded is printed on every start; without a line here a session
+			// can begin with loops and rules the user has entirely forgotten about.
+			// "Active here" means it: a plain job of another session is asleep, not active.
+			const myJobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd) && j.enabled && runsHere(j, scheduler.ownerView()));
+			const myRules = loadOrNone(() => triggers.store.load()).filter((r) => sameProject(r.cwd, session.cwd) && r.enabled);
+			// What is scheduled says nothing about what is working: a loop that has failed every night
+			// since Tuesday is still counted as active, and this line is the only one a user reads.
+			const failing = failingSummary(myJobs);
+			log.info(`session start: ${myJobs.length} enabled loop(s), ${myRules.length} enabled rule(s)${failing ? `, ${failing}` : ""} in ${session.cwd}`);
+			{
+				const line = awayLine(awayHere());
+				// After pi has drawn the resumed history: said now, a long conversation pushed it off the screen.
+				if (line) sayInfo(line);
+			}
+			// Said once, the first time this version starts: plain jobs used to sleep while their conversation
+			// was closed, and closing it was how people stopped one. Now the host runs them, and they cost turns.
+			if (ctx.hasUI && readUiPrefs(dir).heldJobsNotice !== "shown") {
+				// Every conversation's plain jobs (src/job-lines.ts heldJobsNotice): one an older pi-loops last
+				// had open runs in the background too, once it has been opened here; a count of what runs
+				// right now was spent on the first start and said nothing about the rest.
+				const line = heldJobsNotice(scheduler.store.load());
+				if (line) {
+					sayInfo(line);
+					// Marked only once it is on the screen: a notice used up unseen is never said again.
+					startShown.push(() => writeUiPref(dir, "heldJobsNotice", "shown"));
+				}
+			}
+			if (ctx.hasUI && readUiPrefs(dir).toolsCapNotice !== "shown") {
+				// A 0.22 plain job's `--tools` was never used; now it caps the job's turns (docs/loops.md).
+				const line = toolsCapNotice(scheduler.store.load());
+				if (line) {
+					sayInfo(line);
+					startShown.push(() => writeUiPref(dir, "toolsCapNotice", "shown"));
+				}
+			}
+			if (leftLine) {
+				sayInfo(leftLine);
+				leftLine = undefined;
+			}
+			const pausedLoops = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd) && j.enabled && j.stateful).length;
+			const pauseReason = hostPauseReason();
+			if (ctx.hasUI && pauseReason && (pausedLoops || myRules.length)) {
+				afterHistory(ctx, () => ctx.ui.notify(`[cron] ${plural(pausedLoops, "loop")} and ${plural(myRules.length, "rule")} here are paused: ${pauseReason}`, "warning"));
+			} else if (ctx.hasUI && (myJobs.length || myRules.length)) {
+				const next = myJobs
+					.map((j) => computeNext({ schedule: j.schedule, createdAt: Date.parse(j.createdAt), lastFiredAt: j.lastFiredAt ? Date.parse(j.lastFiredAt) : undefined }, Date.now()))
+					.filter((n): n is number => n !== undefined)
+					.sort((a, b) => a - b)[0];
+				const active = `[cron] ${plural(myJobs.length, "loop")} and ${plural(myRules.length, "rule")} active here${next ? ` · next ${formatLocal(next)}` : ""}${failing ? ` · ${failing} — /cron runs` : ""}`;
+				sayInfo(active);
+			}
+		} finally {
+			flushStartLines(ctx);
 		}
 	});
 
+	/** Only the page's pi says on its lease that a turn runs: a terminal takes a conversation from it between turns, never in one. */
+	let turnMarks: TurnMarks = {};
+	function markTurn(event: keyof typeof TURN_EVENTS): void {
+		// The page child, for a terminal's takeover (src/lease.ts decideAcquire); a terminal, for the
+		// page that views its conversation and reads it again when the turn ends (shouldReadAgain).
+		if (!pageChild && leaseMode !== "tui") return;
+		const was = turnSinceOf(turnMarks);
+		turnMarks = markTurnEvent(turnMarks, event, stamp());
+		const since = turnSinceOf(turnMarks);
+		if (since === was) return;
+		try {
+			binding.setTurn(since);
+		} catch (err: any) {
+			log.info(`lease: ${err?.message ?? err}`);
+		}
+	}
+
 	// hooks.toml events, mapped from pi's lifecycle events.
-	pi.on("agent_start", async (_e, ctx) => fireHook({ event: "agent_start" }, ctx));
+	pi.on("agent_start", async (_e, ctx) => {
+		bindSession(ctx);
+		markTurn("agent_start");
+		executor.agentStarted(Date.now());
+		await fireHook({ event: "agent_start" }, ctx);
+	});
+	// Observed only: the person typing is what makes the next user message theirs (the cap). Our own
+	// hand-overs arrive here too, as `source: "extension"`; either says pi is about to run something,
+	// so nothing handed over is judged refused for a while yet.
+	pi.on("input", async (e) => {
+		executor.inputSeen(Date.now());
+		if (e.source !== "extension") executor.personInput();
+	});
 	pi.on("turn_start", async (_e, ctx) => fireHook({ event: "turn_start" }, ctx));
 	pi.on("turn_end", async (e, ctx) => fireHook({ event: "turn_end", message_kind: messageKind(e.message), message_summary: messageSummary(e.message) }, ctx));
-	pi.on("message_start", async (e, ctx) => fireHook({ event: "message_start", message_kind: messageKind(e.message), message_summary: messageSummary(e.message) }, ctx));
+	pi.on("message_start", async (e, ctx) => {
+		executor.messageStarted(e.message);
+		await fireHook({ event: "message_start", message_kind: messageKind(e.message), message_summary: messageSummary(e.message) }, ctx);
+	});
 	pi.on("message_update", async (e, ctx) => fireHook({ event: "message_update", message_kind: messageKind(e.message), message_summary: messageSummary(e.message), assistant_event: (e.assistantMessageEvent as any)?.type }, ctx));
-	pi.on("message_end", async (e, ctx) => fireHook({ event: "message_end", message_kind: messageKind(e.message), message_summary: messageSummary(e.message) }, ctx));
+	pi.on("message_end", async (e, ctx) => {
+		// pi appends the user message once this handler returns: a drain right after finds a person
+		// row's proof in the conversation, and the page's queue stops listing a message that is running.
+		if ((e.message as { role?: unknown } | undefined)?.role === "user" && executor.handedOver.size) setImmediate(() => void drainRequests().catch((err: any) => log.info(`requests: ${err?.message ?? err}`)));
+		await fireHook({ event: "message_end", message_kind: messageKind(e.message), message_summary: messageSummary(e.message) }, ctx);
+	});
 	pi.on("tool_execution_start", async (e, ctx) => fireHook({ event: "tool_start", tool_call_id: e.toolCallId, tool_name: e.toolName, tool_args: e.args }, ctx));
 	pi.on("tool_execution_update", async (e, ctx) => fireHook({ event: "tool_update", tool_call_id: e.toolCallId, tool_name: e.toolName, tool_args: e.args, tool_result_summary: resultSummary(e.partialResult) }, ctx));
 	pi.on("tool_execution_end", async (e: any, ctx) => fireHook({ event: "tool_end", tool_call_id: e.toolCallId, tool_name: e.toolName, tool_is_error: !!e.isError, tool_result_summary: resultSummary(e.result) }, ctx));
-	pi.on("session_compact", async (e, ctx) => fireHook({ event: "compaction", compaction_trigger: e.reason === "manual" ? "manual" : "auto", compaction_tokens_before: e.compactionEntry?.tokensBefore, compaction_summary: e.compactionEntry?.summary ? truncateSummary(e.compactionEntry.summary) : undefined }, ctx));
+	pi.on("session_before_compact", async () => {
+		markTurn("session_before_compact");
+	});
+	pi.on("session_compact", async (e, ctx) => {
+		markTurn("session_compact");
+		await fireHook({ event: "compaction", compaction_trigger: e.reason === "manual" ? "manual" : "auto", compaction_tokens_before: e.compactionEntry?.tokensBefore, compaction_summary: e.compactionEntry?.summary ? truncateSummary(e.compactionEntry.summary) : undefined }, ctx);
+	});
 	// A compaction that failed or was cancelled is the same news to a watcher, and the more urgent
 	// half of it: a session that cannot compact is a session about to fail on context length. It
 	// carries no summary and no token count — nothing was written — only the flag saying so.
-	pi.on("session_compact_failed", async (e, ctx) => fireHook({ event: "compaction", compaction_trigger: e.reason === "manual" ? "manual" : "auto", compaction_failed: true }, ctx));
+	pi.on("session_compact_failed", async (e, ctx) => {
+		markTurn("session_compact_failed");
+		await fireHook({ event: "compaction", compaction_trigger: e.reason === "manual" ? "manual" : "auto", compaction_failed: true }, ctx);
+	});
 
 	pi.on("model_select", async (_event, ctx) => {
 		session = sessionSnapshot(ctx);
@@ -2613,8 +3474,10 @@ export default function piLoops(pi: ExtensionAPI) {
 		goalMessages = event.messages ?? [];
 		const last: any = (event.messages ?? []).at(-1);
 		lastTurnStopReason = typeof last?.stopReason === "string" ? last.stopReason : undefined;
+		executor.agentEnded();
 		if (lastTurnStopReason === "aborted") {
 			goalAbort?.abort();
+			goalSkippedTurn = false;
 			// Esc pauses the goal, not only this turn's judgement: the person said stop, and a goal
 			// that went on pursuing would send them back to work on their next message.
 			const stopped = goal && abortedTurn(goal);
@@ -2629,6 +3492,9 @@ export default function piLoops(pi: ExtensionAPI) {
 	// The goal is evaluated at the end of a turn; pi's hook for that is `agent_settled` — the point where
 	// no automatic retry, compaction or queued continuation will run, so a decision here is final.
 	pi.on("agent_settled", async (_event, ctx) => {
+		markTurn("agent_settled");
+		// pi is idle now: what it dropped is offered again by the drain below.
+		executor.settled();
 		// The tracker description `/recipe add` was waiting for: written during this turn, so the
 		// wizard picks up where it stopped — in the same project, with the same words.
 		if (pendingRecipeAdd && sameProject(pendingRecipeAdd.project, session.cwd) && fs.existsSync(path.join(pendingRecipeAdd.project, TRACKER_FILE))) {
@@ -2641,76 +3507,107 @@ export default function piLoops(pi: ExtensionAPI) {
 			}
 		}
 		lastCtx = ctx;
-		try {
-			await evaluateGoal(ctx);
-		} catch (err: any) {
-			if (ctx.hasUI) ctx.ui.notify(`[goal] ${err?.message ?? err}`, "warning");
-		}
+		// Judge the turn unless a continuation is already on its way, then drain (src/goal.ts settledTurn).
+		const sessionId = binding.here().sessionId;
+		const evaluate = async () => {
+			try {
+				const skipped = () => {
+					const was = goalSkippedTurn;
+					goalSkippedTurn = false;
+					return was;
+				};
+				return await judgeCaughtUp(() => evaluateGoal(ctx), skipped, () => ctx.isIdle());
+			} catch (err: any) {
+				if (ctx.hasUI) ctx.ui.notify(`[goal] ${err?.message ?? err}`, "warning");
+				return false;
+			}
+		};
+		await settledTurn(sessionId ? requests.list(sessionId) : [], executor.handedOver, delivered, evaluate, () => drainRequests().catch((err: any) => log.info(`requests: ${err?.message ?? err}`)));
 	});
 
-	/** Whether this quitting pi should hand the clock to a background host. May throw on a damaged store. */
-	function handOffDecision(here: string, wasStarted: boolean): ReturnType<typeof shouldHandOff> | undefined {
-		if (!wasStarted) return undefined;
-		const enabledRules = triggers.store.load().filter((r) => r.enabled).length;
-		return shouldHandOff({
-			auto: handsOffOnQuit(),
-			presence: scheduler.presenceList(),
-			selfPid: process.pid,
-			selfInstance: scheduler.self.instance,
-			hostName: here,
-			enabledLoops: scheduler.store.load().filter((j) => j.enabled && j.stateful).length,
-			enabledRules,
-			pushServers: hostPushWork(loadMcpConfigFiles({ dir, projectTrusted: false }).servers, enabledRules),
-			hostAlive: !!liveHost(dir),
-		});
-	}
-
 	pi.on("session_shutdown", async (event, ctx) => {
-		// The last interactive pi to quit hands the clock to a headless host (host.ts) so loops,
-		// trigger checks and MCP pushes keep running; the next pi to open takes it back.
+		sessionGeneration++;
+		leaving = true;
+		// Said on the way out, as it was when the last window handed loops on: closing the window does
+		// not stop them, and a person who just closed it is deciding whether they keep running. pi
+		// draws no notification while it quits, so the line goes to the terminal once pi has left it.
+		// A store that cannot be read must not cost the lease release and the stops below.
+		// This conversation's plain jobs too: closing it used to stop them, and now it does not. The
+		// line is worded at exit, once the background process has been started for them (below).
+		let mine = 0;
+		/** Set when this quit started pi-loops in the background and did not wait for it to register. */
+		let startedOnQuit = false;
+		if (event.reason === "quit") {
+			try {
+				// Only once pi has written the conversation's file: until then there is nothing to run them in.
+				const file = ctx.sessionManager.getSessionFile();
+				mine = file && fs.existsSync(file) ? scheduler.store.load().filter((j) => j.enabled && !j.stateful && j.sessionId === session.sessionId).length : 0;
+				const work = automationCounts();
+				const what = [work.loops || work.rules ? `${plural(work.loops, "loop")} and ${plural(work.rules, "rule")}` : "", mine ? `${plural(mine, "plain job")} of this conversation (each run a model turn)` : ""].filter(Boolean).join(", and ");
+				if (what && ctx.hasUI && ctx.mode === "tui") {
+					process.once("exit", () => {
+						const live = liveHostRecord();
+						const pause = hostPauseReason();
+						// `[host] auto = false`: with no other window open, pi-loops leaves with this one (0.22.8).
+						const lastWindow = !config.hostAuto && readUiPrefs(dir).host !== "started" && ![...openWindowPids(binding.store)].some((pid) => pid !== process.pid);
+						const line = lastWindow ? `${what} stop with this window ([host] auto = false); they run again once a pi window is open` : live ? `${what} keep running in the background; pi-loops stop ends them` : startedOnQuit ? `${what} keep running once pi-loops has started in the background; pi-loops stop ends them` : pause ? `${what} are paused: ${pause}` : `${what} run in the background once pi-loops is running: pi-loops start`;
+						process.stderr.write(`[pi-loops] ${line}\n`);
+					});
+				}
+			} catch (err: any) {
+				log.info(`quit line: ${err?.message ?? err}`);
+			}
+		}
+		// The host keeps running whatever this window does: nothing is handed off.
 		//
 		// `/new`, `/resume`, `/reload` and `/fork` replace the session inside the same process, and pi
 		// rebuilds the extension with it — so this scheduler must stop, or two would run at once.
 		// A run aborted by the swap gives its slot back (see `launch`), and the replacement session
 		// re-fires it on its first tick instead of losing it until the next due time.
 		startHandled = false;
-		const wasStarted = schedulerStarted;
 		if (schedulerStarted) {
 			schedulerStarted = false;
 			await triggers.stop();
 			await scheduler.stop();
 		}
-		// Decided after stop(): our own presence entry is gone. Two pis quitting together may both
-		// hand off; the extra host exits on its first tick — better than neither handing off.
-		if (event.reason !== "quit") {
-			await hookRunner?.drain(3000);
-			return; // the replacement session_start starts everything again
+		// The conversation is free for the next window (or, after /new, the next session here) at once.
+		requestWatch?.close();
+		requestWatch = undefined;
+		storeWatch?.close();
+		storeWatch = undefined;
+		clearTimeout(storeWatchTimer);
+		storeWatchTimer = undefined;
+		try {
+			leaveSession();
+		} catch (err: any) {
+			log.info(`requests: ${err?.message ?? err}`);
 		}
-		config = loadConfig(dir); // `[host] auto` may have been edited while this pi was open
-		const here = os.hostname();
-		// A damaged store must not abort the rest of shutdown: the hooks, the MCP pool and the MCP
-		// servers below all still have to be torn down, or their child processes outlive pi.
-		let handOff: ReturnType<typeof shouldHandOff> | undefined;
 		try {
-			handOff = handOffDecision(here, wasStarted);
+			binding.release();
 		} catch (err: any) {
-			process.stderr.write(`[pi-loops] could not decide on a background host: ${err?.message ?? err}\n`);
+			log.info(`lease release: ${err?.message ?? err}`);
 		}
-		if (handOff?.handOff) {
+		if (event.reason !== "quit") {
+			// Leaving by /new or /resume: in 0.22.8 that stopped the conversation's plain jobs, and now it
+			// does not. Said once the next session has drawn, since pi draws nothing during the swap.
 			try {
-				const pid = spawnHost({ dir, packageDir: PACKAGE_DIR, piPackage: piPackageDir(), model: session.model, thinking: session.thinking });
-				// Only claim the hand-off once the host has recorded itself: one that dies during
-				// module resolution would otherwise be announced as a success, with automation off.
-				const up = await waitForHost(dir, pid);
-				const note = up
-					? `[cron] handed the clock to a background host (pid ${pid}; ${handOff.reason}); /cron host stop ends it`
-					: `[cron] the background host (pid ${pid}) did not start; automation is not running — see ${homeRel(path.join(dir, HOST_LOG))}`;
-				log.write(up ? "info" : "error", note.replace("[cron] ", ""));
-				if (ctx.hasUI) ctx.ui.notify(note, up ? "info" : "warning");
-				else process.stderr.write(`${note}\n`);
+				// A reload keeps the conversation; new, resume and fork leave it.
+				const left = event.reason !== "reload" ? session.sessionId : undefined;
+				const plain = left ? scheduler.store.load().filter((j) => j.enabled && !j.stateful && j.sessionId === left).length : 0;
+				leftLine = left ? leftConversationLine(left, plain, config.hostAuto) : undefined;
 			} catch (err: any) {
-				process.stderr.write(`[pi-loops] could not start the background host: ${err?.message ?? err}\n`);
+				log.info(`left line: ${err?.message ?? err}`);
 			}
+			await hookRunner?.drain(3000);
+			return; // the replacement session_start starts everything again
+		}
+		// Closed now: its plain jobs are the background process's to run, and with no loop or rule on
+		// this machine nothing has started one yet. With `[host] auto = false` and this the last window,
+		// a process started now would only leave again.
+		// Started, not waited for: quitting has nothing to do with the answer, and the wait cost seconds.
+		if (mine && config.hostAuto) {
+			const out = await hostTick(false, false, false).catch((err: any) => void log.info(`host: ${err?.message ?? err}`));
+			startedOnQuit = out?.action.kind === "spawn" && !!out.pid && !out.error;
 		}
 		await hookRunner?.drain(3000);
 		await mcpPool.stopAll();