@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/sdk/broker/transport.ts

@@ -14,6 +14,7 @@ const BROKER_OPERATIONS = new Set([
 	"session.resume",
 	"session.close",
 	"session.delete",
+	"broker.shutdown",
 ]);
 type RequestInput = Record<string, unknown>;
 type BrokerRequest = {
@@ -32,8 +33,15 @@ function tokenMatches(expected: string, actual: string | null): boolean {
 function isInput(value: unknown): value is RequestInput {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function send(socket: ServerWebSocket<unknown>, frame: Record<string, unknown>): void {
-	socket.send(JSON.stringify(frame));
+function send(socket: ServerWebSocket<unknown>, frame: Record<string, unknown>): number {
+	return socket.send(JSON.stringify(frame));
+}
+
+export type BrokerShutdownSendAction = "dropped" | "wait_for_drain" | "close";
+
+export function brokerShutdownSendAction(status: number): BrokerShutdownSendAction {
+	if (status === 0) return "dropped";
+	return status < 0 ? "wait_for_drain" : "close";
 }
 function sendError(socket: ServerWebSocket<unknown>, id: string | undefined, code: string, message: string): void {
 	send(socket, { type: "broker_response", ...(id === undefined ? {} : { id }), ok: false, error: { code, message } });
@@ -45,6 +53,8 @@ export class BrokerTransport {
 	readonly #requestedPort: number;
 	#server: Bun.Server<undefined> | null = null;
 	#port = 0;
+	readonly #shutdownBackpressured = new WeakSet<ServerWebSocket<unknown>>();
+	#shutdownRequested = false;
 	constructor(broker: Broker, token: string, port = 0) {
 		this.#broker = broker;
 		this.#token = token;
@@ -71,8 +81,13 @@ export class BrokerTransport {
 			},
 			websocket: {
 				maxPayloadLength: MAX_BROKER_JSON_FRAME_BYTES * 2,
-				open: socket => send(socket, { type: "broker_hello", protocolVersion: PROTOCOL_VERSION }),
+				open: socket => {
+					send(socket, { type: "broker_hello", protocolVersion: PROTOCOL_VERSION });
+				},
 				message: (socket, message) => void this.#handleMessage(socket, message),
+				drain: socket => {
+					if (this.#shutdownBackpressured.delete(socket)) this.#scheduleStopAfterShutdownResponse();
+				},
 			},
 		});
 		this.#port = this.#server.port ?? 0;
@@ -84,6 +99,10 @@ export class BrokerTransport {
 		if (server) await server.stop(true);
 	}
 	async #handleMessage(socket: ServerWebSocket<unknown>, raw: string | Buffer): Promise<void> {
+		if (this.#shutdownRequested) {
+			sendError(socket, undefined, "unavailable", "broker is shutting down");
+			return;
+		}
 		if (Buffer.byteLength(raw) > MAX_BROKER_JSON_FRAME_BYTES) {
 			sendError(socket, undefined, "payload_too_large", "broker JSON frame exceeds 4 MiB limit");
 			return;
@@ -115,6 +134,16 @@ export class BrokerTransport {
 			sendError(socket, frame.id, "invalid_input", "idempotencyKey must be a string");
 			return;
 		}
+		if (frame.operation === "broker.shutdown") {
+			const action = brokerShutdownSendAction(
+				send(socket, { type: "broker_response", id: frame.id, ok: true, result: { accepted: true } }),
+			);
+			if (action === "dropped") return;
+			this.#shutdownRequested = true;
+			if (action === "wait_for_drain") this.#shutdownBackpressured.add(socket);
+			else this.#scheduleStopAfterShutdownResponse();
+			return;
+		}
 		try {
 			const result = await this.#broker.handleRequest(frame.operation, frame.input, frame.idempotencyKey);
 			send(socket, { type: "broker_response", id: frame.id, ...result });
@@ -122,4 +151,7 @@ export class BrokerTransport {
 			sendError(socket, frame.id, "unavailable", "broker request failed");
 		}
 	}
+	#scheduleStopAfterShutdownResponse(): void {
+		setTimeout(() => void this.#broker.stop(), 25);
+	}
 }

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

@@ -5,7 +5,11 @@
  */
 
 /** Delivers a local file to the session's Telegram chat. */
-export type TelegramFileSink = (file: { path: string; caption?: string }) => Promise<{ ok: boolean; error?: string }>;
+export type TelegramFileSink = (file: {
+	path: string;
+	caption?: string;
+	mime?: string;
+}) => Promise<{ ok: boolean; error?: string }>;
 
 const sinks = new Map<string, TelegramFileSink>();
 

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

@@ -60,27 +60,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 	const config = notificationConfigFromFile(loaded.value);
 	if (!config.enabled) return undefined;
 	if (kind === "discord") {
-		if (
-			!isDiscordConfigured({
-				...config,
-				sessionScope: "all",
-				idleTimeoutMs: 60_000,
-				rich: { enabled: true },
-				richDraft: { enabled: false },
-				toolActivity: { enabled: false },
-				topics: { nameTemplate: undefined },
-				btw: { enabled: true },
-				streaming: { enabled: true },
-			})
-		) {
+		if (!isDiscordConfigured(config)) {
 			throw new Error("Discord notifications are enabled but configuration is incomplete");
 		}
-		const discord = config.discord as {
-			botToken: string;
-			applicationId: string;
-			guildId: string;
-			parentChannelId: string;
-		};
+		const discord = config.discord;
 		const { botToken, applicationId, guildId, parentChannelId } = discord;
 		const identity = crypto
 			.createHash("sha256")
@@ -95,28 +78,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 			presentation: { redact: config.redact, verbosity: config.verbosity },
 		};
 	}
-	if (
-		!isSlackConfigured({
-			...config,
-			sessionScope: "all",
-			idleTimeoutMs: 60_000,
-			rich: { enabled: true },
-			richDraft: { enabled: false },
-			toolActivity: { enabled: false },
-			topics: { nameTemplate: undefined },
-			btw: { enabled: true },
-			streaming: { enabled: true },
-		})
-	) {
+	if (!isSlackConfigured(config)) {
 		throw new Error("Slack notifications are enabled but configuration is incomplete");
 	}
-	const slack = config.slack as {
-		botToken: string;
-		appToken: string;
-		workspaceId: string;
-		channelId: string;
-		authorizedUserId?: string;
-	};
+	const slack = config.slack;
 	const { botToken, appToken, workspaceId, channelId, authorizedUserId } = slack;
 	const identity = crypto
 		.createHash("sha256")

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

@@ -35,11 +35,14 @@ export type ChatDaemonAction = "stop" | "reload";
  * when deleting an observed owner-lock lease. Generation 12 refreshes retained
  * native path and process authority semantics. Generation 13 rejects special
  * files before retained native authority opens. Generation 14 reloads shared
- * chat daemons after notification configuration parsing changes.
+ * chat daemons after notification configuration parsing changes. Generation 15
+ * applies the current notification configuration directly when starting chat
+ * daemon transports. Generation 16 applies Telegram sound-policy configuration
+ * through shared notification parsing.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 14,
-	slack: 14,
+	discord: 16,
+	slack: 16,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

package/src/sdk/bus/config.ts

@@ -55,6 +55,7 @@ export interface NotificationSettingsSnapshot {
 		botToken?: string;
 		chatId?: string;
 		activation?: Record<string, unknown>;
+		sound: "all" | "important" | "none";
 		btw: {
 			enabled: boolean;
 		};
@@ -160,6 +161,11 @@ export function parseNotificationSettingsSnapshot(rawConfig?: unknown): Notifica
 			botToken: notificationSettingsString(telegram.botToken),
 			chatId: notificationSettingsString(telegram.chatId),
 			...(Object.keys(activation).length === 0 ? {} : { activation }),
+			sound: notificationSettingsChoice<"all" | "important" | "none">(telegram.sound, "all", [
+				"all",
+				"important",
+				"none",
+			]),
 			btw: {
 				enabled: notificationSettingsBoolean(btw.enabled, true),
 			},
@@ -228,6 +234,7 @@ export interface NotificationConfig {
 	 * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
 	 */
 	sessionScope: "all" | "primary";
+	sound: "all" | "important" | "none";
 	idleTimeoutMs: number;
 	btw: {
 		enabled: boolean;
@@ -270,6 +277,7 @@ export function getNotificationConfig(settings: NotificationSettingsReader): Not
 		verbosity: snapshot.verbosity,
 		sessionScope: snapshot.sessionScope,
 		idleTimeoutMs: snapshot.idleTimeoutMs,
+		sound: snapshot.telegram.sound,
 		rich: snapshot.telegram.rich,
 		btw: snapshot.telegram.btw,
 		richDraft: snapshot.telegram.richDraft,
@@ -358,7 +366,10 @@ export function isTelegramConfigured(
 }
 
 /** Is Discord configured with all credentials and routing identifiers required by its daemon. */
-export function isDiscordConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export function isDiscordConfigured(cfg: Pick<NotificationConfig, "enabled" | "discord">): cfg is Pick<
+	NotificationConfig,
+	"enabled"
+> & {
 	discord: { botToken: string; applicationId: string; guildId: string; parentChannelId: string };
 } {
 	return (
@@ -371,7 +382,10 @@ export function isDiscordConfigured(cfg: NotificationConfig): cfg is Notificatio
 }
 
 /** Is Slack configured with both SDK tokens and its workspace/channel routing identifiers. */
-export function isSlackConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export function isSlackConfigured(cfg: Pick<NotificationConfig, "enabled" | "slack">): cfg is Pick<
+	NotificationConfig,
+	"enabled"
+> & {
 	slack: { botToken: string; appToken: string; workspaceId: string; channelId: string };
 } {
 	return (
@@ -539,6 +553,8 @@ export interface RedactableAction {
 	workflowGateId?: string;
 	question?: string;
 	options?: string[];
+	/** Selected zero-based option positions for transport-specific multi-select rendering. */
+	selectedOptionIndices?: number[];
 	summary?: string;
 	/** Optional zero-based recommendation into the authoritative raw options. */
 	recommendedIndex?: number;

package/src/sdk/bus/control-drain-lease.ts

@@ -0,0 +1,104 @@
+/**
+ * Ordering seam for an in-band SDK identity transition.
+ *
+ * A request arrives through predecessor A, so a successful terminal response cannot
+ * be published until successor B is ready. Native builds may provide a true
+ * send-only connection lease; source/dev builds use the conservative fallback in
+ * which the predecessor server remains alive until the terminal write completes.
+ */
+
+export type TerminalSendOutcome = "written" | "disconnected" | "write_failed";
+
+/** Fence/capability hooks may return false to reject; undefined means ok. */
+export type IdentityControlGateResult = boolean | undefined;
+export type IdentityControlGate = () => IdentityControlGateResult | Promise<IdentityControlGateResult>;
+
+export interface IdentityControlSuccessPathInput {
+	/** Fence predecessor inbound work. The fence must not close its response writer. */
+	fence: IdentityControlGate;
+	/** Optional explicit proof that the predecessor writer is still usable. */
+	ensurePredecessorSendCapable?: IdentityControlGate;
+	/** Start successor B and resolve only after its public endpoint is ready. */
+	startSuccessor: () => Promise<void>;
+	/** Write and flush either the success or non-success terminal response. */
+	sendTerminal: () => Promise<TerminalSendOutcome>;
+	/** Release predecessor A after the terminal response has settled. */
+	stopPredecessor: () => Promise<void>;
+	/** Set only when a caller cannot use the retained-writer fallback. */
+	requireNativeControlDrain?: boolean;
+}
+
+export interface IdentityControlTerminalPathInput {
+	fenceInbound: IdentityControlGate;
+	ensurePredecessorSendCapable?: IdentityControlGate;
+	startSuccessorReady: () => Promise<void>;
+	sendTerminal: () => Promise<TerminalSendOutcome>;
+	stopPredecessor: () => Promise<void>;
+	requireNativeControlDrain?: boolean;
+}
+
+/**
+ * Probe the loaded native addon, never an environment flag or a TypeScript shim.
+ * Older/source installs intentionally report false so callers can select the
+ * retained-writer fallback or fail closed when detach is mandatory.
+ */
+export function isNativeControlDrainAvailable(): boolean {
+	try {
+		// Keep the addon lazy: importing the bus must continue to work without a
+		// compiled native artifact (tests and source distributions do that often).
+		// eslint-disable-next-line @typescript-eslint/no-require-imports
+		const natives = require("@gajae-code/natives") as {
+			NotificationServer?: {
+				prototype?: Record<string, unknown>;
+			};
+		};
+		const prototype = natives.NotificationServer?.prototype;
+		return (
+			typeof prototype?.acquireControlDrain === "function" &&
+			typeof prototype?.sendTerminalAndWait === "function" &&
+			typeof prototype?.closeControlDrain === "function"
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Run the only safe ordering for a successful identity-control response.
+ *
+ * The `finally` is deliberately around both successor startup and terminal
+ * delivery: a failed startup must not leave the fenced predecessor alive, and a
+ * failed/disconnected terminal write must still release it. When native detach
+ * is unavailable the caller is expected to keep A's server up (not call
+ * `stopAndWait`) until `sendTerminal` settles.
+ */
+export async function runIdentityControlSuccessPath(
+	input: IdentityControlSuccessPathInput,
+): Promise<TerminalSendOutcome> {
+	if (input.requireNativeControlDrain && !isNativeControlDrainAvailable())
+		throw new Error("SDK identity control requires the native control-drain lease.");
+
+	if ((await input.fence()) === false) throw new Error("SDK identity control predecessor fence was not acquired.");
+	if ((await input.ensurePredecessorSendCapable?.()) === false)
+		throw new Error("SDK identity control predecessor writer is not send-capable.");
+	try {
+		await input.startSuccessor();
+		return await input.sendTerminal();
+	} finally {
+		await input.stopPredecessor();
+	}
+}
+
+/** Compatibility spelling used by the host wiring design notes. */
+export async function runIdentityControlTerminalPath(
+	input: IdentityControlTerminalPathInput,
+): Promise<TerminalSendOutcome> {
+	return runIdentityControlSuccessPath({
+		fence: input.fenceInbound,
+		ensurePredecessorSendCapable: input.ensurePredecessorSendCapable,
+		startSuccessor: input.startSuccessorReady,
+		sendTerminal: input.sendTerminal,
+		stopPredecessor: input.stopPredecessor,
+		requireNativeControlDrain: input.requireNativeControlDrain,
+	});
+}