@gajae-code/coding-agent 0.12.0 → 0.12.1

package/src/prompts/tools/bash.md

@@ -44,13 +44,13 @@ Use it only for sanctioned GJC workflow CLI persistence or state read/write/cont
 {{else}}
 - Use bash only for terminal operations that dedicated tools do not cover.
 {{/when}}
-- Never pipe through `| head -n N` or `| tail -n N` — output is already truncated with the full result available via `artifact://<id>`.
+- Never pipe through `| head -n N` or `| tail -n N` — output is already truncated. Recover omitted output only when the result includes an `artifact://<id>` footer or metadata reference; truncation without a reference leaves the visible output incomplete with no recoverable artifact.
 - Never redirect with `2>&1` or `2>/dev/null` — stdout and stderr are already merged.
 </critical>
 
 <output>
 - Returns output and exit code.
-- Truncated output is retrievable from `artifact://<id>` (linked in metadata)
+- Truncated output is recoverable only when the result includes an `artifact://<id>` footer or metadata reference; truncation evidence without such a reference means the visible output is incomplete and no artifact is recoverable.
 - Exit codes shown on non-zero exit
 </output>
 
@@ -64,6 +64,6 @@ Use it only for sanctioned GJC workflow CLI persistence or state read/write/cont
 
 # Output minimizer
 
-- Bash stdout/stderr may be rewritten before you see it: long output is head/tail truncated, and test/lint runners (e.g. `bun test`, `cargo test`, ESLint) are passed through heuristic filters that drop noise and keep failures.
-- When the minimizer changes the visible text, the tool appends a `[raw output: artifact://<id>]` footer pointing at the **full untouched capture**. If a run looks suspicious (e.g. only a version banner) or you need the exact bytes, read that artifact.
-- If no footer is present, what you see is what the command actually emitted.
+- Bash stdout/stderr may be rewritten before you see it: long output keeps only the last 1 KiB by default to reduce noise and input-token use. Explicit `tools.artifactTailBytes` / `tools.artifactHeadBytes` settings can set the tail budget or retain both ends. Prefer focused commands and dedicated `search`/`find` tools over producing broad output. Test/lint runners (e.g. `bun test`, `cargo test`, ESLint) are also passed through heuristic filters that drop noise and keep failures.
+- When the local minimizer changes visible text, successful artifact storage appends a footer containing an `artifact://<id>` reference. Complete artifacts are labeled as full output; hard-capped artifacts report omitted bytes instead. If artifact allocation/storage is unavailable before a writer/save operation is attempted, truncation may have no reference or diagnostic. If an artifact writer/save operation is attempted and fails, a bounded diagnostic is emitted without inventing an artifact URI.
+- ACP/client-terminal output can arrive already truncated from the beginning. Treat any truncation notice or metadata as evidence that the visible tail is incomplete. Recover omitted output only when an `artifact://` footer or metadata reference is present; truncation evidence without a reference means the visible output is incomplete and no artifact is recoverable. Output with neither truncation evidence nor an artifact reference is the complete emitted output.

package/src/prompts/tools/search-tool-bm25.md

@@ -12,6 +12,11 @@ Behavior:
 - Repeated searches add to the active tool set; they do not remove earlier selections
 - Newly activated tools become available before the next model call in the same overall turn
 
+Follow-through:
+- Activation only changes the active tool set; it does not execute a discovered tool or complete its work.
+- If the task still needs a newly activated capability, call that tool in the next model turn. Do not claim that a browser action, web search, integration, or subagent ran until its tool result is present.
+- If discovery was the only requested action, report availability as availability, not as completed work.
+
 Not for repository/file/code search. Tool discovery only.
 
 Returns JSON with:

package/src/prompts/tools/task.md

@@ -28,7 +28,7 @@ Subagents have no conversation history. Every fact, file path, and direction the
 {{#if independentMode}}- `.inheritContext`: independent mode cannot inherit parent conversation. Omit it or set `"none"`; any non-`none` value is rejected before scheduling.{{/if}}
 {{#if customSchemaEnabled}}- `schema`: JTD schema for expected structured output (do not put format rules in assignments){{/if}}
 - `spawnPlan` (optional): required before any batch with more than 4 tasks; include whyParallel, whyNotLocal, independence, expectedReceiptShape, and maxInlineTokens.
-{{#if isolationEnabled}}- `isolated`: run in isolated env; use when tasks edit overlapping files{{/if}}
+{{#if isolationEnabled}}- `isolated`: run in an isolated environment; REQUIRED when the user explicitly requests a worktree (for example, "use worktree"), and use when tasks edit overlapping files{{/if}}
 </parameters>
 
 <rules>

package/src/reminders/star-reminder.ts

@@ -18,6 +18,10 @@ import type { ImageContent, MessageAttribution } from "@gajae-code/ai";
 import { getConfigRootDir, isEnoent } from "@gajae-code/utils";
 import { withFileLock } from "../config/file-lock";
 import type { CustomMessage } from "../session/messages";
+import { type GhResult, type RunGh, runGhDefault } from "../utils/gh";
+
+export type { GhResult, RunGh };
+export { runGhDefault };
 
 export const STAR_REMINDER_REPO = "Yeachan-Heo/gajae-code";
 export const STAR_REMINDER_CUSTOM_TYPE = "star-reminder";
@@ -34,15 +38,6 @@ export interface StarReminderState {
 
 export type StarCheckStatus = "starred" | "unstarred" | "unavailable";
 
-export interface GhResult {
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-	timedOut?: boolean;
-}
-
-export type RunGh = (args: string[], options?: { timeoutMs?: number }) => Promise<GhResult>;
-
 export interface StarReminderDeps {
 	statePath?: string;
 	now?: () => Date;
@@ -187,39 +182,6 @@ export async function recordDeclinedAfterNo(deps?: StarReminderDeps): Promise<St
 	}, deps);
 }
 
-// --------------------------------------------------------------------------
-// gh helpers
-// --------------------------------------------------------------------------
-
-/** Default `gh` runner. Returns an unavailable-style result instead of throwing. */
-export async function runGhDefault(args: string[], options?: { timeoutMs?: number }): Promise<GhResult> {
-	const ghPath = Bun.which("gh");
-	if (!ghPath) {
-		return { exitCode: -1, stdout: "", stderr: "gh not found", timedOut: false };
-	}
-	const timeoutMs = options?.timeoutMs ?? GH_TIMEOUT_MS;
-	let timedOut = false;
-	try {
-		const proc = Bun.spawn([ghPath, ...args], { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
-		const timer = setTimeout(() => {
-			timedOut = true;
-			proc.kill();
-		}, timeoutMs);
-		try {
-			const [stdout, stderr] = await Promise.all([
-				new Response(proc.stdout).text(),
-				new Response(proc.stderr).text(),
-			]);
-			const exitCode = await proc.exited;
-			return { exitCode, stdout, stderr, timedOut };
-		} finally {
-			clearTimeout(timer);
-		}
-	} catch (err) {
-		return { exitCode: -1, stdout: "", stderr: err instanceof Error ? err.message : String(err), timedOut };
-	}
-}
-
 function resolveRunGh(deps?: StarReminderDeps): RunGh {
 	return deps?.runGh ?? runGhDefault;
 }

package/src/runtime-mcp/manager.ts

@@ -75,6 +75,7 @@ const STARTUP_TIMEOUT_GRACE_MS = 500;
  * budget derived from the readiness deadline (see `maxStartupTimeoutMs`).
  */
 const MAX_STARTUP_TIMEOUT_MS = 1_750;
+const DEFAULT_EXACT_CONFIG_STARTUP_TIMEOUT_MS = 30_000;
 
 export function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number {
 	const ceiling =
@@ -88,6 +89,17 @@ export function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTi
 	return Math.min(ceiling, Math.max(STARTUP_TIMEOUT_MS, Math.max(...configuredTimeouts) + STARTUP_TIMEOUT_GRACE_MS));
 }
 
+export function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number {
+	const effectiveTimeouts = configs.map(config => {
+		const timeout = config.timeout;
+		return typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0
+			? timeout
+			: DEFAULT_EXACT_CONFIG_STARTUP_TIMEOUT_MS;
+	});
+	if (effectiveTimeouts.length === 0) return STARTUP_TIMEOUT_MS;
+	return Math.max(...effectiveTimeouts) + STARTUP_TIMEOUT_GRACE_MS;
+}
+
 function trackPromise<T>(promise: Promise<T>): TrackedPromise<T> {
 	const tracked: TrackedPromise<T> = { promise, status: "pending" };
 	promise.then(
@@ -650,10 +662,13 @@ export class MCPManager {
 		}
 
 		if (connectionTasks.length > 0) {
-			const startupTimeoutMs = resolveStartupTimeoutMs(
-				connectionTasks.map(task => task.config),
-				this.#maxStartupTimeoutMs,
-			);
+			const configs = connectionTasks.map(task => task.config);
+			// An exact config is explicit operator intent, so its declared connection
+			// windows govern startup. Ordinary discovery keeps the short ceiling.
+			const startupTimeoutMs =
+				this.#toolsOnly && this.#maxStartupTimeoutMs === undefined
+					? resolveExactConfigStartupTimeoutMs(configs)
+					: resolveStartupTimeoutMs(configs, this.#maxStartupTimeoutMs);
 			const firstUnexpectedFailure = Promise.withResolvers<{ reason: unknown }>();
 			if (this.#toolsOnly) {
 				for (const task of connectionTasks) {

package/src/sdk/acp/adapter.ts

@@ -8,7 +8,7 @@ type JsonObject = Record<string, unknown>;
 
 /** The small agent-side ACP surface used for reverse requests. */
 export interface AcpReverseConnection {
-	request?(method: string, params: JsonObject): Promise<unknown>;
+	request?(method: string, params: JsonObject, options?: { cancellationSignal?: AbortSignal }): Promise<unknown>;
 	[key: string]: unknown;
 }
 
@@ -42,6 +42,7 @@ export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
 export type AcpFrameHandler = (frame: SdkFrame) => void;
 type ReverseRequest = {
 	state: "pending" | "cancelled";
+	controller?: AbortController;
 	cancelTimer?: NodeJS.Timeout;
 };
 
@@ -142,7 +143,10 @@ export class AcpSdkAdapter {
 		if (this.#closed) return;
 		this.#closed = true;
 		if (this.#heartbeat) clearInterval(this.#heartbeat);
-		for (const request of this.#reverseRequests.values()) if (request.cancelTimer) clearTimeout(request.cancelTimer);
+		for (const request of this.#reverseRequests.values()) {
+			request.controller?.abort();
+			if (request.cancelTimer) clearTimeout(request.cancelTimer);
+		}
 		this.#reverseRequests.clear();
 		this.#unsubscribe?.();
 		this.#unsubscribeReconnect?.();
@@ -263,6 +267,7 @@ export class AcpSdkAdapter {
 		if (this.#closed || !this.#providers.length) return;
 		if (this.#reclaiming) return await this.#reclaiming;
 		this.#reclaiming = (async () => {
+			this.#abortActiveReverseRequests();
 			this.#connectionId = this.#client.connectionId;
 			if (!this.#connectionId) this.#connectionId = await this.#waitForConnectionId();
 			for (const provider of this.#providers) await this.registerProvider(provider);
@@ -349,13 +354,14 @@ export class AcpSdkAdapter {
 			!this.#ownsReverseLease(connectionId, capability, leaseId)
 		)
 			return;
-		const active: ReverseRequest = { state: "pending" };
+		const controller = new AbortController();
+		const active: ReverseRequest = { state: "pending", controller };
 		this.#reverseRequests.set(id, active);
 		try {
 			const request = frame.payload as JsonObject | undefined;
 			const method = typeof request?.method === "string" ? request.method : "";
 			const payload = request?.payload && typeof request.payload === "object" ? (request.payload as JsonObject) : {};
-			const result = await this.#forwardReverse(method, payload);
+			const result = await this.#forwardReverse(method, payload, controller.signal);
 			if (!this.#canRespondToReverse(id, active, connectionId, capability, leaseId)) return;
 
 			this.#client.send({ type: "reverse_response", id, connectionId, leaseId, ok: true, result });
@@ -404,6 +410,7 @@ export class AcpSdkAdapter {
 		const request: ReverseRequest = this.#reverseRequests.get(id) ?? { state: "pending" };
 		if (request.state === "cancelled") return;
 		request.state = "cancelled";
+		request.controller?.abort();
 		request.cancelTimer = setTimeout(() => this.#finishReverse(id, request), this.#reverseCancelTtlMs);
 		this.#reverseRequests.set(id, request);
 	}
@@ -414,9 +421,18 @@ export class AcpSdkAdapter {
 		this.#reverseRequests.delete(id);
 	}
 
-	async #forwardReverse(method: string, payload: JsonObject): Promise<unknown> {
+	#abortActiveReverseRequests(): void {
+		for (const [id, request] of this.#reverseRequests) {
+			request.state = "cancelled";
+			request.controller?.abort();
+			this.#finishReverse(id, request);
+		}
+	}
+
+	async #forwardReverse(method: string, payload: JsonObject, signal: AbortSignal): Promise<unknown> {
 		if (!method || !this.#connection) throw new AcpSdkAdapterError("acp_reverse_unavailable");
-		if (this.#connection.request) return await this.#connection.request(method, payload);
+		if (this.#connection.request)
+			return await this.#connection.request(method, payload, { cancellationSignal: signal });
 		const target = this.#connection[method];
 		if (typeof target !== "function")
 			throw new AcpSdkAdapterError("acp_reverse_unsupported", `ACP client does not support ${method}.`);

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;