@gajae-code/coding-agent 0.12.0 → 0.12.2

package/src/modes/types.ts

@@ -63,6 +63,88 @@ export function canApplyComposerSubmission(
 ): boolean {
 	return options === undefined || (options.ownsComposer && editor === options.editor);
 }
+
+type PartialActivityStatusContainer = Partial<Pick<Container, "children" | "clear" | "detachChild" | "addChild">>;
+
+export function stopInteractiveActivityIndicator(
+	ctx: {
+		loadingAnimation?: Loader;
+		statusContainer?: PartialActivityStatusContainer;
+		stopLoadingAnimation?: (options?: { restoreBackground?: boolean }) => void;
+	},
+	options?: { restoreBackground?: boolean },
+): void {
+	if (ctx.stopLoadingAnimation) {
+		ctx.stopLoadingAnimation(options);
+		return;
+	}
+	ctx.loadingAnimation?.stop();
+	ctx.loadingAnimation = undefined;
+	ctx.statusContainer?.clear?.();
+}
+
+export function clearInteractiveActivityLoaders(
+	ctx: Pick<
+		InteractiveModeContext,
+		| "autoCompactionLoader"
+		| "autoCompactionEscapeHandler"
+		| "retryLoader"
+		| "retryCountdownTimer"
+		| "retryEscapeHandler"
+		| "retryEscapePrimed"
+		| "editor"
+	>,
+): void {
+	ctx.autoCompactionLoader?.stop();
+	ctx.autoCompactionLoader = undefined;
+	if (ctx.autoCompactionEscapeHandler) ctx.editor.onEscape = ctx.autoCompactionEscapeHandler;
+	ctx.autoCompactionEscapeHandler = undefined;
+	ctx.retryLoader?.stop();
+	ctx.retryLoader = undefined;
+	if (ctx.retryCountdownTimer) clearInterval(ctx.retryCountdownTimer);
+	ctx.retryCountdownTimer = undefined;
+	if (ctx.retryEscapeHandler) ctx.editor.onEscape = ctx.retryEscapeHandler;
+	ctx.retryEscapeHandler = undefined;
+	ctx.retryEscapePrimed = false;
+}
+
+export function suspendInteractiveActivityIndicator(ctx: {
+	loadingAnimation?: Loader;
+	statusContainer?: PartialActivityStatusContainer;
+	stopLoadingAnimation?: (options?: { restoreBackground?: boolean }) => void;
+	syncActivityIndicator?: () => void;
+	suspendActivityIndicator?: () => () => void;
+}): () => void {
+	if (ctx.suspendActivityIndicator) return ctx.suspendActivityIndicator();
+	const suspendedLoader = ctx.loadingAnimation;
+	const statusContainer = ctx.statusContainer;
+	const canTransferMountedLoader =
+		Array.isArray(statusContainer?.children) &&
+		typeof statusContainer.detachChild === "function" &&
+		typeof statusContainer.addChild === "function";
+	const wasMounted =
+		canTransferMountedLoader && suspendedLoader !== undefined && statusContainer.children?.includes(suspendedLoader);
+	if (suspendedLoader && wasMounted) statusContainer.detachChild?.(suspendedLoader);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (
+			wasMounted &&
+			suspendedLoader &&
+			ctx.loadingAnimation === suspendedLoader &&
+			Array.isArray(statusContainer?.children) &&
+			!statusContainer.children.includes(suspendedLoader)
+		) {
+			statusContainer.addChild?.(suspendedLoader);
+		}
+		syncInteractiveActivityIndicator(ctx);
+	};
+}
+
+export function syncInteractiveActivityIndicator(ctx: { syncActivityIndicator?: () => void }): void {
+	ctx.syncActivityIndicator?.();
+}
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 
 export type TodoItem = {
@@ -164,6 +246,8 @@ export interface InteractiveModeContext {
 	init(): Promise<void>;
 	shutdown(): Promise<void>;
 	checkShutdownRequested(): Promise<void>;
+	isStopped?(): boolean;
+	onStop(callback: () => void): () => void;
 
 	// Extension UI integration
 	setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
@@ -190,6 +274,9 @@ export interface InteractiveModeContext {
 	setWorkingMessage(message?: string): void;
 	applyPendingWorkingMessage(): void;
 	ensureLoadingAnimation(): void;
+	syncActivityIndicator(): void;
+	suspendActivityIndicator(): () => void;
+	stopLoadingAnimation(options?: { restoreBackground?: boolean }): void;
 	/**
 	 * Commit a pet mode through the shared result-returning policy: capability
 	 * is rechecked immediately before mutation and the preference persists only
@@ -253,6 +340,7 @@ export interface InteractiveModeContext {
 	updateEditorTopBorder(): void;
 	updateEditorBorderColor(): void;
 	rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
+	updateEditorChrome(): void;
 	setTodos(todos: TodoItem[] | TodoPhase[]): void;
 	reloadTodos(): Promise<void>;
 	toggleTodoExpansion(): void;

package/src/prompts/agent-fragments/ralplan-persistence.md

@@ -1,6 +1,7 @@
 Persistence (ralplan runs only):
-- Only when the assignment references a ralplan stage or `stage_n`, persist the full artifact through:
+- Only when the assignment references a ralplan stage or `stage_n`, it must also provide the ralplan owner `session_id` and `run_id`. If either identifier is missing, do not persist; return a compact error asking the caller to supply both.
+- Persist the full artifact through:
 
-  gjc ralplan --write --stage {{stage}} --stage_n <N> --artifact-env GJC_RALPLAN_ARTIFACT --json
+  gjc ralplan --write --session-id <owner-session-id> --run-id <run-id> --stage {{stage}} --stage_n <N> --artifact-env GJC_RALPLAN_ARTIFACT --json
 
-  Use the assignment-provided `stage_n`; on a duplicate-write error retry with the incremented N. Return the write receipt (`run_id`, `path`, `sha256`, `stage`, `stage_n`) and the role's compact verdict only. Otherwise, do not call `gjc ralplan --write`; return the full result in `yield.result.data`.
+  Use the assignment-provided owner `session_id`, `run_id`, and `stage_n`; never substitute the role subagent's own session id. On a duplicate-write error retry with the incremented N. Return the write receipt (`session_id`, `run_id`, `path`, `sha256`, `stage`, `stage_n`) and the role's compact verdict only. Otherwise, do not call `gjc ralplan --write`; return the full result in `yield.result.data`.

package/src/prompts/system/eager-todo.md

@@ -2,11 +2,15 @@
 Before substantive work, create a phased todo.
 
 You MUST call `todo_write` first in this turn.
-You MUST initialize the todo list with a single `init` op.
+Your call MUST use the top-level `ops` array with exactly one `init` operation.
+The `init` operation MUST contain `list`, whose entries each have a unique `phase` and an `items` array of task strings.
+Use this canonical shape:
+```json
+{"ops":[{"op":"init","list":[{"phase":"Investigation","items":["Locate relevant source and existing tests","Reproduce failure with focused contract test"]},{"phase":"Implementation","items":["Apply root cause fix across callsites"]},{"phase":"Verification","items":["Run focused tests and static checks"]}]}]}
+```
 You MUST cover the entire request from investigation through implementation and verification — not just the next immediate step.
-Task descriptions MUST be specific. A future turn MUST execute them without re-planning.
-You MUST keep task `content` to a short label (5-10 words). Put file paths, implementation steps, and specifics in `details`.
-You MUST keep exactly one task `in_progress` and all later tasks `pending`.
+Task strings MUST be specific, unique labels of 5-10 words. A future turn MUST execute them without re-planning.
+The tool automatically promotes the first task after initialization. Add extra context later with a separate `note` operation only when needed.
 
 After `todo_write` succeeds, continue the request in the same turn.
 Do not call `todo_write` again unless task state materially changed.

package/src/prompts/system/system-prompt.md

@@ -22,12 +22,13 @@ Optimize for correctness first, maintainability second, and brevity third. Prefe
 - Clear, low-risk implementation requests use direct tools and focused verification; do not invoke workflows or role agents for ceremony. Small verification needs do not turn a clear request into a planning workflow.
 - Ambiguous implementation asks with a missing target, scope, acceptance criteria, or safety boundary require clarification or the appropriate planning workflow before mutation.
 - Informational questions are answer-only/read-only unless the user explicitly requests a change, command, or execution.
-- Vague requirements use `/skill:deep-interview`: a requirements-only workflow that must not mutate product code. Its spec hands off as deep-interview → ralplan consensus → pending approval → separately approved execution.
-- Clear work with non-trivial architecture or sequencing risk uses `/skill:ralplan --deliberate` and stops pending approval.
+- Vague requirements use `/skill:deep-interview`: a requirements-only workflow that must not mutate product code. Its spec hands off as deep-interview → ralplan consensus → final receipt → approval or valid non-off runtime admission → separately authorized execution.
+- Clear work with non-trivial architecture or sequencing risk uses `/skill:ralplan --deliberate`; reconciliation must persist its final receipt before choosing approval or an admitted handoff. A valid non-off final runtime receipt enters the existing handoff chain; otherwise it stops pending approval.
 - Use `/skill:ultragoal` for durable goal ledgers and `/skill:team` for approved coordinated persistent work.
 - Delegate large implementation slices to `executor`; use `planner`, `architect`, or `critic` for bounded planning and review.
+- An explicit user request to use a worktree (for example, "use worktree") overrides direct editing: delegate implementation through `task` with `isolated: true`. This is the in-session counterpart of launching `gjc --worktree`; if task isolation is unavailable, report that conflict instead of editing in the parent session.
 - Active skills are authoritative: never ignore an invoked skill; read the full skill text and follow it exactly.
-- Before explicit execution approval, planning and interview workflows NEVER edit product source, run mutating shell commands, commit, push, open PRs, or delegate implementation.
+- Before explicit execution approval or a valid non-off ralplan final runtime receipt, planning and interview workflows NEVER edit product source, run mutating shell commands, commit, push, open PRs, or delegate implementation.
 </routing>
 </gjc-runtime>
 {{/unless}}
@@ -82,8 +83,14 @@ Use tools whenever they materially improve correctness, completeness, or groundi
 
 {{#if toolDiscoveryActive}}
 <tool-discovery>
-Use `{{toolRefs.search_tool_bm25}}` to activate hidden tools when a purpose-built capability would improve the task; then call the activated tool. Essential tools stay loaded up front.
+Use `{{toolRefs.search_tool_bm25}}` to activate hidden tools when a purpose-built capability would improve the task; then call the activated tool. Activation makes a tool available, but does not perform its action. Essential tools stay loaded up front.
 Discoverable capabilities include browser automation, scheduling, debugging, and external integrations.
+{{#has tools "task"}}
+For requested subagents, delegation, or independent parallel lanes, call `{{toolRefs.task}}` before saying agents are running.
+{{else}}
+For requested subagents, delegation, or independent parallel lanes, search for `subagent delegation` before saying agents are running.
+{{/has}}
+Do not claim a web search, browser action, integration, or subagent ran without that tool's result.
 </tool-discovery>
 {{/if}}
 

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/lifecycle.ts

@@ -3260,26 +3260,31 @@ async function executeLifecycleResponse(
 				`Unable to delete saved session artifacts: ${error instanceof Error ? error.message : String(error)}`,
 			);
 		}
-		const retainedArtifactsCleanup =
+		const retainedArtifactsRootOnly =
 			deleted.kind === "cleanup_pending" &&
 			deleted.phase === "artifacts" &&
 			deleted.detachedArtifactsPath !== undefined &&
-			cleanupTarget.plannedArtifactsPath !== undefined &&
-			(deleted.detachedArtifactsPath === cleanupTarget.plannedArtifactsPath ||
-				deleted.detachedArtifactsPath === `${cleanupTarget.plannedArtifactsPath}.removing`);
-		if (deleted.kind === "artifacts_removed" || retainedArtifactsCleanup) {
+			(() => {
+				const snapshot = native.snapshotDirectoryTree(deleted.detachedArtifactsPath);
+				if (!snapshot.ok || !snapshot.snapshot) return false;
+				const entries = snapshot.snapshot.entries;
+				return entries.length === 1 && entries[0]?.relativePath === "" && entries[0].kind === "directory";
+			})();
+		const retainedArtifactsEvidence =
+			retainedArtifactsRootOnly && deleted.kind === "cleanup_pending" && deleted.phase === "artifacts"
+				? {
+						detachedArtifactsPath: deleted.detachedArtifactsPath,
+						...(deleted.artifactsIdentity
+							? { artifactsIdentity: serializeCleanupIdentity(deleted.artifactsIdentity) }
+							: {}),
+					}
+				: {};
+		if (deleted.kind === "artifacts_removed" || retainedArtifactsRootOnly) {
 			const transcriptPhaseCleanup = {
 				...preauthorizedCleanup,
 				phase: "transcript" as const,
 				artifactsRemoved: true,
-				...(deleted.kind === "cleanup_pending" && deleted.phase === "artifacts"
-					? {
-							detachedArtifactsPath: deleted.detachedArtifactsPath,
-							...(deleted.artifactsIdentity
-								? { artifactsIdentity: serializeCleanupIdentity(deleted.artifactsIdentity) }
-								: {}),
-						}
-					: {}),
+				...(retainedArtifactsRootOnly ? retainedArtifactsEvidence : {}),
 				...(preauthorizedCleanup.artifactTree
 					? { artifactTree: { ...preauthorizedCleanup.artifactTree, completed: true as const } }
 					: {}),

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,15 @@ 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. Generation 17 binds managed-session
+ * replacement to exact native filesystem authority.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 14,
-	slack: 14,
+	discord: 17,
+	slack: 17,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {