Gracefully protect live sessions during daemon updates

packages/coding-agent/CHANGELOG.md

@@ -2,7 +2,11 @@
 
 ## [Unreleased]
 
+- Changed automatic harness refinement to be enabled by default while keeping `autoRefine.enabled: false` as the opt-out.
 - Changed the new-chat splash to show only version, model, and cwd metadata and rotate among five example prompts.
+- Fixed daemon updates and stale-daemon takeovers preserving restorable live sessions while blocking volatile child-agent work.
+- Fixed non-numeric `autoRefine.turnInterval` and `autoRefine.cooldownMs` settings falling back to defaults instead of silently enabling a noisy auto-refine loop.
+- Fixed all session-resume entry points to share a searchable full-screen picker, stream results while loading, and support renaming ([ENG-4513](https://linear.app/primeintellect/issue/ENG-4513/resume-in-agents-view-is-broken)).
 
 ## [0.2.8] - 2026-07-09
 
@@ -14,9 +18,6 @@
 - Fixed the agents-view splash shifting when opening an agent session ([ENG-4517](https://linear.app/primeintellect/issue/ENG-4517)).
 - Changed `/model` to sort featured flagship models above a provider's long tail (with a numeric-aware alphabetical tiebreak), so the full Prime Inference catalog doesn't flood the picker.
 - Fixed selector prompts and choices filling their background through the terminal's right edge.
-- Changed automatic harness refinement to be enabled by default while keeping `autoRefine.enabled: false` as the opt-out.
-- Fixed non-numeric `autoRefine.turnInterval` and `autoRefine.cooldownMs` settings falling back to defaults instead of silently enabling a noisy auto-refine loop.
-- Fixed all session-resume entry points to share a searchable full-screen picker, stream results while loading, and support renaming ([ENG-4513](https://linear.app/primeintellect/issue/ENG-4513/resume-in-agents-view-is-broken)).
 
 ## [0.2.7] - 2026-07-08
 

packages/coding-agent/src/cli/daemon-launch.ts

@@ -9,7 +9,7 @@
 
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { appendRotatingLog, expandTildePath, getClientErrorLogPath, VERSION } from "../config.js";
 import { DaemonClient } from "../modes/daemon/daemon-client.js";
 import { DAEMON_PROTOCOL_VERSION } from "../modes/daemon/daemon-protocol.js";
@@ -35,6 +35,20 @@ function logDaemonLaunch(message: string): void {
 	appendRotatingLog(getClientErrorLogPath(), `[${new Date().toISOString()}] daemon-launch: ${message}`);
 }
 
+function reportDaemonLaunchRestoreWarnings(result: DaemonSessionRestoreResult): void {
+	if (result.failed.length === 0) {
+		return;
+	}
+	const message = `Warning: restored ${result.restored}/${result.total} daemon session(s), but ${result.failed.length} session(s) failed to reopen after daemon replacement.`;
+	logDaemonLaunch(message);
+	console.error(message);
+	for (const failure of result.failed) {
+		const detail = `  ${failure.sessionFile}: ${failure.error}`;
+		logDaemonLaunch(detail);
+		console.error(detail);
+	}
+}
+
 async function canConnectToDaemon(socketPath: string, timeoutMs: number): Promise<boolean> {
 	const client = new DaemonClient(socketPath);
 	try {
@@ -132,12 +146,23 @@ export async function shutdownDaemonAndWait(socketPath: string): Promise<boolean
 }
 
 // activeSessions is undefined when the daemon is reachable but its sessions couldn't
-// be listed — callers must treat that as "possibly busy", not idle.
+// be listed — callers must treat that as "possibly active", not idle.
 export type RunningDaemonProbe = { reachable: false } | { reachable: true; activeSessions?: SessionSummary[] };
 
-export function isSessionBusy(summary: SessionSummary): boolean {
-	// pendingMessageCount covers queued steering/follow-ups, which live only in
-	// memory and would be lost if the daemon were stopped.
+export interface DaemonSessionRestoreFailure {
+	sessionFile: string;
+	error: string;
+}
+
+export interface DaemonSessionRestoreResult {
+	restored: number;
+	total: number;
+	failed: DaemonSessionRestoreFailure[];
+}
+
+export function hasSessionVolatileWorkForDaemonStop(summary: SessionSummary): boolean {
+	// These states live in daemon memory and cannot be reconstructed by reopening
+	// the JSONL session file after the daemon restarts.
 	return (
 		summary.isStreaming ||
 		summary.isCompacting ||
@@ -147,6 +172,88 @@ export function isSessionBusy(summary: SessionSummary): boolean {
 	);
 }
 
+export function isSessionReopenableAfterDaemonStop(summary: SessionSummary): boolean {
+	return (
+		summary.activeSessionId !== undefined && summary.runtimeKind !== "subagent" && summary.sessionFile !== undefined
+	);
+}
+
+export function isSessionRestorableAfterDaemonStop(summary: SessionSummary): boolean {
+	return isSessionReopenableAfterDaemonStop(summary) && !hasSessionVolatileWorkForDaemonStop(summary);
+}
+
+export function isSessionBusy(summary: SessionSummary): boolean {
+	return hasSessionVolatileWorkForDaemonStop(summary);
+}
+
+export function isSessionAtRiskFromDaemonStop(summary: SessionSummary): boolean {
+	if (summary.activeSessionId === undefined) {
+		return hasSessionVolatileWorkForDaemonStop(summary);
+	}
+	return !isSessionRestorableAfterDaemonStop(summary);
+}
+
+export function isRunningDaemonProbeAtRiskFromStop(probe: RunningDaemonProbe): boolean {
+	if (!probe.reachable) {
+		return false;
+	}
+	return probe.activeSessions === undefined || probe.activeSessions.some(isSessionAtRiskFromDaemonStop);
+}
+
+function restoreCandidateSessionFiles(sessions: readonly SessionSummary[]): string[] {
+	return [
+		...new Set(
+			sessions
+				.filter(isSessionRestorableAfterDaemonStop)
+				.map((session) => session.sessionFile)
+				.filter((sessionFile): sessionFile is string => sessionFile !== undefined)
+				.map((sessionFile) => resolve(sessionFile)),
+		),
+	];
+}
+
+export async function restoreDaemonSessionSummaries(
+	socketPath: string,
+	sessions: readonly SessionSummary[],
+): Promise<DaemonSessionRestoreResult> {
+	const sessionFiles = restoreCandidateSessionFiles(sessions);
+	if (sessionFiles.length === 0) {
+		return { restored: 0, total: 0, failed: [] };
+	}
+
+	const client = new DaemonClient(socketPath);
+	await client.connect(3000);
+	let restored = 0;
+	const failed: DaemonSessionRestoreFailure[] = [];
+	try {
+		for (const sessionFile of sessionFiles) {
+			const sourceSummary = sessions.find(
+				(session) =>
+					isSessionRestorableAfterDaemonStop(session) &&
+					session.sessionFile &&
+					resolve(session.sessionFile) === sessionFile,
+			);
+			const response = await client.request({
+				type: "create",
+				...(sourceSummary?.activeSessionId ? { activeSessionId: sourceSummary.activeSessionId } : {}),
+				sessionPath: sessionFile,
+				config: {
+					sessionDir: dirname(sessionFile),
+					...(sourceSummary?.cwd ? { cwd: sourceSummary.cwd } : {}),
+				},
+			});
+			if (response.success) {
+				restored++;
+			} else {
+				failed.push({ sessionFile, error: response.error });
+			}
+		}
+	} finally {
+		client.close();
+	}
+	return { restored, total: sessionFiles.length, failed };
+}
+
 export async function probeRunningDaemonSessions(socketPath: string): Promise<RunningDaemonProbe> {
 	const client = new DaemonClient(socketPath);
 	try {
@@ -165,23 +272,25 @@ export async function probeRunningDaemonSessions(socketPath: string): Promise<Ru
 	}
 }
 
-// Idle-but-loaded sessions reload from disk on the fresh daemon, so only a busy
-// session blocks replacing a stale daemon.
-async function shutdownStaleDaemonIfNotBusy(socketPath: string): Promise<boolean> {
+interface StaleDaemonShutdownResult {
+	stopped: boolean;
+	restoreSessions: SessionSummary[];
+}
+
+// Sessions with volatile in-memory work still block implicit replacement. Idle
+// persisted top-level sessions can be reopened after the fresh daemon starts.
+async function shutdownStaleDaemonForReplacement(socketPath: string): Promise<StaleDaemonShutdownResult> {
 	const client = new DaemonClient(socketPath);
 	let connected = false;
-	let hasBusySessions = false;
-	let loadedSessionCount = 0;
+	let summaries: SessionSummary[] | undefined;
 	try {
 		await client.connect(1000);
 		connected = true;
 		try {
-			const summaries = await listActiveDaemonSessionSummaries(client);
-			loadedSessionCount = summaries.length;
-			hasBusySessions = summaries.some(isSessionBusy);
+			summaries = await listActiveDaemonSessionSummaries(client);
 		} catch {
-			// Couldn't confirm idleness: treat as busy rather than risk interrupting work.
-			hasBusySessions = true;
+			// Couldn't confirm the session state: treat as active rather than risk interrupting work.
+			summaries = undefined;
 		}
 	} catch {
 		// Couldn't reach it to inspect; don't send a blind shutdown, just verify below.
@@ -190,30 +299,25 @@ async function shutdownStaleDaemonIfNotBusy(socketPath: string): Promise<boolean
 	}
 
 	if (!connected) {
-		return waitForDaemonGone(socketPath);
+		return { stopped: await waitForDaemonGone(socketPath), restoreSessions: [] };
 	}
-	if (hasBusySessions) {
-		logDaemonLaunch(`refusing to replace stale daemon on ${socketPath}: busy session(s) present`);
-		return false;
+	if (!summaries) {
+		logDaemonLaunch(`refusing to replace stale daemon on ${socketPath}: session list unavailable`);
+		return { stopped: false, restoreSessions: [] };
+	}
+	const atRiskSessions = summaries.filter(isSessionAtRiskFromDaemonStop);
+	if (atRiskSessions.length > 0) {
+		logDaemonLaunch(`refusing to replace stale daemon on ${socketPath}: unrestorable live session(s) present`);
+		return { stopped: false, restoreSessions: [] };
 	}
+	const restoreSessions = summaries.filter(isSessionRestorableAfterDaemonStop);
 	logDaemonLaunch(
-		`replacing stale daemon on ${socketPath} (idle): ${loadedSessionCount} loaded session(s) will reload`,
+		`replacing stale daemon on ${socketPath}: ${restoreSessions.length} live session(s) will be reopened`,
 	);
-	return shutdownDaemonAndWait(socketPath);
+	return { stopped: await shutdownDaemonAndWait(socketPath), restoreSessions };
 }
 
-async function ensureDaemonRunning(socketPath: string, spawnCwd?: string): Promise<void> {
-	const probe = await probeDaemonVersion(socketPath);
-	if (probe === "current") {
-		return;
-	}
-	if (probe === "stale") {
-		const stopped = await shutdownStaleDaemonIfNotBusy(socketPath);
-		if (!stopped) {
-			throw new StaleDaemonError(socketPath);
-		}
-	}
-
+async function spawnDaemonAndWait(socketPath: string, spawnCwd?: string): Promise<void> {
 	const entrypoint = process.argv[1];
 	if (!entrypoint) {
 		throw new Error("Cannot determine current CLI entrypoint for daemon launch");
@@ -244,6 +348,56 @@ async function ensureDaemonRunning(socketPath: string, spawnCwd?: string): Promi
 	throw new Error(`Timed out waiting for daemon to start on ${socketPath}`);
 }
 
+export async function relaunchDaemonAndRestoreSessions(
+	socketPath: string,
+	sessions: readonly SessionSummary[],
+	spawnCwd?: string,
+	options: { allowAtRiskSessions?: boolean; latestProbe?: RunningDaemonProbe } = {},
+): Promise<DaemonSessionRestoreResult> {
+	const latestProbe = options.latestProbe ?? (await probeRunningDaemonSessions(socketPath));
+	if (latestProbe.reachable && latestProbe.activeSessions === undefined && !options.allowAtRiskSessions) {
+		throw new Error(`Cannot stop daemon on ${socketPath}: live session list unavailable`);
+	}
+	const sessionsToRestore = latestProbe.reachable ? (latestProbe.activeSessions ?? sessions) : sessions;
+	const atRiskSessions = sessionsToRestore.filter(isSessionAtRiskFromDaemonStop);
+	if (atRiskSessions.length > 0 && !options.allowAtRiskSessions) {
+		throw new Error(`Cannot stop daemon on ${socketPath}: unrestorable live session(s) present`);
+	}
+	const stopped = await shutdownDaemonAndWait(socketPath);
+	if (!stopped) {
+		throw new Error(`Could not stop daemon on ${socketPath}`);
+	}
+	await spawnDaemonAndWait(socketPath, spawnCwd);
+	return restoreDaemonSessionSummaries(socketPath, sessionsToRestore);
+}
+
+export async function spawnDaemonAndRestoreSessions(
+	socketPath: string,
+	sessions: readonly SessionSummary[],
+	spawnCwd?: string,
+): Promise<DaemonSessionRestoreResult> {
+	await spawnDaemonAndWait(socketPath, spawnCwd);
+	return restoreDaemonSessionSummaries(socketPath, sessions);
+}
+
+async function ensureDaemonRunning(socketPath: string, spawnCwd?: string): Promise<void> {
+	const probe = await probeDaemonVersion(socketPath);
+	if (probe === "current") {
+		return;
+	}
+	let restoreSessions: SessionSummary[] = [];
+	if (probe === "stale") {
+		const result = await shutdownStaleDaemonForReplacement(socketPath);
+		if (!result.stopped) {
+			throw new StaleDaemonError(socketPath);
+		}
+		restoreSessions = result.restoreSessions;
+	}
+
+	const restoreResult = await spawnDaemonAndRestoreSessions(socketPath, restoreSessions, spawnCwd);
+	reportDaemonLaunchRestoreWarnings(restoreResult);
+}
+
 const ensurePromises = new Map<string, Promise<void>>();
 
 /**

packages/coding-agent/src/cli/daemon-stop-confirm.ts

@@ -2,8 +2,9 @@
  * Shared confirmation for stopping a running daemon that has live sessions.
  *
  * Both `prime-agent update --self` and interactive startup (when taking over a
- * stale-version daemon) need to ask before discarding busy sessions. They keep
- * the same busy-session semantics here and only vary the wording via `copy`.
+ * stale-version daemon) need to ask before discarding live active sessions that
+ * cannot be restored after the daemon restarts. They keep the same safety
+ * semantics here and only vary the wording via `copy`.
  *
  * Kept out of daemon-launch.ts so the early fire-and-forget launch path stays
  * light on imports (no readline/chalk); this module is only reached on the
@@ -12,7 +13,7 @@
 
 import { createInterface } from "node:readline";
 import chalk from "chalk";
-import { isSessionBusy, type RunningDaemonProbe } from "./daemon-launch.js";
+import { isSessionAtRiskFromDaemonStop, type RunningDaemonProbe } from "./daemon-launch.js";
 
 /** Prompt for a yes/no answer at a TTY. Empty/anything-but-yes resolves false (default No). */
 export function promptYesNo(message: string): Promise<boolean> {
@@ -31,8 +32,8 @@ export function pluralizeSessions(count: number): { noun: string; pronoun: strin
 }
 
 export interface DaemonSessionLossCopy {
-	/** Full sentence describing the busy sessions and what stopping the daemon does. */
-	busyDetail(count: number): string;
+	/** Full sentence describing the unrestorable sessions and what stopping the daemon does. */
+	atRiskDetail(count: number): string;
 	/** Full sentence for the reachable-but-unlistable case (work may be lost). */
 	unlistableDetail: string;
 	/** Question appended after the detail when prompting at a TTY (before " [y/N]"). */
@@ -43,10 +44,10 @@ export interface DaemonSessionLossCopy {
 
 /**
  * Returns true when it is safe to proceed with stopping the daemon: it is not
- * reachable, `force` is set, no sessions are busy, or the user confirmed at a
- * TTY. Returns false to abort (busy/unlistable and either declined or non-TTY).
- * Only busy sessions (streaming, compacting, running bash, or pending messages)
- * require confirmation; idle loaded sessions are restored from disk.
+ * reachable, `force` is set, no live sessions are at risk, or the user
+ * confirmed at a TTY. Returns false to abort (at-risk/unlistable and either
+ * declined or non-TTY). Restorable top-level sessions are reopened after the
+ * fresh daemon starts.
  */
 export async function confirmDaemonSessionLoss(
 	probe: RunningDaemonProbe,
@@ -61,11 +62,11 @@ export async function confirmDaemonSessionLoss(
 		// Reachable but couldn't list sessions: assume work may be lost.
 		detail = copy.unlistableDetail;
 	} else {
-		const busySessions = probe.activeSessions.filter(isSessionBusy);
-		if (busySessions.length === 0) {
+		const atRiskSessions = probe.activeSessions.filter(isSessionAtRiskFromDaemonStop);
+		if (atRiskSessions.length === 0) {
 			return true;
 		}
-		detail = copy.busyDetail(busySessions.length);
+		detail = copy.atRiskDetail(atRiskSessions.length);
 	}
 	if (!process.stdin.isTTY) {
 		console.error(chalk.red(`${detail} ${copy.nonTtyHint}`));

packages/coding-agent/src/core/cron-jobs.ts

@@ -149,11 +149,14 @@ export class AgentCronJobStore {
 		sessionId: string;
 		sessionFile: string;
 		cwd: string;
+		matchActiveSessionId?: boolean;
 	}): AgentCronJob[] {
 		const targetSessionFile = resolve(input.sessionFile);
 		const reboundJobs: AgentCronJob[] = [];
 		const jobs = this.readJobs().map((job) => {
-			if (job.activeSessionId !== input.activeSessionId && resolve(job.sessionFile) !== targetSessionFile) {
+			const matchesActiveSessionId =
+				input.matchActiveSessionId !== false && job.activeSessionId === input.activeSessionId;
+			if (!matchesActiveSessionId && resolve(job.sessionFile) !== targetSessionFile) {
 				return job;
 			}
 			if (