@gajae-code/coding-agent 0.11.7 → 0.11.8

package/src/sdk/bus/lifecycle-commands.ts

@@ -49,6 +49,49 @@ const USAGE = [
 	"/session_recent [create|resume]",
 ].join("\n");
 
+function tokenizeLifecycleCommand(value: string): string[] | undefined {
+	const tokens: string[] = [];
+	let token = "";
+	let quote: '"' | "'" | undefined;
+	let started = false;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index]!;
+		if (character === "\\") {
+			const next = value[index + 1];
+			if (next !== undefined && (next === "\\" || next === '"' || next === "'" || /\s/u.test(next))) {
+				token += next;
+				index++;
+			} else token += character;
+			started = true;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = undefined;
+			else token += character;
+			started = true;
+			continue;
+		}
+		if (character === '"' || character === "'") {
+			quote = character;
+			started = true;
+			continue;
+		}
+		if (/\s/u.test(character)) {
+			if (started) {
+				tokens.push(token);
+				token = "";
+				started = false;
+			}
+			continue;
+		}
+		token += character;
+		started = true;
+	}
+	if (quote) return undefined;
+	if (started) tokens.push(token);
+	return tokens;
+}
+
 /** True when the text begins with any /session_* token, regardless of addressability. */
 export function isLifecycleCommandLikeText(text: string | undefined): boolean {
 	if (!text) return false;
@@ -98,8 +141,10 @@ export function parseLifecycleCommand(
 	text: string | undefined,
 	ctx: { chatType?: string; botUsername?: string } = {},
 ): ParsedLifecycleCommand {
+	const tokens = tokenizeLifecycleCommand((text ?? "").trim());
+	if (!tokens) return { kind: "usage", message: USAGE };
+	const [rawCommand, ...args] = tokens;
 	const raw = (text ?? "").trim();
-	const [rawCommand, ...args] = raw.split(/\s+/);
 	const command = normalizeLifecycleCommandToken(rawCommand ?? "", ctx);
 	if (command === undefined) return { kind: "none" };
 
@@ -140,9 +185,8 @@ export function parseLifecycleCommand(
 
 	// /session_create <kind> ... [--mpreset <profile>]
 	const { positional, modelPreset } = extractModelPreset(args);
-	if (modelPreset !== undefined && !isSafeIdentifier(modelPreset)) {
+	if (modelPreset !== undefined && modelPreset.length === 0)
 		return { kind: "reject", reason: "invalid_target", message: `Invalid model preset name.\n\n${USAGE}` };
-	}
 	const kind = positional[0];
 	if (kind === "path") {
 		if (positional.length !== 2) return { kind: "usage", message: USAGE };

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

@@ -1178,16 +1178,25 @@ export function outcomeToResponse(frame: SessionLifecycleRequest, outcome: Lifec
 	if (frame.type === "session_close") {
 		if (typeof e.sessionId !== "string" || typeof e.processGone !== "boolean")
 			throw new Error("invalid close success ledger entry");
+		if (!e.processGone) {
+			return {
+				type: "session_lifecycle_error",
+				requestId: frame.requestId,
+				status: "error",
+				reason: "terminal_uncertain",
+				message: "close did not confirm process termination",
+			};
+		}
 		return {
 			type: "session_close_response",
 			requestId: frame.requestId,
 			status: "ok",
 			sessionId: e.sessionId,
-			processGone: e.processGone,
+			processGone: true,
 			historyPreserved: true,
 			// The killed session's per-session endpoint record is reaped by the
 			// daemon's dead-PID scan (scanRoots), so it is effectively stale.
-			endpointStale: e.processGone,
+			endpointStale: true,
 		};
 	}
 	if (

package/src/sdk/bus/lifecycle-orchestrator.ts

@@ -309,6 +309,21 @@ export async function handleLifecycleRequest(
 
 	// 4. Durable idempotency.
 	const doc = await deps.store.read();
+	const existing = doc.entries[key];
+	if (
+		frame.type === "session_close" &&
+		existing?.verb === "session_close" &&
+		existing.requestHash === hash &&
+		existing.state === "success" &&
+		typeof existing.sessionId === "string" &&
+		existing.processGone === false
+	) {
+		existing.state = "terminal_uncertain";
+		existing.reason = "terminal_uncertain";
+		existing.updatedAt = deps.now();
+		delete existing.processGone;
+		await deps.store.write(doc);
+	}
 	const dup = classifyDuplicate(doc.entries[key], hash);
 	switch (dup.kind) {
 		case "conflict":
@@ -394,12 +409,28 @@ export async function handleLifecycleRequest(
 
 		if (frame.type === "session_close") {
 			const closed = await deps.closeSession(frame.target);
+			if (!closed.processGone) {
+				Object.assign(entry, {
+					state: "terminal_uncertain",
+					updatedAt: deps.now(),
+					reason: "terminal_uncertain",
+					sessionId: frame.target.sessionId,
+					tmuxSession: frame.target.tmuxSession,
+				});
+				await deps.store.write(doc);
+				await deps.audit({ ...baseAudit, event: "terminal_uncertain", reason: "terminal_uncertain" });
+				return {
+					status: "error",
+					reason: "terminal_uncertain",
+					message: "session_close could not confirm process disappearance; manual check",
+				};
+			}
 			Object.assign(entry, {
 				state: "success",
 				updatedAt: deps.now(),
 				sessionId: frame.target.sessionId,
 				tmuxSession: frame.target.tmuxSession,
-				processGone: closed.processGone,
+				processGone: true,
 			});
 			await deps.store.write(doc);
 			await deps.audit({ ...baseAudit, event: "success" });

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

@@ -1,5 +1,6 @@
 import type { CasRestoreResult } from "../../config/atomic-yaml-patch";
 import type { RawSettings, SettingsAtomicPatch, SettingsAtomicReceipt } from "../../config/settings";
+import { isProcessIncarnation, processIncarnation } from "../broker/process-incarnation";
 import {
 	getNotificationConfig,
 	hasNonBlankValue,
@@ -53,6 +54,7 @@ export interface ProposedTelegramIdentityPreflightInput {
 	deps?: {
 		fs?: TelegramDaemonFs;
 		pidAlive?: (pid: number) => boolean;
+		pidIncarnation?: (pid: number) => string | undefined;
 	};
 }
 
@@ -109,6 +111,16 @@ export async function proposedTelegramIdentity(
 
 		const pidAlive = input.deps?.pidAlive ?? defaultPidAlive;
 		if (!pidAlive(metadata.pid)) return { status: "absent" };
+		const pidIncarnation = input.deps?.pidIncarnation ?? processIncarnation;
+		const persistedIncarnation = state.incarnation;
+		const currentIncarnation = pidIncarnation(metadata.pid);
+		if (
+			!isProcessIncarnation(persistedIncarnation) ||
+			!isProcessIncarnation(currentIncarnation) ||
+			persistedIncarnation !== currentIncarnation
+		) {
+			return { status: "absent" };
+		}
 
 		if (state.tokenFingerprint === tokenFingerprint(input.botToken) && state.chatId === input.chatId) {
 			return {

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

@@ -900,7 +900,16 @@ async function detachTransitionMarker(
 ): Promise<boolean> {
 	if (!snapshot.identity || !fs.exactUnlink) return false;
 	try {
-		return (await fs.exactUnlink(path, snapshot.identity)).ok;
+		const removed = await fs.exactUnlink(path, snapshot.identity);
+		if (removed.ok) return true;
+		// Accept only typed retained authority: a concrete detached quarantine plus
+		// a proven-absent canonical marker pathname. Anything else stays fail-closed.
+		return (
+			removed.code === "cleanup_pending" &&
+			typeof removed.detachedPath === "string" &&
+			removed.detachedPath.length > 0 &&
+			(await fs.readFile(path, "utf8").catch(() => undefined)) === undefined
+		);
 	} catch {
 		return false;
 	}
@@ -1080,11 +1089,27 @@ export async function recoverNotifications(opts: RecoveryOptions): Promise<Notif
 		try {
 			const result = await fs.exactUnlink(file, record.identity);
 			if (!result.ok) {
-				recoveryFailures += 1;
 				if (result.detachedPath) detached.push(result.detachedPath);
 				if (result.retainedSuccessorPath) retainedSuccessors.push(result.retainedSuccessorPath);
 				if (result.retainedPlaceholderPath) retainedPlaceholders.push(result.retainedPlaceholderPath);
 				if (result.retainedUnknownPath) retainedUnknown.push(result.retainedUnknownPath);
+				// Typed retained authority with a concrete quarantine and a proven-absent
+				// canonical endpoint counts as removed; the detached path above is the
+				// durable evidence. Anything else is a genuine recovery failure.
+				const retainedRemoved =
+					result.code === "cleanup_pending" &&
+					typeof result.detachedPath === "string" &&
+					result.detachedPath.length > 0 &&
+					(await fs.readFile(file, "utf8").catch(() => undefined)) === undefined;
+				if (retainedRemoved) {
+					removed.push({
+						sessionId: view.sessionId,
+						pid: view.pid,
+						reason: view.stale ? "stale-flag" : "dead-pid",
+					});
+					continue;
+				}
+				recoveryFailures += 1;
 				if (
 					!result.detachedPath &&
 					!result.retainedSuccessorPath &&

package/src/sdk/bus/prompt-reconciliation.ts

@@ -0,0 +1,239 @@
+/**
+ * Bounded authoritative reconciliation state for Q26 `turn.prompt_status`.
+ *
+ * Separate from the lifecycle delivery buffers (promptSubmissions /
+ * promptTerminalTombstones), which exist to deliver frames and intentionally
+ * forget outcomes. This record preserves accepted/in_flight/terminal_ok/failed
+ * plus bounded sanitized failure metadata so a caller can reconcile a prior
+ * `turn.prompt` after disconnect/reconnect.
+ *
+ * Semantics (public contract, mirrored in sdk/prompt-status.ts):
+ * - Active records are NEVER converted to terminal by age or capacity.
+ * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
+ *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
+ *   does a lookup honestly report `unknown`.
+ * - The durability floor is the live session process: restart means `unknown`.
+ * - The clientRef index is session-runtime scoped; a ref conflicts only while
+ *   retained and must never be reused as a retry mechanism.
+ * - Terminal transitions settle once: the first terminal outcome wins.
+ */
+
+export const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
+export const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
+export const PROMPT_RECONCILIATION_TERMINAL_TTL_MS = 15 * 60_000;
+export const PROMPT_FAILURE_CODE_MAX = 64;
+
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+
+export interface PromptCorrelation {
+	commandId: string;
+	turnId: string;
+}
+
+export interface PromptReconciliationRecord extends PromptCorrelation {
+	clientRef?: string;
+	status: PromptReconciliationStatus;
+	error?: { code: string; message: string };
+	acceptedAt: number;
+	startedAt?: number;
+	terminalAt?: number;
+}
+
+export type TurnPromptReconciliation =
+	| {
+			status: "accepted";
+			commandId: string;
+			turnId: string;
+			clientRef?: string;
+			acceptedAt: number;
+	  }
+	| {
+			status: "in_flight";
+			commandId: string;
+			turnId: string;
+			clientRef?: string;
+			acceptedAt: number;
+			startedAt: number;
+	  }
+	| {
+			status: "terminal_ok";
+			commandId: string;
+			turnId: string;
+			clientRef?: string;
+			acceptedAt: number;
+			startedAt?: number;
+			terminalAt: number;
+	  }
+	| {
+			status: "failed";
+			commandId: string;
+			turnId: string;
+			clientRef?: string;
+			acceptedAt: number;
+			startedAt?: number;
+			terminalAt: number;
+			error: { code: string; message: string };
+	  }
+	| { status: "unknown" };
+
+export interface PromptReconciliation {
+	/** Fail-closed admission BEFORE any execution; holds an identity-bound reservation. */
+	admit(clientRef?: string): void;
+	/** Discard one admission reservation without creating a record (rejection/cancellation). */
+	releaseAdmission(clientRef?: string): void;
+	/** Transition a reservation into the accepted record at preflight acceptance. */
+	noteAccepted(correlation: PromptCorrelation, clientRef?: string): void;
+	/** Lifecycle transition; terminal outcomes settle exactly once. */
+	noteTransition(
+		correlation: PromptCorrelation | undefined,
+		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
+	): void;
+	lookup(selector: { commandId?: string; turnId?: string; clientRef?: string }): TurnPromptReconciliation;
+	cleanup(): void;
+	activeCount(): number;
+}
+
+/** Safe-token code capped at 64; arbitrary failure text is never retained. */
+export function sanitizePromptFailure(error: unknown): { code: string; message: string } {
+	const candidate = error as { code?: unknown } | undefined;
+	const rawCode = typeof candidate?.code === "string" ? candidate.code : "";
+	const code = rawCode.length <= PROMPT_FAILURE_CODE_MAX && /^[A-Za-z0-9._-]+$/.test(rawCode) ? rawCode : "internal";
+	return { code, message: "Prompt submission failed." };
+}
+
+export function createPromptReconciliation(options: { now?: () => number } = {}): PromptReconciliation {
+	const now = options.now ?? Date.now;
+	const records = new Map<string, PromptReconciliationRecord>();
+	const clientRefIndex = new Map<string, string>();
+	const reservedClientRefs = new Set<string>();
+	// One identity-bound entry per admission. Transitions consume exactly one
+	// matching entry and stale/duplicate transitions are no-ops, so reservation
+	// accounting is exactly-once even under repeated calls.
+	const reservations: Array<string | undefined> = [];
+	const keyOf = (correlation: PromptCorrelation) => `${correlation.commandId}:${correlation.turnId}`;
+
+	const remove = (key: string) => {
+		const record = records.get(key);
+		if (!record) return;
+		records.delete(key);
+		if (record.clientRef !== undefined && clientRefIndex.get(record.clientRef) === key)
+			clientRefIndex.delete(record.clientRef);
+	};
+
+	const cleanup = () => {
+		const at = now();
+		for (const [key, record] of records)
+			if (record.terminalAt !== undefined && record.terminalAt + PROMPT_RECONCILIATION_TERMINAL_TTL_MS <= at)
+				remove(key);
+		const terminalEntries = [...records.entries()].filter(([, record]) => record.terminalAt !== undefined);
+		if (terminalEntries.length <= PROMPT_RECONCILIATION_TERMINAL_CAPACITY) return;
+		// Evict oldest-terminal-first by terminalAt, not acceptance/insertion
+		// order; the stable sort keeps acceptance order for exact ties.
+		terminalEntries.sort((a, b) => (a[1].terminalAt as number) - (b[1].terminalAt as number));
+		for (const [key] of terminalEntries.slice(0, terminalEntries.length - PROMPT_RECONCILIATION_TERMINAL_CAPACITY))
+			remove(key);
+	};
+
+	const activeCount = () => {
+		let count = 0;
+		for (const record of records.values()) if (record.terminalAt === undefined) count++;
+		return count;
+	};
+
+	/** Consume one reservation matching clientRef; no-op when none is outstanding. */
+	const consumeReservation = (clientRef?: string) => {
+		const index = reservations.indexOf(clientRef);
+		if (index === -1) return;
+		reservations.splice(index, 1);
+		if (clientRef !== undefined && !reservations.includes(clientRef)) reservedClientRefs.delete(clientRef);
+	};
+
+	const admit = (clientRef?: string) => {
+		cleanup();
+		if (clientRef !== undefined && (clientRefIndex.has(clientRef) || reservedClientRefs.has(clientRef)))
+			throw Object.assign(
+				new Error("A prompt with this clientRef is already retained; never reuse a clientRef for retry."),
+				{ code: "client_ref_conflict" },
+			);
+		if (activeCount() + reservations.length >= PROMPT_RECONCILIATION_ACTIVE_CAPACITY)
+			throw Object.assign(new Error("Too many active prompt submissions; reconcile or await terminal state."), {
+				code: "reconciliation_capacity",
+			});
+		reservations.push(clientRef);
+		if (clientRef !== undefined) reservedClientRefs.add(clientRef);
+	};
+
+	const releaseAdmission = (clientRef?: string) => {
+		consumeReservation(clientRef);
+	};
+
+	const noteAccepted = (correlation: PromptCorrelation, clientRef?: string) => {
+		cleanup();
+		consumeReservation(clientRef);
+		const at = now();
+		const key = keyOf(correlation);
+		records.set(key, {
+			commandId: correlation.commandId,
+			turnId: correlation.turnId,
+			...(clientRef !== undefined ? { clientRef } : {}),
+			status: "accepted",
+			acceptedAt: at,
+		});
+		if (clientRef !== undefined) clientRefIndex.set(clientRef, key);
+	};
+
+	const noteTransition = (
+		correlation: PromptCorrelation | undefined,
+		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
+	) => {
+		if (!correlation) return;
+		const record = records.get(keyOf(correlation));
+		if (!record || record.terminalAt !== undefined) return;
+		if (frame.type === "agent_start") {
+			if (record.status === "accepted") {
+				record.status = "in_flight";
+				record.startedAt = now();
+			}
+			return;
+		}
+		record.terminalAt = now();
+		if (frame.type === "agent_failed") {
+			record.status = "failed";
+			record.error = sanitizePromptFailure(frame.error);
+		} else {
+			record.status = "terminal_ok";
+		}
+		// Enforce terminal retention immediately at settlement, not lazily.
+		cleanup();
+	};
+
+	const lookup = (selector: { commandId?: string; turnId?: string; clientRef?: string }): TurnPromptReconciliation => {
+		cleanup();
+		const key =
+			selector.clientRef !== undefined
+				? clientRefIndex.get(selector.clientRef)
+				: selector.commandId !== undefined && selector.turnId !== undefined
+					? keyOf({ commandId: selector.commandId, turnId: selector.turnId })
+					: undefined;
+		const record = key === undefined ? undefined : records.get(key);
+		if (!record) return { status: "unknown" };
+		const identity = {
+			commandId: record.commandId,
+			turnId: record.turnId,
+			...(record.clientRef !== undefined ? { clientRef: record.clientRef } : {}),
+			acceptedAt: record.acceptedAt,
+		};
+		if (record.status === "accepted") return { status: "accepted", ...identity };
+		if (record.status === "in_flight")
+			return { status: "in_flight", ...identity, startedAt: record.startedAt as number };
+		const terminal = {
+			...identity,
+			...(record.startedAt !== undefined ? { startedAt: record.startedAt } : {}),
+			terminalAt: record.terminalAt as number,
+		};
+		if (record.status === "terminal_ok") return { status: "terminal_ok", ...terminal };
+		return { status: "failed", ...terminal, error: record.error ?? sanitizePromptFailure(undefined) };
+	};
+
+	return { admit, releaseAdmission, noteAccepted, noteTransition, lookup, cleanup, activeCount };
+}

package/src/sdk/bus/recent-activity.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { verifyOwnerOnlyPathSecurity } from "@gajae-code/natives";
 import { getAgentDir, getSessionsDir } from "@gajae-code/utils";
-import { FileSessionStorage } from "../../session/session-storage";
+import { FileSessionStorage, type SessionStorageSnapshot } from "../../session/session-storage";
 import {
 	type LogicalSessionCandidate,
 	listManagedSessionCandidates,
@@ -58,25 +58,52 @@ export interface RecentActivityDeps {
 	readInitialLines?: (file: string, maxLines: number) => string[];
 }
 
+class ManagedCandidateChangedError extends Error {}
+class ManagedCandidateUnavailableError extends Error {}
+
+const CHANGED_CANDIDATE_WARNING = "Ignored managed session candidate that changed during inspection.";
+
+function isAppendExtension(bytes: Uint8Array, candidate: LogicalSessionCandidate): boolean {
+	return (
+		bytes.byteLength >= candidate.identity.size &&
+		createHash("sha256").update(bytes.subarray(0, candidate.identity.size)).digest("hex") ===
+			candidate.identity.sha256
+	);
+}
+
 function readCandidateInitialLines(
 	candidate: LogicalSessionCandidate,
 	readInitialLines: ((file: string, maxLines: number) => string[]) | undefined,
+	appendBase?: LogicalSessionCandidate,
 ): string[] {
 	if (readInitialLines) return readInitialLines(candidate.path, 8);
 	if (candidate.provenance !== "legacy") {
 		const security = verifyOwnerOnlyPathSecurity(candidate.path, "file");
-		if (!security.ok) throw new Error(`Managed session metadata path is unsafe: ${security.code}`);
+		if (!security.ok) throw new ManagedCandidateUnavailableError("Managed session metadata path is unsafe.");
 	}
-	const snapshot = new FileSessionStorage().readSnapshotSync(candidate.path);
+	let snapshot: SessionStorageSnapshot;
+	try {
+		snapshot = new FileSessionStorage().readSnapshotSync(candidate.path);
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT" || code === "ELOOP" || code === "ENOTDIR")
+			throw new ManagedCandidateUnavailableError("Managed session metadata is unavailable.");
+		throw error;
+	}
+	const sameFile = snapshot.stat.dev === candidate.identity.dev && snapshot.stat.ino === candidate.identity.ino;
 	const digest = createHash("sha256").update(snapshot.bytes).digest("hex");
-	if (
-		snapshot.stat.dev !== candidate.identity.dev ||
-		snapshot.stat.ino !== candidate.identity.ino ||
-		snapshot.stat.size !== candidate.identity.size ||
-		snapshot.stat.mtimeNs !== candidate.identity.mtimeNs ||
-		digest !== candidate.identity.sha256
-	)
-		throw new Error("Managed session changed after ownership was verified.");
+	const exactIdentity =
+		sameFile &&
+		snapshot.stat.size === candidate.identity.size &&
+		snapshot.stat.mtimeNs === candidate.identity.mtimeNs &&
+		digest === candidate.identity.sha256;
+	if (appendBase && (!sameFile || !isAppendExtension(snapshot.bytes, appendBase)))
+		throw new ManagedCandidateUnavailableError("Managed session no longer extends the verified transcript.");
+	if (!exactIdentity) {
+		if (sameFile && isAppendExtension(snapshot.bytes, candidate))
+			throw new ManagedCandidateChangedError("Managed session was appended after ownership was verified.");
+		throw new ManagedCandidateUnavailableError("Managed session changed without an append-only extension.");
+	}
 	return Buffer.from(snapshot.bytes).toString("utf8").split("\n").slice(0, 8);
 }
 
@@ -227,13 +254,13 @@ export async function listRecentSessions(deps: RecentActivityDeps): Promise<List
 	const resolved = await resolveRecentScopes(deps);
 	if (resolved.kind === "error") return resolved;
 	const warnings = [...resolved.warnings];
-	const candidates: LogicalSessionCandidate[] = [];
+	const candidates: Array<{ scope: ManagedSessionScope; candidate: LogicalSessionCandidate }> = [];
 	for (const scope of resolved.scopes) {
 		const listed = await listManagedSessionCandidates({ scope });
 		if (listed.kind !== "complete") {
 			return { kind: "error", code: "managed_scan_failed", message: listed.message };
 		}
-		candidates.push(...listed.owned);
+		candidates.push(...listed.owned.map(candidate => ({ scope, candidate })));
 		warnings.push(
 			...listed.invalid
 				.filter(
@@ -245,28 +272,65 @@ export async function listRecentSessions(deps: RecentActivityDeps): Promise<List
 	}
 
 	const entries: RecentSessionEntry[] = [];
-	for (const candidate of candidates) {
-		let initialLines: string[];
+	for (const { scope, candidate } of candidates) {
+		let selected = candidate;
+		let initialLines: string[] | undefined;
 		try {
-			initialLines = readCandidateInitialLines(candidate, readInitialLines);
+			initialLines = readCandidateInitialLines(selected, readInitialLines);
 		} catch (error) {
-			return {
-				kind: "error",
-				code: "managed_scan_failed",
-				message: `Could not read managed session metadata: ${error instanceof Error ? error.message : String(error)}`,
-			};
+			if (error instanceof ManagedCandidateChangedError) {
+				const refreshed = await listManagedSessionCandidates({ scope });
+				if (refreshed.kind !== "complete")
+					return { kind: "error", code: "managed_scan_failed", message: refreshed.message };
+				const sameFile = refreshed.owned.find(
+					current =>
+						path.resolve(current.path) === path.resolve(candidate.path) &&
+						current.identity.dev === candidate.identity.dev &&
+						current.identity.ino === candidate.identity.ino,
+				);
+				if (sameFile) {
+					try {
+						initialLines = readCandidateInitialLines(sameFile, readInitialLines, candidate);
+						selected = sameFile;
+					} catch (retryError) {
+						if (
+							!(retryError instanceof ManagedCandidateChangedError) &&
+							!(retryError instanceof ManagedCandidateUnavailableError)
+						)
+							return {
+								kind: "error",
+								code: "managed_scan_failed",
+								message: `Could not read managed session metadata: ${
+									retryError instanceof Error ? retryError.message : String(retryError)
+								}`,
+							};
+					}
+				}
+			} else if (!(error instanceof ManagedCandidateUnavailableError)) {
+				return {
+					kind: "error",
+					code: "managed_scan_failed",
+					message: `Could not read managed session metadata: ${
+						error instanceof Error ? error.message : String(error)
+					}`,
+				};
+			}
+			if (!initialLines) {
+				warnings.push(CHANGED_CANDIDATE_WARNING);
+				continue;
+			}
 		}
 		const meta = headerMeta(initialLines[0]);
 		const internal = isInternalSession(initialLines);
 		if (internal && !includeInternal) continue;
 		entries.push({
-			sessionId: candidate.sessionId,
-			path: candidate.cwd,
+			sessionId: selected.sessionId,
+			path: selected.cwd,
 			branch: meta.branch,
 			title: meta.title,
-			sessionStateFile: candidate.path,
-			mtimeMs: candidate.identity.mtimeMs,
-			currentTerminal: breadcrumbs.has(path.resolve(candidate.path)) || undefined,
+			sessionStateFile: selected.path,
+			mtimeMs: selected.identity.mtimeMs,
+			currentTerminal: breadcrumbs.has(path.resolve(selected.path)) || undefined,
 			internal: internal || undefined,
 		});
 	}

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -26,7 +26,17 @@ export const NOTIFICATION_PROTOCOL_VERSION = 3;
  * legacy stopped-lock reclamation in generation 14, Windows expected-identity
  * ACL verification and repair in generation 15, identity-fenced stale endpoint
  * startup recovery in generation 16, Telegram topic recovery authority fencing
- * in generation 17, and fail-closed blank-token validation plus lifecycle-startup
- * stop fencing in generation 18.
+ * in generation 17, fail-closed blank-token validation plus lifecycle-startup
+ * stop fencing in generation 18, recommended ask metadata rendering in
+ * generation 19, authoritative terminal session-close delivery and cleanup
+ * fencing, attested generation-bearing pre-incarnation owner handoff in
+ * generation 20, guarded modern generation-absent predecessor signaling in
+ * generation 21, dead Windows v0.10 owner replacement in generation 22, and
+ * retained native cleanup authority revalidation in generation 23, and typed
+ * retained exact-unlink cleanup authority acceptance (concrete detached
+ * quarantine plus proven canonical absence) in generation 24.
+ * Generation 25 adds startup dead-root prune + leak-artifact self-heal
+ * on TelegramNotificationDaemon.run (#2958). Generation 26 adds bounded reload
+ * cooldown and lazy Telegram topic lifecycle safeguards (#2956, #2960, #2984).
  */
-export const DAEMON_GENERATION = 18;
+export const DAEMON_GENERATION = 26;