@gajae-code/coding-agent 0.12.1 → 0.12.4

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/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/bus/chat-daemon-control.ts

@@ -38,11 +38,12 @@ export type ChatDaemonAction = "stop" | "reload";
  * 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.
+ * 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: 16,
-	slack: 16,
+	discord: 17,
+	slack: 17,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

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

@@ -46,9 +46,10 @@ export const NOTIFICATION_PROTOCOL_VERSION = 3;
  * 33 adds action-bound multi-select state rendering and replay-safe option
  * snapshots. Generation 34 converts non-photo image formats (including WebP)
  * into Telegram-compatible photo uploads when possible. Generation 35 adds
- * user-created topic adoption (forum-topic folder picker).
+ * user-created topic adoption (forum-topic folder picker). Generation 36 binds
+ * managed-session replacement to exact native filesystem authority.
  */
-export const DAEMON_GENERATION = 35;
+export const DAEMON_GENERATION = 36;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers

package/src/sdk/protocol/operation-inventory.generated.json

@@ -2531,6 +2531,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:registerToolSessionCleanup",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal tool lifecycle cleanup registration, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:getAsyncJobSnapshot",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/sdk/session.ts

@@ -1623,6 +1623,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 			},
 			getArtifactManager: () => sessionManager.getArtifactManager(),
+			registerSessionCleanup: cleanup => session?.registerToolSessionCleanup(cleanup) ?? (() => {}),
 			settings,
 			authStorage,
 			modelRegistry,

package/src/session/agent-session.ts

@@ -1884,6 +1884,7 @@ export class AgentSession {
 	#providerCacheSessionId: string | undefined;
 	#isDisposed = false;
 	#disposePromise: Promise<void> | undefined;
+	readonly #toolSessionCleanups = new Set<() => Promise<void> | void>();
 	#newSessionTransition: Promise<boolean> | undefined;
 	// Extension system
 	#extensionRunner: ExtensionRunner | undefined = undefined;
@@ -3233,6 +3234,21 @@ export class AgentSession {
 		return this.#agentId;
 	}
 
+	registerToolSessionCleanup(cleanup: () => Promise<void> | void): () => void {
+		if (this.#isDisposed) throw new Error("Cannot register tool cleanup after session disposal has started.");
+		this.#toolSessionCleanups.add(cleanup);
+		return () => this.#toolSessionCleanups.delete(cleanup);
+	}
+
+	async #runToolSessionCleanups(): Promise<void> {
+		const cleanups = Array.from(this.#toolSessionCleanups);
+		this.#toolSessionCleanups.clear();
+		const results = await Promise.allSettled(cleanups.map(async cleanup => await cleanup()));
+		for (const result of results) {
+			if (result.status === "rejected") logger.warn("Tool session cleanup failed", { error: String(result.reason) });
+		}
+	}
+
 	getAsyncJobSnapshot(options?: { recentLimit?: number }): AsyncJobSnapshot | null {
 		const manager = AsyncJobManager.instance();
 		if (!manager) return null;
@@ -5565,6 +5581,7 @@ export class AgentSession {
 				AsyncJobManager.setInstance(undefined);
 			}
 		}
+		await this.#runToolSessionCleanups();
 		// Only disconnect the MCP manager THIS session owns (top-level sessions that
 		// connected plugin-bundle MCP servers). Subagents and callers that merely
 		// observe the process-global manager must never tear down a manager they do
@@ -15703,7 +15720,10 @@ export class AgentSession {
 	 */
 	async switchSession(
 		sessionPath: string,
-		options?: { transition?: SessionSwitchEvent["transition"] },
+		options?: {
+			transition?: SessionSwitchEvent["transition"];
+			onTransitionMutationStarted?: () => void;
+		},
 	): Promise<boolean> {
 		this.#beginSessionTransition("switch-session");
 		try {
@@ -15723,6 +15743,7 @@ export class AgentSession {
 					return false;
 				}
 			}
+			options?.onTransitionMutationStarted?.();
 
 			this.#disconnectFromAgent();
 			await this.abort();