@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/sdk/broker/worktree-occupancy.ts

@@ -0,0 +1,90 @@
+/**
+ * Which session currently holds a GJC-managed worktree.
+ *
+ * Both launch paths need this answer and must not disagree about it: the broker
+ * refuses a lifecycle launch into an occupied worktree, and the interactive
+ * `gjc --worktree` launch refuses for the same reason. Keeping one predicate —
+ * and one definition of "still running" — here prevents the two from drifting
+ * into different notions of liveness.
+ */
+
+import type * as NativeBindings from "@gajae-code/natives";
+import { resolveEquivalentPath } from "@gajae-code/utils";
+import { probeLinuxProcPidSync } from "../../gjc-runtime/linux-proc";
+import { processIncarnation } from "./process-incarnation";
+import type { IndexedSession } from "./session-index";
+
+function nativeLifecycle(): typeof NativeBindings {
+	return require("@gajae-code/natives") as typeof NativeBindings;
+}
+
+export type ProcessObservation = "alive" | "exited" | "uncertain";
+
+/** Only ESRCH or a changed, readable incarnation proves the owned process exited. */
+export function observeProcess(
+	pid: number,
+	expectedIncarnation: string | undefined,
+	readIncarnation: (pid: number) => string | undefined = processIncarnation,
+): ProcessObservation {
+	if (process.platform === "win32") {
+		try {
+			const reference = nativeLifecycle().Process.fromPid(pid);
+			if (reference?.status() !== "running") return "exited";
+		} catch {
+			return "uncertain";
+		}
+		if (!expectedIncarnation) return "uncertain";
+		const actualIncarnation = readIncarnation(pid);
+		if (!actualIncarnation) return "uncertain";
+		return actualIncarnation === expectedIncarnation ? "alive" : "exited";
+	}
+	try {
+		process.kill(pid, 0);
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "ESRCH" ? "exited" : "uncertain";
+	}
+	if (process.platform === "linux") {
+		const probe = probeLinuxProcPidSync(pid);
+		if (probe.kind === "live" && probe.state === "Z" && expectedIncarnation === `linux:${probe.startTime}`)
+			return "exited";
+	}
+	if (!expectedIncarnation) return "uncertain";
+	const actualIncarnation = readIncarnation(pid);
+	if (!actualIncarnation) return "uncertain";
+	return actualIncarnation === expectedIncarnation ? "alive" : "exited";
+}
+
+/**
+ * The id of a session still occupying `worktreePath`, or null when it is free.
+ *
+ * `ensureLaunchWorktree` reuses an existing worktree without asking whether
+ * anyone is in it, and an unnamed launch derives its directory deterministically
+ * from the repository's current branch. Two concurrent sessions in one
+ * repository therefore land in the same checkout and overwrite each other's
+ * files with no error.
+ *
+ * Only a process observed as definitively exited releases the worktree.
+ * `uncertain` counts as occupied: refusing a launch is recoverable by picking
+ * another worktree name, whereas two live sessions sharing a checkout corrupts
+ * work already done.
+ */
+export function worktreeOccupant(
+	sessions: readonly IndexedSession[],
+	worktreePath: string,
+	observe: (pid: number, expectedIncarnation: string | undefined) => ProcessObservation = observeProcess,
+): string | null {
+	// Session locators retain the canonical Git worktree root separately from the
+	// session cwd. A host may start below that root, and a launch plan may arrive
+	// through a symlink, so compare the root identity rather than the cwd spelling.
+	const target = resolveEquivalentPath(worktreePath);
+	for (const session of sessions) {
+		const sessionWorktreeRoot = session.locator.worktreeRoot;
+		if (session.terminal || typeof sessionWorktreeRoot !== "string" || sessionWorktreeRoot.length === 0) continue;
+		if (resolveEquivalentPath(sessionWorktreeRoot) !== target) continue;
+		// `live` is heartbeat-derived and can be stale. Only positive process-exit
+		// evidence releases a matching retained session's worktree.
+		if (observe(session.pid, session.hostIncarnation ?? session.processIncarnation) === "exited") continue;
+		return session.sessionId;
+	}
+	return null;
+}

package/src/sdk/bus/chat-daemon-control.ts

@@ -130,10 +130,13 @@ export type ChatDaemonAction = "stop" | "reload";
  * session-index lock every 2s; staleness retirement moved to a 30s sweep and
  * lease heartbeats no longer force an authority reconcile. A pre-upgrade owner
  * would retain the old hot polling loop, so replacement is required.
+ * Discord generation 72 / Slack generation 75 serialize same-generation
+ * successor attachment admission behind predecessor provider retirement, so a
+ * pre-upgrade owner cannot retain the queue race fixed by #5120.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 70,
-	slack: 73,
+	discord: 72,
+	slack: 75,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

package/src/sdk/bus/chat-daemon-runtime.ts

@@ -114,6 +114,10 @@ function readGeneration(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
 }
 
+function readSequence(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
 /**
  * What one representation of a frame states about an identity it owns.
  *
@@ -138,7 +142,7 @@ const ABSENT_IDENTITY: IdentityClaim<never> = { state: "absent" };
  */
 function identityClaim<T>(
 	frame: Record<string, unknown> | undefined,
-	key: "sessionId" | "generation" | "name" | "kind",
+	key: "sessionId" | "generation" | "name" | "kind" | "seq",
 	read: (value: unknown) => T | undefined,
 ): IdentityClaim<T> {
 	if (!frame || !Object.hasOwn(frame, key)) return ABSENT_IDENTITY;
@@ -232,11 +236,17 @@ function correlateFrame(frame: Record<string, unknown>): CorrelatedFrame | undef
 		identityClaim(payload, "generation", readGeneration),
 	);
 	if (!generation.ok) return undefined;
+	const seq = reconcileIdentity(
+		identityClaim(frame, "seq", readSequence),
+		identityClaim(payload, "seq", readSequence),
+	);
+	if (!seq.ok) return undefined;
 	return {
 		body,
 		name: envelopeName.value ?? bodyName,
 		sessionId: sessionId.value,
 		generation: generation.value,
+		seq: seq.value,
 	};
 }
 
@@ -248,6 +258,7 @@ export class ChatDaemonRuntime {
 	readonly #router: SessionRouter;
 	readonly #attachments = new Map<string, SessionAttachment>();
 	readonly #cleanupWork = new Map<string, Promise<void>>();
+	readonly #retirementWork = new Map<string, Promise<void>>();
 	readonly #attachmentBarriers = new Map<string, Promise<void>>();
 	#discord: DiscordNotificationDaemon | undefined;
 	#slack: SlackNotificationDaemon | undefined;
@@ -271,12 +282,18 @@ export class ChatDaemonRuntime {
 	}
 
 	async start(): Promise<void> {
-		if (this.#cleanupWork.size > 0) {
+		if (this.#cleanupWork.size > 0 || this.#retirementWork.size > 0) {
+			const retirements = [...this.#retirementWork.entries()];
 			const settled = await Promise.race([
-				Promise.allSettled([...this.#cleanupWork.values()]).then(() => true),
+				Promise.all([
+					Promise.allSettled([...this.#cleanupWork.values()]),
+					Promise.all(retirements.map(([, retirement]) => retirement)),
+				]).then(() => true),
 				Bun.sleep(5_000).then(() => false),
 			]);
 			if (!settled) throw new Error("Prior provider cleanup did not settle before chat daemon restart.");
+			for (const [sessionId, retirement] of retirements)
+				if (this.#retirementWork.get(sessionId) === retirement) this.#retirementWork.delete(sessionId);
 		}
 		this.#attachments.clear();
 		const retainedProvider =
@@ -418,6 +435,12 @@ export class ChatDaemonRuntime {
 		const discord = this.#discord;
 		const slack = this.#slack;
 		const barrier = (async () => {
+			const retirement = this.#retirementWork.get(attachment.sessionId);
+			if (retirement) {
+				await retirement;
+				if (this.#retirementWork.get(attachment.sessionId) === retirement)
+					this.#retirementWork.delete(attachment.sessionId);
+			}
 			await this.#cleanupWork.get(attachment.sessionId)?.catch(() => undefined);
 			await discord?.recoverCleanup(attachment.sessionId, attachment.generation);
 			await slack?.recoverCleanup(attachment.sessionId, attachment.generation);
@@ -441,13 +464,31 @@ export class ChatDaemonRuntime {
 	): Promise<void> {
 		if (this.#attachments.get(attachment.sessionId) !== attachment) return;
 		if (reason === "replaced_same_generation") {
-			await this.#discord?.retireAttachment(attachment.sessionId, attachment.generation);
-			await this.#slack?.retireAttachment(attachment.sessionId, attachment.generation);
+			const retirement = this.#trackRetirement(attachment);
+			this.#attachments.delete(attachment.sessionId);
+			await retirement;
+			return;
 		}
 		this.#attachments.delete(attachment.sessionId);
 		if (reason === "removed") await this.#trackCleanup(attachment);
 	}
 
+	#trackRetirement(attachment: SessionAttachment): Promise<void> {
+		const sessionId = attachment.sessionId;
+		const discord = this.#discord;
+		const slack = this.#slack;
+		const previous = this.#retirementWork.get(sessionId);
+		const work = (previous ?? Promise.resolve()).then(async () => {
+			// Capture the predecessor providers before stop() can clear the runtime
+			// fields. The successor barrier owns this promise until every retirement
+			// waiter settles, even when takeover overlaps worker shutdown.
+			await discord?.retireAttachment(sessionId, attachment.generation);
+			await slack?.retireAttachment(sessionId, attachment.generation);
+		});
+		this.#retirementWork.set(sessionId, work);
+		return work;
+	}
+
 	async #handleFrame(attachment: SessionAttachment, correlated: CorrelatedFrame): Promise<void> {
 		if (this.#attachments.get(attachment.sessionId) !== attachment) return;
 		await this.#attachmentBarriers.get(attachment.sessionId);

package/src/sdk/bus/index.ts

@@ -90,14 +90,17 @@ import { acpFinalTextFromMessage } from "../acp/final-text";
 import { ensureBroker } from "../broker/ensure";
 import { publishSessionHostRuntimeEvidence, type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { processIncarnation } from "../broker/process-incarnation";
-import { SessionIndex } from "../broker/session-index";
+import { resolveSessionLocator, SessionIndex } from "../broker/session-index";
 import {
 	CAP_GATED_FRAME_KINDS,
 	createSdkSurfaceFactory,
+	masterAttestationForEffectiveHost,
+	reattestMasterSessionIdentity,
 	type SessionSdkHost,
 	SessionSdkSessionRuntime,
 	shouldHostSdk,
 	TOOL_ACTIVITY_CAPABILITY,
+	verifyMasterCapabilityFrame,
 } from "../host";
 import { type AbortScope, type ControlSurface, dispatchControl, TypedControlError } from "../host/control";
 import { BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD } from "../host/control/runtime-gate";
@@ -4043,6 +4046,12 @@ export function createNotificationsExtension(
 		controller?: NotificationSessionController;
 		/** Whether this host mode can own the root SDK endpoint. Default: true. */
 		sdkHostModeSupported?: boolean;
+		/** In-memory master capability for private broker verification only. */
+		masterCapability?: string;
+		/** Opaque direct-role epoch this effective host may adopt. */
+		masterAttestationEpoch?: string;
+		/** Stable master lineage identity retained across session switches/branches. */
+		masterOwnerSessionId?: string;
 		onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
 		runBtwTurn?: (question: string, signal: AbortSignal) => Promise<{ replyText: string }>;
 		/** Observes settlement of optional session-branch startup after reconciliation completes. */
@@ -4103,6 +4112,7 @@ export function createNotificationsExtension(
 		  }
 		| undefined;
 	let extensionShuttingDown = false;
+	const consumedMasterNonces = new Map<string, number>();
 
 	async function ensureTelegramOwner(settings: Settings): Promise<"ready" | "blocked_identity"> {
 		if (!telegramTopicsEnabled()) return "blocked_identity";
@@ -4489,12 +4499,14 @@ export function createNotificationsExtension(
 
 	async function startSession(ctx: ExtensionContext): Promise<SessionStartResult> {
 		const id = sessionId(ctx);
-		const lifecycleRequestId = safeLifecycleRequestId(process.env.GJC_LIFECYCLE_REQUEST_ID);
 		const { settings, cfg, settingsAvailable } = resolveSettings(options.settings);
 		const notificationsEnabledForSession = controller.query(ctx).genericSessionEnabled;
 		const sdkEnabledForSession =
 			(options.sdkHostModeSupported ?? true) && shouldHostSdk(settings, isNotificationEligibleContext(ctx));
 		const lifecycleRequired = lifecycleStartupCapability !== undefined;
+		const lifecycleRequestId = lifecycleRequired
+			? safeLifecycleRequestId(lifecycleStartupCapability.lifecycleRequestId)
+			: safeLifecycleRequestId(process.env.GJC_LIFECYCLE_REQUEST_ID);
 		/** The broker-issued readiness intent for this exact lifecycle-managed session. */
 		const lifecycleReadiness = lifecycleStartupCapability?.readiness ?? "immediate";
 		const failLifecycleStartup = (
@@ -6588,6 +6600,7 @@ export function createNotificationsExtension(
 		}
 
 		sdkRuntime = new SessionSdkSessionRuntime({
+			masterOwnerSessionId: options.masterOwnerSessionId,
 			transport: {
 				sessionId: id,
 				stateRoot,
@@ -6607,6 +6620,13 @@ export function createNotificationsExtension(
 			...(activationGate ? { activationGate } : {}),
 			...(settings ? { settings } : {}),
 			...(configOverrides ? { configOverrides } : {}),
+			masterCapabilityVerify: frame =>
+				verifyMasterCapabilityFrame({
+					frame,
+					expectedCapability: options.masterCapability,
+					expectedEpoch: options.masterAttestationEpoch,
+					replay: consumedMasterNonces,
+				}),
 			connectionCapabilities: connectionId => hostCapCache.get(connectionId),
 			installProviderDefinitions,
 			onProviderDefinitionsRemoved: removeProviderDefinitions,
@@ -7751,6 +7771,8 @@ export function createNotificationsExtension(
 			}
 			const agentDir = lifecycleAgentDir ?? settings?.getAgentDir?.();
 			if (lifecycleRequired && !agentDir) throw new Error("Lifecycle SDK host requires an agent directory.");
+			if (lifecycleRequired && !lifecycleRequestId)
+				throw new Error("Lifecycle SDK host requires a capability-bound request identity.");
 
 			if (agentDir) {
 				try {
@@ -7758,13 +7780,36 @@ export function createNotificationsExtension(
 					throwIfLifecycleStopped();
 					const index = await new SessionIndex(agentDir).open();
 					throwIfLifecycleStopped();
-					const locator = { repo: path.resolve(ctx.cwd), stateRoot: endpointStateRoot };
-					const endpointMtimeMs = fs.statSync(path.join(endpointStateRoot, "sdk", `${id}.json`)).mtimeMs;
+					const locator = await resolveSessionLocator(ctx.cwd, endpointStateRoot);
+					const endpointPath = path.join(endpointStateRoot, "sdk", `${id}.json`);
+					const endpointMtimeMs = fs.statSync(endpointPath).mtimeMs;
+					const endpointIdentity = fs.statSync(endpointPath, { bigint: true });
+					const endpointFileId = `${endpointIdentity.dev}:${endpointIdentity.ino}`;
 					const hostProcessIncarnation = processIncarnation(process.pid);
+					const direct = await reattestMasterSessionIdentity({
+						index,
+						locator,
+						masterCapability: options.masterCapability,
+						attestationEpoch: options.masterAttestationEpoch,
+						ownerSessionId: options.masterOwnerSessionId,
+						sessionId: id,
+						pid: process.pid,
+						processIncarnation: hostProcessIncarnation,
+					});
+					throwIfLifecycleStopped();
 					await host.registerWithBroker({
 						// The endpoint is written before registration. Its exact mtime
 						// binds this index generation to that discovery record.
 						register: async input => {
+							const masterRole = masterAttestationForEffectiveHost({
+								masterCapability: options.masterCapability,
+								attestationEpoch: options.masterAttestationEpoch,
+								ownerSessionId: options.masterOwnerSessionId,
+								sessionId: input.sessionId,
+								pid: process.pid,
+								processIncarnation: hostProcessIncarnation,
+								direct,
+							});
 							await index.append({
 								type: "host_registered",
 								...input,
@@ -7776,6 +7821,8 @@ export function createNotificationsExtension(
 								// teardown identity provable after that workspace is gone.
 								...(hostProcessIncarnation ? { processIncarnation: hostProcessIncarnation } : {}),
 								endpointMtimeMs,
+								endpointFileId,
+								...(masterRole ? { masterRole } : {}),
 								...(lifecycleRequestId ? { lifecycleRequestId } : {}),
 							});
 						},

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

@@ -21,6 +21,8 @@ import type {
 	ReconciliationStore,
 } from "./reconciliation-store";
 
+const EMPTY_PROMPT_FAILURE = { code: "prompt_failed", message: "Prompt submission failed." } as const;
+
 export type { ReconciliationKind };
 
 export interface KindCorrelation extends PromptCorrelation {
@@ -51,8 +53,13 @@ export interface KindAwareReconciliation {
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
 		frame:
-			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
-			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
+			| {
+					type: "agent_start" | "agent_end";
+					content?: TurnResultContent;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent; hasActivity?: boolean },
 	): Promise<void>;
 	claimPendingOutcome(
 		kind: ReconciliationKind,
@@ -340,8 +347,13 @@ export function createKindAwareReconciliation(
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
 		frame:
-			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
-			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
+			| {
+					type: "agent_start" | "agent_end";
+					content?: TurnResultContent;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent; hasActivity?: boolean },
 	) => {
 		if (!correlation) return;
 		await queueMutation(candidate => {
@@ -412,7 +424,17 @@ export function createKindAwareReconciliation(
 				record.receiptState = record.pendingReceiptState ?? "missing";
 				record.pendingReceiptState = undefined;
 			} else {
-				record.status = record.error === undefined ? "terminal_ok" : "failed";
+				if (
+					kind === "prompt" &&
+					record.error === undefined &&
+					frame.type === "agent_end" &&
+					frame.outcome?.kind !== "stopped" &&
+					!frame.content?.text.trim() &&
+					!frame.hasActivity
+				) {
+					record.status = "failed";
+					record.error = EMPTY_PROMPT_FAILURE;
+				} else record.status = record.error === undefined ? "terminal_ok" : "failed";
 				record.receiptState = frame.content?.text?.trim() ? "present" : "missing";
 			}
 			cleanupRecords(candidate);
@@ -453,6 +475,7 @@ export function createKindAwareReconciliation(
 					: undefined;
 		const content =
 			typeof arg4 === "function" ? arg6 : typeof arg5 === "object" && arg5 !== null && "code" in arg5 ? arg6 : arg5;
+		const sanitizedContent = sanitizeTurnResultContent(content);
 		await queueMutation(candidate => {
 			if (isCurrent !== undefined && !isCurrent()) return { value: undefined, changed: false };
 			const record = candidate.get(keyOf(kind, correlation));
@@ -463,8 +486,15 @@ export function createKindAwareReconciliation(
 			if (finalOutcome?.kind === "failed") {
 				record.status = "failed";
 				record.error = recordError ?? { code: finalOutcome.code, message: finalOutcome.message };
+			} else if (
+				kind === "prompt" &&
+				((finalOutcome === undefined && !sanitizedContent?.text.trim()) ||
+					(finalOutcome?.kind !== "stopped" && content !== undefined && !sanitizedContent?.text.trim()))
+			) {
+				record.status = "failed";
+				record.error = EMPTY_PROMPT_FAILURE;
 			} else record.status = "terminal_ok";
-			record.content = sanitizeTurnResultContent(content);
+			record.content = sanitizedContent;
 			record.outcome = finalOutcome;
 			record.receiptState = record.pendingReceiptState ?? "unknown";
 			record.pendingOutcome = undefined;

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

@@ -23,11 +23,13 @@
  */
 
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
+import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import type { ReceiptState } from "../receipt-state";
 
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
 export const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
+const EMPTY_PROMPT_FAILURE = { code: "prompt_failed", message: "Prompt submission failed." } as const;
 
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
 
@@ -101,8 +103,13 @@ export interface PromptReconciliation {
 		correlation: PromptCorrelation | undefined,
 		frame:
 			| { type: "agent_start" }
-			| { type: "agent_end"; finalText?: string }
-			| { type: "agent_failed"; error: unknown; finalText?: string },
+			| {
+					type: "agent_end";
+					finalText?: string;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; finalText?: string; hasActivity?: boolean },
 	): void;
 	lookup(selector: { commandId?: string; turnId?: string; clientRef?: string }): TurnPromptReconciliation;
 	cleanup(): void;
@@ -190,8 +197,13 @@ export function createPromptReconciliation(options: { now?: () => number } = {})
 		correlation: PromptCorrelation | undefined,
 		frame:
 			| { type: "agent_start" }
-			| { type: "agent_end"; finalText?: string }
-			| { type: "agent_failed"; error: unknown; finalText?: string },
+			| {
+					type: "agent_end";
+					finalText?: string;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; finalText?: string; hasActivity?: boolean },
 	) => {
 		if (!correlation) return;
 		const record = records.get(keyOf(correlation));
@@ -221,6 +233,18 @@ export function createPromptReconciliation(options: { now?: () => number } = {})
 		if (frame.type === "agent_failed") {
 			record.status = "failed";
 			record.error = sanitizePromptFailure(frame.error);
+		} else if (record.error !== undefined) {
+			// Preserve an actionable provider failure already recorded before a late
+			// empty agent_end; the empty frame cannot downgrade or replace its cause.
+			record.status = "failed";
+		} else if (frame.type === "agent_end" && frame.outcome?.kind === "stopped") {
+			record.status = "terminal_ok";
+		} else if (!frame.finalText?.trim() && !frame.hasActivity) {
+			// A prompt cannot claim successful completion without assistant content.
+			// Keep the terminal transition first-wins, but fail closed instead of
+			// exposing an empty zero-token turn as terminal_ok.
+			record.status = "failed";
+			record.error = EMPTY_PROMPT_FAILURE;
 		} else {
 			record.status = "terminal_ok";
 		}

package/src/sdk/bus/slack-conversation.ts

@@ -74,5 +74,9 @@ export function normalizeSlackConversation(record: SlackConversation): SlackConv
 }
 
 export function acceptsSlackInbound(record: SlackConversation, rootTs: string, endpointGeneration: number): boolean {
-	return record.state === "active" && record.rootTs === rootTs && record.endpointGeneration === endpointGeneration;
+	return (
+		(record.state === "active" || record.state === "resumed_root") &&
+		record.rootTs === rootTs &&
+		record.endpointGeneration === endpointGeneration
+	);
 }

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

@@ -291,7 +291,7 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * killing a session's mirroring after one transient rejection and must be
  * replaced across this upgrade.
  */
-export const DAEMON_GENERATION = 179;
+export const DAEMON_GENERATION = 180;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

package/src/sdk/cli/index.ts

@@ -1 +1,2 @@
+export * from "./master-cli";
 export * from "./session-cli";