@gajae-code/coding-agent 0.13.0 → 0.13.1

package/src/sdk/bus/kind-aware-reconciliation.ts

@@ -5,6 +5,8 @@
 
 import { sanitizePromptFailure } from "../prompt-failure";
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
+import { sanitizeTurnResultContent, type TurnResultContent, type TurnResultPage } from "../turn-result";
+
 import {
 	PROMPT_RECONCILIATION_ACTIVE_CAPACITY,
 	PROMPT_RECONCILIATION_TERMINAL_CAPACITY,
@@ -17,6 +19,7 @@ export type { ReconciliationKind };
 
 export interface KindCorrelation extends PromptCorrelation {
 	kind: ReconciliationKind;
+	content?: TurnResultContent;
 }
 
 export interface KindAwareReconciliation {
@@ -31,7 +34,9 @@ export interface KindAwareReconciliation {
 	noteTransition(
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
-		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
+		frame:
+			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
 	): Promise<void>;
 	claimPendingOutcome(
 		correlation: PromptCorrelation,
@@ -41,12 +46,17 @@ export interface KindAwareReconciliation {
 		correlation: PromptCorrelation,
 		outcome?: SdkPromptTerminalOutcome,
 		recordError?: { code: string; message: string },
+		content?: unknown,
 	): Promise<void>;
 	peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
 	lookup(
 		kind: ReconciliationKind,
 		selector: { commandId?: string; turnId?: string; clientRef?: string },
 	): TurnPromptReconciliation;
+	lookupResult(
+		kind: ReconciliationKind,
+		selector: { commandId?: string; turnId?: string; clientRef?: string },
+	): TurnResultPage;
 	cleanup(): void;
 	activeCount(kind: ReconciliationKind): number;
 	/** Hydrate from durable store (call once at session host start). */
@@ -190,7 +200,9 @@ export function createKindAwareReconciliation(
 	const noteTransition = async (
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
-		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
+		frame:
+			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
 	) => {
 		if (!correlation) return;
 		await queueMutation(candidate => {
@@ -214,9 +226,13 @@ export function createKindAwareReconciliation(
 				if (record.status !== "accepted") return { value: undefined, changed: false };
 				record.status = "in_flight";
 				record.startedAt = now();
+				if (frame.content) record.content = sanitizeTurnResultContent(frame.content.text);
+
 				return { value: undefined, changed: true };
 			}
 			record.terminalAt = now();
+			if (frame.content) record.content = sanitizeTurnResultContent(frame.content.text);
+
 			if (frame.type === "agent_failed") {
 				record.status = "failed";
 				record.error = sanitizePromptFailure(frame.error);
@@ -243,6 +259,7 @@ export function createKindAwareReconciliation(
 		correlation: PromptCorrelation,
 		outcome?: SdkPromptTerminalOutcome,
 		recordError?: { code: string; message: string },
+		content?: unknown,
 	) => {
 		await queueMutation(candidate => {
 			const record = candidate.get(keyOf("prompt", correlation));
@@ -254,6 +271,7 @@ export function createKindAwareReconciliation(
 				record.status = "failed";
 				record.error = recordError ?? { code: finalOutcome.code, message: finalOutcome.message };
 			} else record.status = "terminal_ok";
+			record.content = sanitizeTurnResultContent(content);
 			record.outcome = finalOutcome;
 			record.pendingOutcome = undefined;
 			cleanupRecords(candidate);
@@ -301,6 +319,37 @@ export function createKindAwareReconciliation(
 		return { status: "failed", ...terminal, error: record.error ?? sanitizePromptFailure(undefined) };
 	};
 
+	const lookupResult = (
+		kind: ReconciliationKind,
+		selector: { commandId?: string; turnId?: string; clientRef?: string },
+	): TurnResultPage => {
+		cleanup();
+		const key =
+			selector.clientRef !== undefined
+				? clientRefIndex.get(refKey(kind, selector.clientRef))
+				: selector.commandId !== undefined && selector.turnId !== undefined
+					? keyOf(kind, { commandId: selector.commandId, turnId: selector.turnId })
+					: undefined;
+		const record = key === undefined ? undefined : records.get(key);
+		if (!record) return { status: "unknown" };
+		const identity = {
+			kind: record.kind,
+			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 };
+		const terminal = {
+			...identity,
+			...(record.startedAt !== undefined ? { startedAt: record.startedAt } : {}),
+			terminalAt: record.terminalAt as number,
+			...(record.content !== undefined ? { content: record.content } : {}),
+		};
+		if (record.status === "terminal_ok") return { status: "terminal_ok", ...terminal };
+		return { status: "failed", ...terminal, error: record.error ?? sanitizePromptFailure(undefined) };
+	};
 	const hydrateFromStore = async () => {
 		if (!store) return;
 		const run = async () => {
@@ -328,6 +377,7 @@ export function createKindAwareReconciliation(
 		finalizePromptOutcome,
 		peekPendingOutcome,
 		lookup,
+		lookupResult,
 		cleanup,
 		activeCount,
 		hydrateFromStore,

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

@@ -883,12 +883,12 @@ export async function checkNotificationHealth(opts: HealthOptions): Promise<Noti
 			// `acquireDaemonOwnership` then answers `provisional`, which `ensureTelegramDaemonRunning`
 			// reports as `blocked_identity`: no transport is ever attached and no
 			// notification is ever published, while the owner keeps heartbeating. Reporting
-			// that as OK is what makes the outage invisible; the generation is inventory
-			// metadata that never forces a reload on its own, so the operator has to.
+			// that as OK is what makes the outage invisible. Recovery is platform-dependent,
+			// so health identifies the condition without prescribing an unsupported command.
 			checks.push({
 				name: "daemon",
 				level: "warn",
-				detail: `daemon pid ${daemon.pid} serves generation ${daemon.generation ?? "unknown"} but this build attaches only to generation ${daemon.currentGeneration}; it cannot attach a session transport — run \`gjc daemon reload\``,
+				detail: `daemon pid ${daemon.pid} serves generation ${daemon.generation ?? "unknown"} but this build attaches only to generation ${daemon.currentGeneration}; it cannot attach a session transport — inspect daemon lifecycle status before attempting recovery`,
 			});
 		} else {
 			checks.push({ name: "daemon", level: "ok", detail: `daemon pid ${daemon.pid} alive with a fresh heartbeat` });

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

@@ -12,6 +12,8 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome } from "../prompt-status";
+import { TURN_RESULT_CONTENT_MAX_BYTES, type TurnResultContent } from "../turn-result";
+
 import type { PromptCorrelation } from "./prompt-reconciliation";
 
 export const RECONCILIATION_STORE_VERSION = 1;
@@ -32,6 +34,7 @@ export interface DurableReconciliationRecord extends PromptCorrelation {
 	pendingOutcome?: SdkPromptTerminalOutcome;
 	/** Skill-only safe token; never skill args bodies. */
 	skillName?: string;
+	content?: TurnResultContent;
 }
 
 export interface ReconciliationStoreDocument {
@@ -112,6 +115,19 @@ function isValidRecord(value: unknown): boolean {
 		if (!isRecord(value.error)) return false;
 		if (typeof value.error.code !== "string" || typeof value.error.message !== "string") return false;
 	}
+	if (value.content !== undefined) {
+		if (
+			!isRecord(value.content) ||
+			value.content.version !== 1 ||
+			value.content.type !== "text" ||
+			typeof value.content.text !== "string" ||
+			typeof value.content.byteLength !== "number" ||
+			typeof value.content.truncated !== "boolean" ||
+			new TextEncoder().encode(value.content.text).length !== value.content.byteLength ||
+			value.content.byteLength > TURN_RESULT_CONTENT_MAX_BYTES
+		)
+			return false;
+	}
 	return [outcome, pendingOutcome].every(candidate => {
 		if (candidate === undefined) return true;
 		if (!isRecord(candidate)) return false;

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

@@ -95,9 +95,18 @@ export const NOTIFICATION_PROTOCOL_VERSION = 3;
  * the exact grace deadline when a failed archive publication rolls back.
  * Generation 59 publishes the owner's attached OPEN-socket count in the
  * heartbeat sidecar so `gjc notify health` can report a live daemon that is
- * attached to no registered endpoint (#4128).
+ * attached to no registered endpoint (#4128). Generation 60 contains transient
+ * heartbeat-sidecar publication failures: a Windows EPERM/EACCES/EBUSY on the
+ * sidecar rename is retried bounded under the ownership-lock fence and an
+ * exhausted publication keeps the daemon alive as `publish_failed` instead of
+ * escaping as an uncaught exception, while only a proven state/lock mismatch
+ * (`not_owner`) stops the owner (#4200). Generation 61 keeps authenticated
+ * same-session transports attached while predecessor archival converges and
+ * settles non-forum close responses. Generation 62 rejects replay-gap
+ * authority claims that do not match the requested cursor, answer bounds,
+ * and retained replay suffix.
  */
-export const DAEMON_GENERATION = 59;
+export const DAEMON_GENERATION = 62;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 5

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

@@ -531,7 +531,7 @@ function topicArchiveSettled(response: unknown): boolean {
 	if (result.ok === true && result.result === true) return true;
 	if (result.ok !== false || result.error_code !== 400 || typeof result.description !== "string") return false;
 	const description = result.description.trim();
-	return /^(?:Bad Request: )?(?:TOPIC_NOT_FOUND|THREAD_NOT_FOUND|topic (?:already|is already) closed|message thread (?:not found|is not modified))$/i.test(
+	return /^(?:Bad Request: )?(?:TOPIC_NOT_FOUND|THREAD_NOT_FOUND|the chat is not a (?:supergroup )?forum|topic (?:already|is already) closed|message thread (?:not found|is not modified))$/i.test(
 		description,
 	);
 }
@@ -1344,6 +1344,30 @@ export async function readOwnerFreshnessSnapshot(input: {
 	};
 }
 
+/** Outcome of a steady heartbeat sidecar renewal. */
+export type OwnerHeartbeatSidecarRenewal =
+	/** The sidecar was published under a still-matching ownership lock. */
+	| "renewed"
+	/** This process no longer matches the persisted state/lock; stop renewing. */
+	| "not_owner"
+	/**
+	 * Ownership still held, but the sidecar publication failed (e.g. a transient
+	 * Windows EPERM/EBUSY while another process holds the destination). The
+	 * daemon must stay alive and publish again on the next cycle (#4200); a
+	 * persistently failing publication eventually stales the heartbeat for
+	 * outside observers, whose takeover then surfaces here as `not_owner`.
+	 */
+	| "publish_failed";
+
+const HEARTBEAT_SIDECAR_PUBLISH_ATTEMPTS = 4;
+const HEARTBEAT_SIDECAR_PUBLISH_BACKOFF_MS = 25;
+
+/** Windows sharing/permission failures from antivirus, indexing, or external file locks. */
+function isTransientSidecarPublishError(error: unknown): boolean {
+	const code = (error as { code?: unknown } | null)?.code;
+	return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+
 /** Marker-free steady heartbeat renewal. The final lock reread fences a stale writer. */
 export async function renewOwnerHeartbeatSidecar(input: {
 	settings: Settings;
@@ -1359,7 +1383,7 @@ export async function renewOwnerHeartbeatSidecar(input: {
 	 * rather than falsely claiming zero attachments.
 	 */
 	attachedEndpoints?: number;
-}): Promise<boolean> {
+}): Promise<OwnerHeartbeatSidecarRenewal> {
 	const fsImpl = input.fs ?? nodeFs;
 	const paths = daemonPaths(input.settings.getAgentDir());
 	const state = await readJson<DaemonState>(fsImpl, paths.state);
@@ -1376,7 +1400,7 @@ export async function renewOwnerHeartbeatSidecar(input: {
 		state.acquisitionId !== acquisitionId ||
 		state.stoppedAt !== undefined
 	)
-		return false;
+		return "not_owner";
 	const sidecar: OwnerHeartbeatSidecar = {
 		pid,
 		incarnation,
@@ -1386,22 +1410,48 @@ export async function renewOwnerHeartbeatSidecar(input: {
 		...(validAttachedEndpointCount(input.attachedEndpoints) ? { attachedEndpoints: input.attachedEndpoints } : {}),
 	};
 	const tmp = `${paths.heartbeat}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-	await fsImpl.writeFile(tmp, `${JSON.stringify(sidecar, null, 2)}\n`, { mode: 0o600 });
-	await fsImpl.chmod(tmp, 0o600).catch(() => undefined);
+	try {
+		await fsImpl.writeFile(tmp, `${JSON.stringify(sidecar, null, 2)}\n`, { mode: 0o600 });
+		await fsImpl.chmod(tmp, 0o600).catch(() => undefined);
+	} catch (error) {
+		// One failed staging write must not terminate the daemon (#4200).
+		await fsImpl.unlink(tmp).catch(() => undefined);
+		logger.warn(`notifications: heartbeat sidecar staging failed: ${sanitizeDiagnostic(String(error))}`);
+		return "publish_failed";
+	}
 	const lock = await readOwnershipLock(fsImpl, paths.lock);
 	if (!ownershipLockMatchesState(lock, state)) {
 		await fsImpl.unlink(tmp).catch(() => undefined);
-		return false;
+		return "not_owner";
 	}
-	// Revalidate the exact lock after the temporary sidecar exists so a stale
-	// writer cannot publish after ownership moved during its write.
-	const finalLock = await readOwnershipLock(fsImpl, paths.lock);
-	if (!ownershipLockMatchesState(finalLock, state)) {
-		await fsImpl.unlink(tmp).catch(() => undefined);
-		return false;
+	for (let attempt = 1; ; attempt++) {
+		// Revalidate the exact lock after the temporary sidecar exists — and again
+		// before every retry — so a stale writer cannot publish after ownership
+		// moved during its write or its backoff.
+		const finalLock = await readOwnershipLock(fsImpl, paths.lock);
+		if (!ownershipLockMatchesState(finalLock, state)) {
+			await fsImpl.unlink(tmp).catch(() => undefined);
+			return "not_owner";
+		}
+		try {
+			await fsImpl.rename(tmp, paths.heartbeat);
+			return "renewed";
+		} catch (error) {
+			// Windows: a transient external lock on the destination (antivirus,
+			// indexer) surfaces as EPERM on rename and used to escape as an
+			// uncaught exception that killed the whole daemon (#4200). Retry a
+			// bounded number of times under the lock fence, then keep the daemon
+			// alive and let the next heartbeat cycle publish.
+			if (attempt >= HEARTBEAT_SIDECAR_PUBLISH_ATTEMPTS || !isTransientSidecarPublishError(error)) {
+				await fsImpl.unlink(tmp).catch(() => undefined);
+				logger.warn(
+					`notifications: heartbeat sidecar publication failed after ${attempt} attempt(s): ${sanitizeDiagnostic(String(error))}`,
+				);
+				return "publish_failed";
+			}
+			await Bun.sleep(HEARTBEAT_SIDECAR_PUBLISH_BACKOFF_MS * attempt);
+		}
 	}
-	await fsImpl.rename(tmp, paths.heartbeat);
-	return true;
 }
 
 function ownershipLockMatchesStoppedState(
@@ -3106,17 +3156,21 @@ export async function renewDaemonHeartbeat(input: {
 		// The durable sidecar must exist and match the rebound ownership lock before
 		// any observer can see ownershipPhase:"ready". A provisional state may be
 		// fresh, but readiness waiters categorically refuse to attach to it.
+		// The initial proof is strict: only a real publication counts. A
+		// `publish_failed` here has no durable sidecar, so readiness must not be
+		// claimed and the provisional ownership retires exactly as before.
 		let sidecarRenewed = false;
 		try {
-			sidecarRenewed = await renewOwnerHeartbeatSidecar({
-				settings: input.settings,
-				ownerId: input.ownerId,
-				acquisitionId,
-				fs: fsImpl,
-				now: () => heartbeatAt,
-				pid,
-				pidIncarnation: input.pidIncarnation,
-			});
+			sidecarRenewed =
+				(await renewOwnerHeartbeatSidecar({
+					settings: input.settings,
+					ownerId: input.ownerId,
+					acquisitionId,
+					fs: fsImpl,
+					now: () => heartbeatAt,
+					pid,
+					pidIncarnation: input.pidIncarnation,
+				})) === "renewed";
 		} catch {
 			sidecarRenewed = false;
 		}
@@ -4764,6 +4818,8 @@ interface SessionSocket {
 	pingTimer: ReturnType<typeof setInterval> | undefined;
 	/** Correlation id for the startup replay barrier. */
 	replayId: string;
+	/** Sequence cursor sent by the current startup replay request. */
+	replaySinceSeq: number;
 	/** Queues live frames until startup replay is applied. */
 	replayPending: boolean;
 	replayQueue: Record<string, unknown>[];
@@ -6174,8 +6230,12 @@ export class TelegramNotificationDaemon {
 					const endpointKey = endpointGenerationKey(endpoint.url, endpoint.token);
 					const connected = this.sessions.get(sessionId);
 					if (connected) {
+						const recoveryRejectedAfterArchive =
+							connected.recoveryLease?.state === "rejected" &&
+							this.topics.get(sessionId)?.authorityState === "inactive";
 						if (
 							connected.endpointKey !== endpointKey ||
+							recoveryRejectedAfterArchive ||
 							(connected.ws.readyState === WebSocket.CONNECTING &&
 								this.runtime.now() - connected.connectingSince >= CONNECTING_RECONNECT_MS)
 						)
@@ -6265,6 +6325,7 @@ export class TelegramNotificationDaemon {
 			awaitingNonce: undefined,
 			pingTimer: undefined,
 			replayId: `telegram-startup-replay:${sessionId}`,
+			replaySinceSeq: 0,
 			replayPending: false,
 			replayQueue: [],
 		};
@@ -6283,6 +6344,7 @@ export class TelegramNotificationDaemon {
 			const persistedTopic = this.topics.get(sessionId);
 			const replayCursor =
 				persistedTopic?.endpointDigest === session.endpointDigest ? this.topics.replayCursor(sessionId) : undefined;
+			session.replaySinceSeq = replayCursor?.seq ?? 0;
 			if (session.ws.readyState === WebSocket.OPEN) {
 				try {
 					session.ws.send(
@@ -9714,7 +9776,7 @@ export class TelegramNotificationDaemon {
 		for (const session of this.sessions.values()) if (session.ws.readyState === WebSocket.OPEN) attached += 1;
 		return attached;
 	}
-	private async renewOwnershipHeartbeat(): Promise<boolean> {
+	private async renewOwnershipHeartbeat(): Promise<OwnerHeartbeatSidecarRenewal> {
 		return renewOwnerHeartbeatSidecar({
 			settings: this.opts.settings,
 			ownerId: this.opts.ownerId,
@@ -9736,7 +9798,10 @@ export class TelegramNotificationDaemon {
 			if (!this.running) return;
 			void this.runtime
 				.runExclusive("telegram-owner-heartbeat", async () => {
-					if (!(await this.renewOwnershipHeartbeat())) this.runtime.requestStop();
+					// `publish_failed` keeps the daemon alive: ownership is still held
+					// and the next interval republishes (#4200). Only a proven
+					// ownership loss stops the owner.
+					if ((await this.renewOwnershipHeartbeat()) === "not_owner") this.runtime.requestStop();
 				})
 				.catch(err => {
 					logger.warn(`notifications: ownership heartbeat failed: ${sanitizeDiagnostic(String(err))}`);
@@ -9944,7 +10009,6 @@ export class TelegramNotificationDaemon {
 				msg.generation >= 1 &&
 				Number.isSafeInteger(msg.lastSeq) &&
 				msg.lastSeq >= 0 &&
-				msg.gap === undefined &&
 				Array.isArray(msg.events) &&
 				msg.events.every((event: unknown) => event !== null && typeof event === "object" && !Array.isArray(event));
 			const replayed: Record<string, unknown>[] = replayValid
@@ -9963,7 +10027,34 @@ export class TelegramNotificationDaemon {
 				frame => typeof frame.sessionId !== "string" || !frame.sessionId.trim(),
 			);
 			const identityConflict = new Set(identities).size > 1;
-			if (!replayValid || malformedIdentity || identityConflict) {
+			const retainedAtOrBelowGap =
+				msg.gap !== null &&
+				typeof msg.gap === "object" &&
+				!Array.isArray(msg.gap) &&
+				Number.isSafeInteger(msg.gap.toSeq) &&
+				Array.isArray(msg.events) &&
+				(msg.events as Record<string, unknown>[]).some(
+					event =>
+						Number.isSafeInteger(event.seq) &&
+						(event.seq as number) >= 1 &&
+						(event.seq as number) <= msg.gap.toSeq,
+				);
+			const sequenceGapWithIdentityProof =
+				msg.gap !== null &&
+				typeof msg.gap === "object" &&
+				!Array.isArray(msg.gap) &&
+				msg.gap.kind === "sequence_gap" &&
+				Number.isSafeInteger(msg.gap.fromSeq) &&
+				Number.isSafeInteger(msg.gap.toSeq) &&
+				msg.gap.fromSeq === session.replaySinceSeq + 1 &&
+				msg.gap.fromSeq <= msg.gap.toSeq &&
+				msg.gap.toSeq <= msg.lastSeq &&
+				!retainedAtOrBelowGap &&
+				Array.isArray(msg.gap.resyncQueries) &&
+				msg.gap.resyncQueries.every((query: unknown) => typeof query === "string") &&
+				identityFrames.length > 0;
+			const gapAllowsRecovery = msg.gap === undefined || sequenceGapWithIdentityProof;
+			if (!replayValid || !gapAllowsRecovery || malformedIdentity || identityConflict) {
 				// A replay result is the admission proof. Never clear its barrier or drain
 				// queued frames after malformed/conflicting proof; the socket cannot fall
 				// back to transport-local config rekeying.
@@ -10005,6 +10096,17 @@ export class TelegramNotificationDaemon {
 			);
 			if (this.sessions.get(session.sessionId) !== session) return;
 			if (!recovered) {
+				const authorityState = this.topics.get(replayCandidateSessionId)?.authorityState;
+				if (
+					replayCandidateSessionId === session.sessionId &&
+					(authorityState === "archive_pending" || authorityState === "archive_exhausted")
+				) {
+					// The old topic remains fenced, but the authenticated live transport
+					// must stay attached while archive reconciliation retries.
+					session.replayQueue = [];
+					session.replayPending = false;
+					return;
+				}
 				if (session.hostGeneration === msg.generation && session.recoveryLease?.state !== "pending")
 					this.dropSession(session, "recovery_rejected");
 				return;
@@ -12389,7 +12491,7 @@ export class TelegramNotificationDaemon {
 			while (this.running) {
 				if (await this.controlStopRequested()) break;
 				if (
-					!(await renewOwnerHeartbeatSidecar({
+					(await renewOwnerHeartbeatSidecar({
 						settings: this.opts.settings,
 						ownerId: this.opts.ownerId,
 						acquisitionId: this.opts.ownerId,
@@ -12398,7 +12500,7 @@ export class TelegramNotificationDaemon {
 						pid: this.opts.pid ?? process.pid,
 						pidIncarnation: this.opts.pidIncarnation,
 						attachedEndpoints: this.attachedEndpointCount(),
-					}))
+					})) === "not_owner"
 				)
 					break;
 				await this.runScan();

package/src/sdk/bus/topic-registry.ts

@@ -213,7 +213,7 @@ export function emptyTopicRegistryState(): TopicRegistryState {
  */
 export function parseTopicRegistryState(value: unknown): TopicRegistryState | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const state = value as TopicRegistryState;
+	let state = value as TopicRegistryState;
 	if (state.version !== undefined && state.version !== 2) throw new Error("unsupported future Telegram topic state");
 	if (!state.topics || typeof state.topics !== "object" || Array.isArray(state.topics)) return undefined;
 	if (state.version === undefined) {
@@ -239,6 +239,26 @@ export function parseTopicRegistryState(value: unknown): TopicRegistryState | un
 
 	const isObject = (candidate: unknown): candidate is Record<string, unknown> =>
 		!!candidate && typeof candidate === "object" && !Array.isArray(candidate);
+	state = {
+		...state,
+		topics: Object.fromEntries(
+			Object.entries(state.topics).map(([sessionId, record]) => [
+				sessionId,
+				isObject(record) ? { ...record } : record,
+			]),
+		),
+		retiredTopics:
+			state.retiredTopics === undefined
+				? undefined
+				: Object.fromEntries(
+						Object.entries(state.retiredTopics).map(([sessionId, records]) => [
+							sessionId,
+							Array.isArray(records)
+								? records.map(record => (isObject(record) ? { ...record } : record))
+								: records,
+						]),
+					),
+	};
 	const validTimestamp = (candidate: unknown): candidate is number =>
 		typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0;
 	const validEpoch = (candidate: unknown): candidate is number =>
@@ -303,12 +323,19 @@ export function parseTopicRegistryState(value: unknown): TopicRegistryState | un
 			value => value !== undefined,
 		).length;
 		if (leaseFieldCount !== 0 && leaseFieldCount !== 3) malformed();
-		if (
-			raw.authorityState === "disconnect_grace"
-				? raw.disconnectGraceExpiresAt === undefined || raw.orphanedAt === undefined
-				: raw.disconnectGraceExpiresAt !== undefined
-		)
-			malformed();
+		if (raw.authorityState === "disconnect_grace") {
+			if (raw.disconnectGraceExpiresAt === undefined || raw.orphanedAt === undefined) malformed();
+		} else if (raw.disconnectGraceExpiresAt !== undefined) {
+			if (
+				raw.authorityState !== "archive_pending" &&
+				raw.authorityState !== "archive_exhausted" &&
+				raw.authorityState !== "inactive"
+			)
+				malformed();
+			// Older archive transitions retained the expired disconnect-grace marker,
+			// making the entire shared registry unreadable on the next daemon start.
+			delete raw.disconnectGraceExpiresAt;
+		}
 		const hasBinding = hasAnyBinding(raw);
 		const hasArchiveOnlyChatIdentity =
 			(raw.authorityState === "archive_pending" ||
@@ -333,11 +360,13 @@ export function parseTopicRegistryState(value: unknown): TopicRegistryState | un
 	for (const [sessionId, records] of Object.entries(state.retiredTopics ?? {})) {
 		if (!isValidBindingString(sessionId) || !Array.isArray(records)) malformed();
 		for (const [index, record] of records.entries()) {
-			parseTopicRegistryState({
+			const recordKey = `${sessionId}:retired:${index}`;
+			const parsed = parseTopicRegistryState({
 				version: 2,
 				registryGeneration: 0,
-				topics: { [`${sessionId}:retired:${index}`]: record },
+				topics: { [recordKey]: record },
 			});
+			records[index] = parsed?.topics[recordKey] ?? malformed();
 		}
 	}
 	for (const [sessionId, epoch] of Object.entries(state.fences ?? {}))

package/src/sdk/cli/session-cli.ts

@@ -11,6 +11,7 @@ import {
 	SdkClient,
 	SdkClientError,
 	SdkDiscoveryError,
+	type SdkSentRecord,
 } from "../client";
 import { PROMPT_CLIENT_REF_MAX_LENGTH } from "../prompt-status.js";
 import { validateAdapterControl } from "../protocol/adapter-validation";
@@ -962,13 +963,25 @@ async function runRawGlobal(
 		throw new SdkSessionCliError("invalid_input", "--idempotency-key is required for lifecycle operations.", 2);
 	const client = await connectBroker(agentDir);
 	try {
-		const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
-		const response = await client.global(operation, input, {
-			idempotencyKey,
-			...(timeoutMs === undefined ? {} : { timeoutMs }),
-			...(args.elevationRequestId === undefined ? {} : { elevationRequestId: args.elevationRequestId }),
-		});
-		return args.showEndpointCredential ? response : stripSecretFields(response);
+		try {
+			const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
+			const response = await client.global(operation, input, {
+				idempotencyKey,
+				...(timeoutMs === undefined ? {} : { timeoutMs }),
+				...(args.elevationRequestId === undefined ? {} : { elevationRequestId: args.elevationRequestId }),
+			});
+			return args.showEndpointCredential ? response : stripSecretFields(response);
+		} catch (error) {
+			if (
+				isLifecycleOperation(operation) &&
+				error instanceof SdkClientError &&
+				error.code === "uncertain_after_send" &&
+				error.details &&
+				typeof error.details === "object"
+			)
+				return stripSecretFields(await client.lookupLifecycle(error.details as SdkSentRecord));
+			throw error;
+		}
 	} finally {
 		await client.close();
 	}

package/src/sdk/client/discovery.ts

@@ -38,13 +38,34 @@ export type SdkSessionEndpointScope = "default" | "chat";
 function endpointDirectory(repo: string, scope: SdkSessionEndpointScope = "default"): string {
 	return scope === "chat" ? path.join(repo, ".gjc", "state", "chat", "sdk") : path.join(repo, ".gjc", "state", "sdk");
 }
+function isUsableSessionId(sessionId: string): boolean {
+	return (
+		sessionId.length > 0 &&
+		sessionId !== "." &&
+		sessionId !== ".." &&
+		!sessionId.includes("/") &&
+		!sessionId.includes("\\") &&
+		!sessionId.includes("\0")
+	);
+}
 
 function parseEndpoint(sessionId: string, file: string, value: unknown): SdkSessionEndpoint {
+	if (!isUsableSessionId(sessionId))
+		throw new SdkDiscoveryError(file, "SDK endpoint discovery filename does not contain a usable session id.");
 	if (!value || typeof value !== "object")
 		throw new SdkDiscoveryError(file, "SDK endpoint discovery record must be an object.");
-	const endpoint = value as { version?: unknown; url?: unknown; token?: unknown; pid?: unknown; stale?: unknown };
+	const endpoint = value as {
+		version?: unknown;
+		sessionId?: unknown;
+		url?: unknown;
+		token?: unknown;
+		pid?: unknown;
+		stale?: unknown;
+	};
 	if (typeof endpoint.version === "number" && endpoint.version > 1)
 		throw new SdkDiscoveryError(file, "Unsupported SDK endpoint discovery state version.");
+	if (endpoint.sessionId !== undefined && endpoint.sessionId !== sessionId)
+		throw new SdkDiscoveryError(file, "SDK endpoint discovery record session id does not match its filename.");
 	if (typeof endpoint.url !== "string" || !endpoint.url)
 		throw new SdkDiscoveryError(file, "SDK endpoint discovery record is invalid.");
 	const stale = typeof endpoint.stale === "boolean" ? endpoint.stale : undefined;
@@ -108,7 +129,7 @@ export async function readSdkSessionEndpoint(
 	sessionId: string,
 	scope: SdkSessionEndpointScope = "default",
 ): Promise<SdkSessionEndpoint | null> {
-	if (!sessionId || sessionId.includes(path.sep) || sessionId.includes("/")) return null;
+	if (!isUsableSessionId(sessionId)) return null;
 	const file = path.join(endpointDirectory(repo, scope), `${sessionId}.json`);
 	try {
 		return parseEndpoint(sessionId, file, JSON.parse(await fs.readFile(file, "utf8")));

package/src/sdk/host/query/cursor.ts

@@ -32,6 +32,10 @@ export interface CursorSelector {
 	resourceKind?: string;
 	resourceId?: string;
 	itemId?: string;
+	kind?: string;
+	clientRef?: string;
+	commandId?: string;
+	turnId?: string;
 }
 
 export interface CursorPosition {