@gajae-code/coding-agent 0.16.3 → 0.16.4

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

@@ -92,6 +92,36 @@ function isReservedIdentity(name: string | undefined): boolean {
 	return isLifecycleEvent(name) || isControlPlaneFrameType(name);
 }
 
+/**
+ * Chat notifications in lean mode are an answer surface, not a mirror of the
+ * session protocol. Lifecycle, identity, and activity frames remain available
+ * to verbose consumers, while finalized answers and action-needed events are
+ * delivered in lean mode.
+ */
+export function shouldPublishChatFrame(
+	frame: Record<string, unknown>,
+	verbosity: "lean" | "verbose" | undefined,
+): boolean {
+	if (verbosity !== "lean") return frame.type !== "turn_stream" || frame.phase !== "live";
+	return frame.type === "turn_stream" && frame.phase === "finalized" && frame.finalAnswer === true;
+}
+
+/**
+ * A final answer's message ref identifies its one rendered message even when
+ * the SDK transport delivers an unpositioned duplicate frame.
+ */
+export function publicationIdForFinalChatAnswer(sessionId: string, frame: Record<string, unknown>): string | undefined {
+	if (
+		frame.type !== "turn_stream" ||
+		frame.phase !== "finalized" ||
+		frame.finalAnswer !== true ||
+		typeof frame.messageRef !== "string" ||
+		frame.messageRef.length === 0
+	)
+		return undefined;
+	return `turn:${sessionId}:${frame.messageRef}`;
+}
+
 /** One delivered frame reduced to a single event identity. */
 type CorrelatedFrame = SessionRouterFrame;
 
@@ -571,8 +601,9 @@ export class ChatDaemonRuntime {
 		if (this.#attachments.get(attachment.sessionId) !== attachment) return;
 		await this.#attachmentBarriers.get(attachment.sessionId);
 		if (this.#attachments.get(attachment.sessionId) !== attachment) return;
-		const publicationId = correlated.publicationId;
 		const normalizedFrame = correlated.body;
+		const publicationId =
+			publicationIdForFinalChatAnswer(attachment.sessionId, normalizedFrame) ?? correlated.publicationId;
 		const bodyType = typeof normalizedFrame.type === "string" ? normalizedFrame.type : undefined;
 		if (isControlPlaneFrameType(correlated.name) || isControlPlaneFrameType(bodyType)) return;
 		if (normalizedFrame.type === "turn_stream" && normalizedFrame.phase === "live") return;
@@ -607,6 +638,11 @@ export class ChatDaemonRuntime {
 			return;
 		}
 		if (!notification) return;
+		if (
+			notification.type === "frame" &&
+			!shouldPublishChatFrame(normalizedFrame, this.input.config.presentation?.verbosity)
+		)
+			return;
 		const payload = this.#presentation?.fanout(notification)[0];
 		const body = payload?.body;
 		const content =

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

@@ -58,7 +58,9 @@ function slackPublicationClientMsgId(publicationId: string): string {
 
 // Durable filesystem publication leases must outlast one event-loop and persistence turn.
 const MIN_PUBLICATION_LEASE_MS = 100;
+const INBOUND_REACTION_DEADLINE_MS = 5_000;
 const RETIREMENT_DRAIN_MS = 5_000;
+const INBOUND_REACTION = "eyes";
 
 type SlackProviderWorkScope = {
 	sessionId: string;
@@ -70,6 +72,8 @@ type SlackProviderWork = {
 	scopeKey: string;
 	invalidate(): Promise<void>;
 	abort(): void;
+	/** Best-effort work is aborted before the graceful shutdown drain. */
+	abortOnStop?: boolean;
 	terminalize(): Promise<void>;
 	settled: Promise<void>;
 };
@@ -362,6 +366,7 @@ export class SlackNotificationDaemon {
 		this.#startedGeneration = undefined;
 		if (this.#providerRunningGeneration === lifecycleGeneration) this.#providerRunningGeneration = undefined;
 		this.#clearLeaseRecoveryTimer();
+		for (const work of this.#workInvalidators) if (work.abortOnStop) work.abort();
 		if (stopProvider) this.#providerStopRequestedGenerations.add(lifecycleGeneration);
 		const providerStop = stopProvider ? Promise.resolve().then(() => this.options.provider.stop()) : undefined;
 		const providerStopResult = providerStop?.then(
@@ -449,6 +454,7 @@ export class SlackNotificationDaemon {
 
 	/** Accepted inbound effects are durably claimed before their Socket Mode ACK. */
 	async handleEnvelope(envelope: SlackSocketEnvelope): Promise<boolean> {
+		const lifecycleGeneration = this.#lifecycleGeneration;
 		if (!text(envelope.envelope_id)) return false;
 		const inbound = messageFromEnvelope(envelope.payload);
 		if (!inbound || inbound.teamId !== this.options.teamId || inbound.channelId !== this.options.channelId) {
@@ -479,6 +485,15 @@ export class SlackNotificationDaemon {
 		this.#inflightInbound.add(inflightKey);
 		try {
 			await this.options.provider.ack(envelope.envelope_id);
+			const messageTs = text(inbound.event.ts);
+			if (messageTs)
+				this.#scheduleInboundReaction(
+					claim.sessionId,
+					claim.endpoint,
+					inbound.channelId,
+					messageTs,
+					lifecycleGeneration,
+				);
 			return await this.#dispatchInbound(claim);
 		} finally {
 			this.#inflightInbound.delete(inflightKey);
@@ -491,6 +506,76 @@ export class SlackNotificationDaemon {
 		return work.finally(() => this.#activeWork.delete(work));
 	}
 
+	/** Track the best-effort acknowledgement in the owning attachment's provider-work scope. */
+	#scheduleInboundReaction(
+		sessionId: string,
+		endpoint: SessionAttachment,
+		channel: string,
+		timestamp: string,
+		lifecycleGeneration: number,
+	): void {
+		const scope: SlackProviderWorkScope = {
+			sessionId,
+			endpointGeneration: endpoint.generation,
+			...(endpoint.authorityId === undefined ? {} : { attachmentAuthorityId: endpoint.authorityId }),
+		};
+		const scopeKey = slackProviderWorkScopeKey(scope);
+		const workGeneration = this.#workGeneration;
+		const controller = new AbortController();
+		const settled = Promise.withResolvers<void>();
+		let abortKind: "deadline" | "lifecycle" | undefined;
+		const abort = (kind: "deadline" | "lifecycle"): void => {
+			abortKind ??= kind;
+			controller.abort();
+		};
+		const work: SlackProviderWork = {
+			scopeKey,
+			invalidate: async () => abort("lifecycle"),
+			abort: () => abort("lifecycle"),
+			abortOnStop: true,
+			terminalize: async () => abort("lifecycle"),
+			settled: settled.promise,
+		};
+		this.#workInvalidators.add(work);
+		const reaction = (async () => {
+			const deadline = setTimeout(() => abort("deadline"), INBOUND_REACTION_DEADLINE_MS);
+			try {
+				if (
+					workGeneration !== this.#workGeneration ||
+					lifecycleGeneration !== this.#lifecycleGeneration ||
+					this.#retiredProviderWorkScopes.has(scopeKey) ||
+					!endpoint.isCurrent()
+				) {
+					abort("lifecycle");
+					return;
+				}
+				await this.options.provider.addReaction({
+					channel,
+					timestamp,
+					name: INBOUND_REACTION,
+					signal: controller.signal,
+				});
+				if (abortKind === "deadline")
+					logger.warn(
+						`Slack inbound acknowledgement reaction exceeded the ${INBOUND_REACTION_DEADLINE_MS}ms deadline and was aborted.`,
+					);
+			} catch {
+				if (abortKind !== "lifecycle")
+					logger.warn(
+						abortKind === "deadline"
+							? `Slack inbound acknowledgement reaction exceeded the ${INBOUND_REACTION_DEADLINE_MS}ms deadline and was aborted.`
+							: "Slack inbound acknowledgement reaction failed.",
+					);
+			} finally {
+				clearTimeout(deadline);
+				this.#workInvalidators.delete(work);
+				settled.resolve();
+				this.#tryReleaseRetiredProviderWorkScope(scopeKey);
+			}
+		})();
+		void this.#track(reaction);
+	}
+
 	async #invalidateActiveWork(): Promise<void> {
 		this.#workGeneration += 1;
 		await Promise.allSettled([...this.#workInvalidators].map(work => work.invalidate()));
@@ -1496,7 +1581,11 @@ export class SlackNotificationDaemon {
 				updatedAt: this.#now(),
 			});
 		});
-		return sessionId && receipt ? { key, endpoint, sessionId, receipt } : undefined;
+		if (!sessionId || !receipt) {
+			await this.#journal.terminalize(effectId, { status: "rejected" });
+			return undefined;
+		}
+		return { key, endpoint, sessionId, receipt };
 	}
 
 	async #dispatchInbound(claim: {
@@ -2020,7 +2109,8 @@ export class SlackNotificationDaemon {
 				current.seenEventIds.includes(routing.eventId) ||
 				current.seenInteractionIds.includes(routing.interactionId) ||
 				current.seenRetryKeys.includes(routing.retryKey) ||
-				(routing.kind === "action" && replyableActionId(current.pendingActionId) !== routing.actionId)
+				(routing.kind === "action" && replyableActionId(current.pendingActionId) !== routing.actionId) ||
+				(routing.kind === "message" && replyableActionId(current.pendingActionId) !== undefined)
 			)
 				return current;
 			receipt = {

package/src/sdk/bus/slack-live-provider.ts

@@ -294,6 +294,18 @@ export class SlackLiveProvider implements SlackProviderClient, SlackDiagnosticPr
 		return message;
 	}
 
+	async addReaction(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void> {
+		await this.#api(
+			"reactions.add",
+			{
+				channel: input.channel,
+				timestamp: input.timestamp,
+				name: input.name,
+			},
+			input.signal,
+		);
+	}
+
 	async findMessageByClientMsgId(input: {
 		channel: string;
 		clientMsgId: string;

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

@@ -57,6 +57,7 @@ export interface SlackProviderClient {
 		threadTs?: string;
 		signal?: AbortSignal;
 	}): Promise<SlackMessageSearchResult | null>;
+	addReaction?(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void>;
 	/**
 	 * Prove that an operator-supplied timestamp addresses a real message in the
 	 * requested channel. Adoption of an existing root is refused when a client
@@ -108,6 +109,10 @@ export class SlackProvider {
 		return (await this.client.findMessageByClientMsgId?.(input)) ?? null;
 	}
 
+	async addReaction(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void> {
+		await this.client.addReaction?.(input);
+	}
+
 	/** Fail-closed root verification: a client without this capability can never confirm a root. */
 	async findMessageByTimestamp(input: { channel: string; ts: string }): Promise<SlackMessageSearchResult | null> {
 		return (await this.client.findMessageByTimestamp?.(input)) ?? null;

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

@@ -334,13 +334,14 @@ function throwResponseFailure(response: unknown): void {
 async function paginatedSessionList(
 	router: SessionRouter,
 	input: JsonRecord = {},
-	requestKey = `${SDK_SESSION_CLI_LIFECYCLE_ACTOR.namespace}:session.list`,
+	requestKey = `${SDK_SESSION_CLI_LIFECYCLE_ACTOR.namespace}:session.list:${randomBytes(12).toString("hex")}`,
 ): Promise<unknown> {
 	try {
 		const pages = await traverseSessionList(
 			input,
 			async pageInput => {
-				const response = object(await router.listBrokerSessions(pageInput, requestKey));
+				const cursor = typeof pageInput.cursor === "string" ? pageInput.cursor : "initial";
+				const response = object(await router.listBrokerSessions(pageInput, `${requestKey}:${cursor}`));
 				if (response?.ok === false) {
 					const failure = object(response.error);
 					throw new SdkClientError(
@@ -375,10 +376,10 @@ type SessionRows = {
 	sessions: SdkSessionRowV1[];
 };
 
-async function sessionRows(agentDir: string): Promise<SessionRows> {
+async function sessionRows(agentDir: string, input: JsonRecord = {}): Promise<SessionRows> {
 	await ensureBroker({ agentDir });
 	return await withRouter(agentDir, async router => {
-		const response = await paginatedSessionList(router);
+		const response = await paginatedSessionList(router, input);
 		const result = resultObject(response) ?? {};
 		let sessions: SdkSessionRowV1[];
 		try {
@@ -689,7 +690,7 @@ async function runList(agentDir: string, args: SdkSessionCliArgs): Promise<unkno
 }
 
 async function runInspect(agentDir: string, sessionId: string): Promise<unknown> {
-	const listing = await sessionRows(agentDir);
+	const listing = await sessionRows(agentDir, { resolveSessionId: sessionId });
 	const session = listing.sessions.find(candidate => candidate.sessionId === sessionId);
 	if (!session)
 		throw new SdkSessionCliError("session_unavailable", `Session ${sessionId} is not indexed by the broker.`, 1);
@@ -1671,7 +1672,9 @@ export async function runTail(
 	sessionId: string,
 	args: SdkSessionCliArgs,
 ): Promise<unknown> {
-	const row = (await sessionRows(agentDir)).sessions.find(candidate => candidate.sessionId === sessionId);
+	const row = (await sessionRows(agentDir, { resolveSessionId: sessionId })).sessions.find(
+		candidate => candidate.sessionId === sessionId,
+	);
 	if (!row)
 		throw new SdkSessionCliError("session_unavailable", `Session ${sessionId} is not indexed by the broker.`, 1);
 	if (row.deleted)

package/src/sdk/host/session-runtime.test.ts

@@ -2125,7 +2125,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (!transport.sent.some(frame => frame.id === "predecessor-prompt")) await Bun.sleep(10);
 			await handlers.get("agent_start")?.({}, ctx); // lifecycle epoch 1
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			transport.feed("client", {
@@ -2148,7 +2148,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (abortCalls < 1) await Bun.sleep(10);
 			await handlers.get("agent_end")?.({ type: "agent_end" }, ctx); // delayed predecessor
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			abortRelease.resolve();