@gajae-code/coding-agent 0.11.0 → 0.11.2

package/src/sdk/bus/lifecycle-control-runtime.ts

@@ -11,6 +11,8 @@ import * as fs from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import * as path from "node:path";
 import type { NotificationControlServer as NativeNotificationControlServer } from "@gajae-code/natives";
+import { logger } from "@gajae-code/utils";
+import { readLinuxProcStartTime } from "../../gjc-runtime/linux-proc";
 import { tmuxRuntimeSessionPath } from "../../gjc-runtime/session-layout";
 import {
 	GJC_COORDINATOR_SESSION_ID_ENV,
@@ -116,6 +118,20 @@ function isLifecycleErrorReason(value: unknown): value is LifecycleErrorReason {
 }
 
 /** Atomic + fsynced file-backed idempotency ledger store. */
+function hasNonDirectoryLedgerParent(idempotencyFile: string): boolean {
+	let parent = path.dirname(idempotencyFile);
+	while (true) {
+		try {
+			return !fs.statSync(parent).isDirectory();
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			const nextParent = path.dirname(parent);
+			if (nextParent === parent) return false;
+			parent = nextParent;
+		}
+	}
+}
+
 function ledgerReadError(error: unknown): Error {
 	const errorCode = (error as NodeJS.ErrnoException | undefined)?.code;
 	const code = typeof errorCode === "string" ? errorCode : "invalid";
@@ -181,27 +197,55 @@ function migrateLegacyLedger(doc: LedgerDoc): LedgerDoc {
 	return doc;
 }
 
+const LIFECYCLE_COMPATIBILITY_DIAGNOSTIC_LIMIT = 1;
+const LIFECYCLE_CONTROL_DIAGNOSTIC_LIMIT = 10;
+let lifecycleCompatibilityDiagnosticCount = 0;
+let lifecycleControlDiagnosticCount = 0;
+
 function isUnsupportedDirectorySyncError(error: unknown): boolean {
 	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return code === "EINVAL" || code === "ENOTSUP" || code === "EOPNOTSUPP";
+	return (
+		code === "EINVAL" ||
+		code === "ENOTSUP" ||
+		code === "EOPNOTSUPP" ||
+		(process.platform === "win32" && code === "EPERM")
+	);
 }
 
-function recordDirectorySyncCompatibilityDiagnostic(): void {
+function recordBoundedLifecycleDiagnostic(message: string, compatibility = false): void {
+	if (compatibility) {
+		if (lifecycleCompatibilityDiagnosticCount >= LIFECYCLE_COMPATIBILITY_DIAGNOSTIC_LIMIT) return;
+		lifecycleCompatibilityDiagnosticCount++;
+	} else {
+		if (lifecycleControlDiagnosticCount >= LIFECYCLE_CONTROL_DIAGNOSTIC_LIMIT) return;
+		lifecycleControlDiagnosticCount++;
+	}
 	try {
-		process.stderr.write("gjc lifecycle ledger directory sync unsupported\n");
+		logger.warn(message);
 	} catch {
-		// Compatibility diagnostics must not alter ledger durability semantics.
+		// Diagnostics are best-effort and must not poison the lifecycle queue.
 	}
 }
 
 function fsyncLedgerParentDirectory(directory: string): void {
-	const dirFd = fs.openSync(directory, "r");
+	let dirFd: number;
+	try {
+		dirFd = fs.openSync(directory, "r");
+	} catch (error) {
+		if (process.platform === "win32" && isUnsupportedDirectorySyncError(error)) {
+			recordBoundedLifecycleDiagnostic("GJC lifecycle ledger directory sync unsupported", true);
+			return;
+		}
+		throw error;
+	}
+
 	let syncFailure: unknown;
 	let closeFailure: unknown;
 	try {
 		fs.fsyncSync(dirFd);
 	} catch (error) {
-		if (isUnsupportedDirectorySyncError(error)) recordDirectorySyncCompatibilityDiagnostic();
+		if (process.platform === "win32" && isUnsupportedDirectorySyncError(error))
+			recordBoundedLifecycleDiagnostic("GJC lifecycle ledger directory sync unsupported", true);
 		else syncFailure = error;
 	} finally {
 		try {
@@ -224,7 +268,16 @@ export function fileLedgerStore(idempotencyFile: string): LedgerStore {
 				contents = fs.readFileSync(idempotencyFile, "utf8");
 			} catch (error) {
 				const code = (error as NodeJS.ErrnoException).code;
-				if (code === "ENOENT") return { version: 1, entries: {} };
+				if (code === "ENOENT") {
+					let hasNonDirectoryParent: boolean;
+					try {
+						hasNonDirectoryParent = hasNonDirectoryLedgerParent(idempotencyFile);
+					} catch (parentError) {
+						throw ledgerReadError(parentError);
+					}
+					if (hasNonDirectoryParent) throw ledgerReadError({ code: "ENOTDIR" });
+					return { version: 1, entries: {} };
+				}
 				throw ledgerReadError(error);
 			}
 			try {
@@ -373,15 +426,11 @@ function lifecycleOwnerIsolationProbe(tmux: string, env: NodeJS.ProcessEnv): Own
 					cgroup: { classification: "not_applicable" },
 					sessionNames,
 				};
-			const [cgroupText, stat] = await Promise.all([
+			const [cgroupText, startTime] = await Promise.all([
 				fsPromises.readFile(`/proc/${pid}/cgroup`, "utf8").catch(() => null),
-				fsPromises.readFile(`/proc/${pid}/stat`, "utf8").catch(() => null),
+				readLinuxProcStartTime(pid),
 			]);
 			const cgroup = classifyCgroup({ platform: process.platform, cgroupText });
-			const startTime = stat
-				?.slice(stat.lastIndexOf(")") + 2)
-				.trim()
-				.split(/\s+/)[19];
 			if (!startTime) return { state: "unverifiable", pid, cgroup, sessionNames };
 			return {
 				state:
@@ -931,6 +980,8 @@ export function daemonCloseSession(
 export function daemonResumeSession(
 	env: NodeJS.ProcessEnv = process.env,
 	opts: {
+		agentDir?: string;
+		/** Explicit managed root for isolated tests. */
 		sessionsRoot?: string;
 		listSessions?: (env: NodeJS.ProcessEnv) => GjcTmuxSessionStatus[];
 		ownerIsolationProbe?: OwnerIsolationProbe;
@@ -971,21 +1022,28 @@ export function daemonResumeSession(
 		// blindly spawning `gjc --resume <prefix>` against a non-authoritative id.
 		let resumeId = target.sessionIdOrPrefix;
 		let resumeCwd = target.path;
-		if (opts.sessionsRoot) {
-			const saved = listRecentSessions({ sessionsRoot: opts.sessionsRoot, limit: 1000 });
-			const prefixed = saved.filter(
-				s => s.sessionId === target.sessionIdOrPrefix || s.sessionId.startsWith(target.sessionIdOrPrefix),
-			);
-			const exact = prefixed.filter(s => s.sessionId === target.sessionIdOrPrefix);
-			const resolved = exact.length > 0 ? exact : prefixed;
-			if (resolved.length === 0) return { notFound: true };
-			if (resolved.length > 1) {
-				return { ambiguous: resolved.map(s => ({ sessionId: s.sessionId, path: s.path })) };
-			}
-			const selected = resolved[0]!;
-			resumeId = selected.sessionId;
-			resumeCwd = selected.path;
+		if (!target.path && !opts.agentDir && !opts.sessionsRoot) return { notFound: true };
+		const recent = await listRecentSessions({
+			cwd: target.path ?? opts.agentDir ?? opts.sessionsRoot ?? "",
+			agentDir: opts.agentDir,
+			sessionsRoot: opts.sessionsRoot,
+			allWorkspaces: target.path === undefined,
+			limit: 1000,
+		});
+		if (recent.kind === "error") throw new Error(`gjc_lifecycle_saved_sessions_unavailable: ${recent.message}`);
+		const saved = recent.entries;
+		const prefixed = saved.filter(
+			s => s.sessionId === target.sessionIdOrPrefix || s.sessionId.startsWith(target.sessionIdOrPrefix),
+		);
+		const exact = prefixed.filter(s => s.sessionId === target.sessionIdOrPrefix);
+		const resolved = exact.length > 0 ? exact : prefixed;
+		if (resolved.length === 0) return { notFound: true };
+		if (resolved.length > 1) {
+			return { ambiguous: resolved.map(s => ({ sessionId: s.sessionId, path: s.path })) };
 		}
+		const selected = resolved[0]!;
+		resumeId = selected.sessionId;
+		resumeCwd = selected.path;
 		const resolvedResumeCwd = resumeCwd ? path.resolve(resumeCwd) : undefined;
 		const resumeCwdStat = resolvedResumeCwd ? fs.statSync(resolvedResumeCwd, { throwIfNoEntry: false }) : undefined;
 		if (typeof resolvedResumeCwd !== "string" || !resumeCwdStat?.isDirectory()) {
@@ -1139,11 +1197,7 @@ function lifecycleFailureResponse(requestId: unknown): SessionLifecycleResponse
 }
 
 function recordLifecycleControlDiagnostic(): void {
-	try {
-		process.stderr.write("gjc lifecycle control request failed\n");
-	} catch {
-		// Diagnostics must not suppress the fixed wire failure response or recovery.
-	}
+	recordBoundedLifecycleDiagnostic("GJC lifecycle control request failed");
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -1267,6 +1321,8 @@ export function buildOrchestratorDeps(input: {
 	auditRedactionKey: Uint8Array;
 	/** Root of saved session histories (`<agentDir>/sessions`), for resume resolution. */
 	sessionsRoot?: string;
+	/** Agent directory used for readonly managed-session resume resolution. */
+	agentDir?: string;
 	env?: NodeJS.ProcessEnv;
 }): OrchestratorDeps {
 	if (input.auditRedactionKey.byteLength !== 32) throw new Error("invalid_audit_redaction_key");
@@ -1285,7 +1341,9 @@ export function buildOrchestratorDeps(input: {
 		},
 		spawnCreate: daemonSpawnCreate(env),
 		closeSession: daemonCloseSession(env),
-		resumeSession: daemonResumeSession(env, { sessionsRoot: input.sessionsRoot }),
+		resumeSession: daemonResumeSession(env, {
+			agentDir: input.agentDir ?? path.dirname(input.agentNotificationsDir),
+		}),
 	};
 }
 

package/src/sdk/bus/native-runtime-compatibility.ts

@@ -1,4 +1,4 @@
-const REQUIRED_WORKFLOW_ARBITRATION_METHODS = ["registerArbitratedAsk", "retireIfUnclaimed"] as const;
+const REQUIRED_WORKFLOW_ARBITRATION_METHODS = ["registerArbitratedAsk", "retireIfUnclaimed", "stopAndWait"] as const;
 
 export class NativeRuntimeCompatibilityError extends Error {
 	readonly code = "native_runtime_incompatible";

package/src/sdk/bus/natives-augment.d.ts

@@ -26,7 +26,11 @@ declare module "@gajae-code/natives" {
 		onSdkFrame(callback: (err: null | Error, frame: SdkFrameEvent) => void): void;
 		/** Register the connection-close callback. Must be called before start. */
 		onConnectionClose(callback: (err: null | Error, connectionId: string) => void): void;
-		/** Directed send of a JSON text frame to one connection. */
+		/** Register negotiated v3 client capabilities. Must be called before start. */
+		onNegotiatedCapabilities(
+			callback: (err: null | Error, connectionId: string, capabilities: string[]) => void,
+		): void;
+		/** Directed delivery of a validated, bounded JSON v3 envelope to one connection. */
 		sendTo(connectionId: string, json: string): void;
 		/** Register a correlated workflow-gate action_needed frame. */
 		registerWorkflowGateAsk(workflowJson: string, repliable: boolean): void;
@@ -34,5 +38,26 @@ declare module "@gajae-code/natives" {
 		registerArbitratedAsk(actionJson: string, repliable: boolean): PresentationLease;
 		/** Retire an exact private lease unless a generic reply has already claimed it. */
 		retireIfUnclaimed(lease: PresentationLease): RetireIfUnclaimedResult;
+		/** Broadcast a TypeScript-constructed turn frame without JSON serde validation. */
+		pushTurnStreamUnchecked(
+			sessionId: string,
+			phase: "live" | "finalized",
+			text: string,
+			finalAnswer?: boolean,
+			messageRef?: string,
+		): void;
+		/** Broadcast raw file bytes; Rust encodes the unchanged base64 wire field. */
+		pushFileAttachmentUnchecked(
+			sessionId: string,
+			name: string,
+			mime: string | undefined,
+			data: Buffer,
+			caption: string | undefined,
+		): void;
+		/** Counters for known-good N-API frame crossings. */
+		knownGoodFrameStats(): {
+			knownGoodTurnStreamFrames: number;
+			turnStreamSerdeValidationParses: number;
+		};
 	}
 }

package/src/sdk/bus/notification-service.ts

@@ -10,8 +10,11 @@
  * artifacts belonging to a DEAD owner (dead-PID / explicitly-stale). It never
  * touches a live owner's lock/state and never kills a process.
  */
+import * as crypto from "node:crypto";
+import * as fsSync from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import * as path from "node:path";
+import * as native from "@gajae-code/natives";
 import type { Settings } from "../../config/settings";
 import {
 	getNotificationConfig,
@@ -46,10 +49,32 @@ export function sanitizeDiagnostic(text: string, token?: string): string {
 	return out.replace(TELEGRAM_TOKEN_PATTERN, "<redacted>");
 }
 
+/** Identity evidence required to remove precisely the endpoint that was inspected. */
+export interface NotificationEndpointFileIdentity {
+	dev: bigint;
+	ino: bigint;
+	size: bigint;
+	mtimeNs: bigint;
+	sha256: string;
+}
+
+export interface NotificationEndpointFile {
+	bytes: Buffer;
+	identity: NotificationEndpointFileIdentity;
+}
+
+export interface NotificationExactUnlinkResult {
+	ok: boolean;
+	code?: string;
+	detachedPath?: string;
+}
+
 /** Minimal filesystem surface the service needs; injectable for tests. */
 export interface NotificationServiceFs {
 	readdir(dir: string): Promise<string[]>;
 	readFile(file: string, encoding: "utf8"): Promise<string>;
+	readEndpointFile(file: string): Promise<NotificationEndpointFile>;
+	exactUnlink(file: string, identity: NotificationEndpointFileIdentity): Promise<NotificationExactUnlinkResult>;
 	unlink(file: string): Promise<void>;
 	/**
 	 * Atomically create `file` with O_EXCL semantics: resolves `true` when this
@@ -63,6 +88,47 @@ export interface NotificationServiceFs {
 const nodeServiceFs: NotificationServiceFs = {
 	readdir: dir => fsPromises.readdir(dir),
 	readFile: (file, encoding) => fsPromises.readFile(file, encoding),
+	readEndpointFile: async file => {
+		const before = await fsPromises.lstat(file, { bigint: true });
+		if (!before.isFile() || before.isSymbolicLink()) throw new Error("Endpoint is not a regular file");
+		const noFollow = fsSync.constants.O_NOFOLLOW;
+		const handle = await fsPromises.open(file, fsSync.constants.O_RDONLY | (noFollow ?? 0));
+		try {
+			const opened = await handle.stat({ bigint: true });
+			if (!opened.isFile() || !sameEndpointFileMetadata(before, opened))
+				throw new Error("Endpoint changed before it was opened");
+			const bytes = await handle.readFile();
+			const after = await handle.stat({ bigint: true });
+			const pathname = await fsPromises.lstat(file, { bigint: true });
+			if (
+				!after.isFile() ||
+				!pathname.isFile() ||
+				pathname.isSymbolicLink() ||
+				!sameEndpointFileMetadata(opened, after) ||
+				!sameEndpointFileMetadata(opened, pathname)
+			)
+				throw new Error("Endpoint changed while it was read");
+			return {
+				bytes,
+				identity: {
+					dev: opened.dev,
+					ino: opened.ino,
+					size: opened.size,
+					mtimeNs: opened.mtimeNs,
+					sha256: crypto.createHash("sha256").update(bytes).digest("hex"),
+				},
+			};
+		} finally {
+			await handle.close();
+		}
+	},
+	exactUnlink: async (file, identity) => {
+		const result = native.exactUnlink(file, {
+			...identity,
+			quarantineName: `.gjc-delete-notification-endpoint-${crypto.randomUUID()}.json`,
+		});
+		return { ok: result.ok, code: result.code, detachedPath: result.detachedPath };
+	},
 	unlink: file => fsPromises.unlink(file),
 	createExclusive: async file => {
 		try {
@@ -99,7 +165,7 @@ function defaultStateRoot(): string {
 }
 
 function endpointDir(stateRoot: string): string {
-	return path.join(stateRoot, "notifications");
+	return path.join(stateRoot, "sdk");
 }
 
 // --- status -------------------------------------------------------------
@@ -179,6 +245,11 @@ interface EndpointView {
 	stale: boolean;
 }
 
+type EndpointFileRead =
+	| { kind: "endpoint"; view: EndpointView; identity: NotificationEndpointFileIdentity }
+	| { kind: "non-endpoint" }
+	| { kind: "unreadable" };
+
 type EndpointLiveness = "live" | "dead" | "unknown";
 
 /**
@@ -194,25 +265,74 @@ function endpointLiveness(view: EndpointView, pidAlive: (pid: number) => boolean
 	return pidAlive(view.pid) ? "live" : "dead";
 }
 
-async function readEndpointView(fs: NotificationServiceFs, file: string): Promise<EndpointView | undefined> {
+function sameEndpointFileMetadata(
+	left: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint },
+	right: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint },
+): boolean {
+	return (
+		left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs
+	);
+}
+
+function isLifecycleArtifact(record: Record<string, unknown>): boolean {
+	const keys = Object.keys(record);
+	const isEffectMarker =
+		typeof record.pid === "number" &&
+		Number.isSafeInteger(record.pid) &&
+		record.pid > 0 &&
+		typeof record.effectMarker === "string" &&
+		record.effectMarker.length > 0 &&
+		typeof record.incarnation === "string" &&
+		record.incarnation.length > 0;
+	if (isEffectMarker && keys.length === 3) return true;
+	return (
+		isEffectMarker &&
+		typeof record.phase === "string" &&
+		typeof record.reason === "string" &&
+		typeof record.message === "string" &&
+		typeof record.rollback === "object" &&
+		record.rollback !== null
+	);
+}
+function isCanonicalLifecycleArtifactName(name: string): boolean {
+	return (
+		name.endsWith(".lifecycle.json") ||
+		name.endsWith(".lifecycle.ready.json") ||
+		/^.+\.lifecycle\.failure\.[A-Za-z0-9._-]{1,128}\.json$/.test(name)
+	);
+}
+
+function unreadableEndpointResult(file: string): EndpointFileRead {
+	return isCanonicalLifecycleArtifactName(path.basename(file)) ? { kind: "non-endpoint" } : { kind: "unreadable" };
+}
+
+async function readEndpointView(fs: NotificationServiceFs, file: string): Promise<EndpointFileRead> {
+	let endpoint: NotificationEndpointFile;
 	let raw: string;
 	try {
-		raw = await fs.readFile(file, "utf8");
+		endpoint = await fs.readEndpointFile(file);
+		raw = endpoint.bytes.toString("utf8");
 	} catch {
-		return undefined;
+		return unreadableEndpointResult(file);
 	}
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(raw);
 	} catch {
-		return undefined;
+		return unreadableEndpointResult(file);
 	}
-	if (!parsed || typeof parsed !== "object") return undefined;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { kind: "non-endpoint" };
 	const rec = parsed as Record<string, unknown>;
+	if (isLifecycleArtifact(rec) || typeof rec.url !== "string" || typeof rec.token !== "string")
+		return { kind: "non-endpoint" };
 	return {
-		sessionId: typeof rec.sessionId === "string" ? rec.sessionId : path.basename(file, ".json"),
-		pid: typeof rec.pid === "number" ? rec.pid : undefined,
-		stale: rec.stale === true,
+		kind: "endpoint",
+		view: {
+			sessionId: typeof rec.sessionId === "string" ? rec.sessionId : path.basename(file, ".json"),
+			pid: safePositiveInteger(rec.pid),
+			stale: rec.stale === true,
+		},
+		identity: endpoint.identity,
 	};
 }
 
@@ -288,9 +408,13 @@ async function readDaemonStateFile(
 	}
 }
 
+function isSharedSdkArtifact(name: string): boolean {
+	return name === "broker.json";
+}
+
 async function listEndpointFiles(fs: NotificationServiceFs, dir: string): Promise<string[]> {
 	try {
-		return (await fs.readdir(dir)).filter(name => name.endsWith(".json"));
+		return (await fs.readdir(dir)).filter(name => name.endsWith(".json") && !isSharedSdkArtifact(name));
 	} catch {
 		return [];
 	}
@@ -468,11 +592,13 @@ export async function checkNotificationHealth(opts: HealthOptions): Promise<Noti
 	let unknownEndpoints = 0;
 	let unreadable = 0;
 	for (const name of files) {
-		const view = await readEndpointView(fs, path.join(dir, name));
-		if (!view) {
+		const record = await readEndpointView(fs, path.join(dir, name));
+		if (record.kind === "non-endpoint") continue;
+		if (record.kind === "unreadable") {
 			unreadable += 1;
 			continue;
 		}
+		const view = record.view;
 		switch (endpointLiveness(view, pidAlive)) {
 			case "live":
 				live += 1;
@@ -485,12 +611,18 @@ export async function checkNotificationHealth(opts: HealthOptions): Promise<Noti
 				break;
 		}
 	}
-	const endpoints: EndpointHealth = { total: files.length, live, dead, unknown: unknownEndpoints, unreadable };
+	const endpoints: EndpointHealth = {
+		total: live + dead + unknownEndpoints + unreadable,
+		live,
+		dead,
+		unknown: unknownEndpoints,
+		unreadable,
+	};
 	if (dead > 0 || unreadable > 0) {
 		checks.push({
 			name: "endpoints",
 			level: "warn",
-			detail: `${dead} dead / ${unreadable} unreadable of ${files.length} endpoint file(s); run recovery`,
+			detail: `${dead} dead / ${unreadable} unreadable of ${endpoints.total} endpoint file(s); run recovery`,
 		});
 	} else {
 		checks.push({
@@ -633,6 +765,7 @@ export interface NotificationRecoveryReport {
 	endpointsRemoved: RecoveredEndpoint[];
 	endpointsKept: number;
 	endpointsUnreadable: number;
+	endpointsDetached?: string[];
 	daemon: {
 		action: DaemonRecoveryAction;
 		detail: string;
@@ -699,15 +832,19 @@ export async function recoverNotifications(opts: RecoveryOptions): Promise<Notif
 	const dir = endpointDir(stateRoot);
 	const files = await listEndpointFiles(fs, dir);
 	const removed: RecoveredEndpoint[] = [];
+	const detached: string[] = [];
 	let kept = 0;
 	let unreadable = 0;
 	for (const name of files) {
-		const view = await readEndpointView(fs, path.join(dir, name));
-		if (!view) {
+		const file = path.join(dir, name);
+		const record = await readEndpointView(fs, file);
+		if (record.kind === "non-endpoint") continue;
+		if (record.kind === "unreadable") {
 			// Leave unparseable files untouched: they may be mid-write by a live server.
 			unreadable += 1;
 			continue;
 		}
+		const view = record.view;
 		if (endpointLiveness(view, pidAlive) !== "dead") {
 			// Keep live AND unknown (PID-less) endpoints: only positive proof of
 			// death (a stale tombstone or a dead pid) authorizes removal.
@@ -715,8 +852,17 @@ export async function recoverNotifications(opts: RecoveryOptions): Promise<Notif
 			continue;
 		}
 		try {
-			await fs.unlink(path.join(dir, name));
-			removed.push({ sessionId: view.sessionId, pid: view.pid, reason: view.stale ? "stale-flag" : "dead-pid" });
+			const result = await fs.exactUnlink(file, record.identity);
+			if (!result.ok) {
+				if (result.detachedPath) detached.push(result.detachedPath);
+				else kept += 1;
+				continue;
+			}
+			removed.push({
+				sessionId: view.sessionId,
+				pid: view.pid,
+				reason: view.stale ? "stale-flag" : "dead-pid",
+			});
 		} catch {
 			kept += 1;
 		}
@@ -782,10 +928,11 @@ export async function recoverNotifications(opts: RecoveryOptions): Promise<Notif
 	}
 
 	return {
-		endpointsScanned: files.length,
+		endpointsScanned: removed.length + kept + unreadable + detached.length,
 		endpointsRemoved: removed,
 		endpointsKept: kept,
 		endpointsUnreadable: unreadable,
+		endpointsDetached: detached,
 		daemon,
 	};
 }
@@ -794,11 +941,12 @@ export async function recoverNotifications(opts: RecoveryOptions): Promise<Notif
 export function formatNotificationRecoveryReport(report: NotificationRecoveryReport): string {
 	const lines = ["Notification recovery"];
 	lines.push(
-		`  endpoints: scanned ${report.endpointsScanned}, removed ${report.endpointsRemoved.length}, kept ${report.endpointsKept}, unreadable ${report.endpointsUnreadable}`,
+		`  endpoints: scanned ${report.endpointsScanned}, removed ${report.endpointsRemoved.length}, kept ${report.endpointsKept}, unreadable ${report.endpointsUnreadable}, detached ${report.endpointsDetached?.length ?? 0}`,
 	);
 	for (const ep of report.endpointsRemoved) {
 		lines.push(`    - removed ${ep.sessionId} (pid ${ep.pid ?? "?"}, ${ep.reason})`);
 	}
+	for (const detached of report.endpointsDetached ?? []) lines.push(`    - retained detached endpoint ${detached}`);
 	lines.push(`  daemon: ${report.daemon.action} — ${report.daemon.detail}`);
 	return lines.join("\n");
 }