@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/modes/controllers/selector-controller.ts

@@ -40,6 +40,7 @@ import {
 	theme,
 } from "../../modes/theme/theme";
 import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
+import { acquireResumeProgressLease } from "../../modes/utils/ui-helpers";
 import { getNotificationConfig, isTelegramConfigured, maskToken } from "../../sdk/bus/config";
 import {
 	clearTelegramActivationMarker,
@@ -2052,26 +2053,40 @@ export class SelectorController {
 		return true;
 	}
 
-	async handleResumeSession(sessionPath: string): Promise<void> {
-		const previousSessionId = this.ctx.sessionManager.getSessionId();
-		this.#clearTransientSessionUi();
-		const migrationPolicy =
-			this.ctx.settings?.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain";
-		const writableSessionPath = await this.ctx.sessionManager.prepareManagedCandidateForWrite(
-			sessionPath,
-			migrationPolicy,
-		);
-
-		// Switch session via AgentSession (emits hook and tool session events)
-		if (!(await this.ctx.session.switchSession(writableSessionPath))) return;
-		const switchingToDifferentSession = previousSessionId !== this.ctx.sessionManager.getSessionId();
-		if (switchingToDifferentSession) this.ctx.resetIrcSidebarSession();
-		this.#refreshSessionTerminalTitle();
-		this.ctx.updateEditorBorderColor();
+	async handleResumeSession(
+		sessionPath: string,
+		options?: { requireIdle?: boolean },
+		onSwitched?: () => void,
+	): Promise<boolean> {
+		const progress = acquireResumeProgressLease(this.ctx);
+		await progress.committed;
+		try {
+			const previousSessionId = this.ctx.sessionManager.getSessionId();
+			const migrationPolicy =
+				this.ctx.settings?.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain";
+			const writableSessionPath = await this.ctx.sessionManager.prepareManagedCandidateForWrite(
+				sessionPath,
+				migrationPolicy,
+			);
 
-		this.ctx.rebuildInitialMessages(switchingToDifferentSession ? "replace-identity" : "reconcile-same-transcript");
-		await this.ctx.reloadTodos();
-		this.ctx.showStatus("Resumed session");
+			// Switch session via AgentSession (emits hook and tool session events)
+			if (!(await this.ctx.session.switchSession(writableSessionPath, options))) return false;
+			onSwitched?.();
+			this.#clearTransientSessionUi();
+			const switchingToDifferentSession = previousSessionId !== this.ctx.sessionManager.getSessionId();
+			if (switchingToDifferentSession) this.ctx.resetIrcSidebarSession();
+			this.#refreshSessionTerminalTitle();
+			this.ctx.updateEditorBorderColor();
+
+			this.ctx.rebuildInitialMessages(
+				switchingToDifferentSession ? "replace-identity" : "reconcile-same-transcript",
+			);
+			await this.ctx.reloadTodos();
+			this.ctx.showStatus("Resumed session");
+			return true;
+		} finally {
+			progress.clear();
+		}
 	}
 
 	async handleSessionDeleteCommand(): Promise<void> {
@@ -2158,6 +2173,7 @@ export class SelectorController {
 		}
 
 		this.ctx.showStatus(`Logging in to ${providerId}… (Esc to cancel)`);
+		let authorizationUrlLease: number | undefined;
 		const manualInput = this.ctx.oauthManualInput;
 		const useManualInput = CALLBACK_SERVER_PROVIDERS.has(providerId as OAuthProvider);
 		const abort = new AbortController();
@@ -2172,6 +2188,7 @@ export class SelectorController {
 			await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {
 				signal: abort.signal,
 				onAuth: (info: { url: string; instructions?: string }) => {
+					authorizationUrlLease = this.ctx.setOAuthAuthorizationUrl(info.url);
 					this.ctx.chatContainer.addChild(new Spacer(1));
 					this.ctx.chatContainer.addChild(new Text(theme.fg("dim", info.url), 1, 0));
 					const hyperlink = `\x1b]8;;${info.url}\x07Click here to login\x1b]8;;\x07`;
@@ -2184,6 +2201,16 @@ export class SelectorController {
 						this.ctx.chatContainer.addChild(new Spacer(1));
 						this.ctx.chatContainer.addChild(new Text(theme.fg("dim", MANUAL_LOGIN_TIP), 1, 0));
 					}
+					this.ctx.chatContainer.addChild(
+						new Text(
+							theme.fg(
+								"dim",
+								`Press ${this.ctx.keybindings.getDisplayString("app.oauth.copyUrl")} to copy the authorization URL.`,
+							),
+							1,
+							0,
+						),
+					);
 					this.ctx.ui.requestRender();
 					this.ctx.openInBrowser(info.url);
 				},
@@ -2235,6 +2262,7 @@ export class SelectorController {
 			if (useManualInput) {
 				manualInput.clear(`Manual OAuth input cleared for ${providerId}`);
 			}
+			if (authorizationUrlLease !== undefined) this.ctx.clearOAuthAuthorizationUrl(authorizationUrlLease);
 		}
 	}
 

package/src/modes/interactive-mode.ts

@@ -312,6 +312,25 @@ export function selectShutdownDraft(editorText: string, hasActiveBtw: boolean):
 	return hasActiveBtw ? "" : editorText;
 }
 
+export class OAuthAuthorizationUrlState {
+	#active: { url: string; lease: number } | undefined;
+	#nextLease = 0;
+
+	set(url: string): number {
+		const lease = ++this.#nextLease;
+		this.#active = { url, lease };
+		return lease;
+	}
+
+	clear(lease: number): void {
+		if (this.#active?.lease === lease) this.#active = undefined;
+	}
+
+	get current(): string | undefined {
+		return this.#active?.url;
+	}
+}
+
 export class InteractiveMode implements InteractiveModeContext {
 	session: AgentSession;
 	sessionManager: SessionManager;
@@ -384,6 +403,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	fileSlashCommands: Set<string> = new Set();
 	skillCommands: Map<string, Skill> = new Map();
 	oauthManualInput: OAuthManualInputManager = new OAuthManualInputManager();
+	#oauthAuthorizationUrl = new OAuthAuthorizationUrlState();
 	promptSuggestion: PromptSuggestionController;
 
 	#baseSlashCommands: SlashCommand[] = [];
@@ -697,6 +717,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		const startupQuiet = settings.get("startup.quiet");
 		const welcomeLogoMode = resolveWelcomeLogoMode(settings.get("startup.welcomeBannerMode"));
+		const skipLogoAnimation = settings.get("startup.skipLogoAnimation");
 		this.#welcomeComponent = undefined;
 
 		for (const warning of this.session.configWarnings) {
@@ -722,6 +743,7 @@ export class InteractiveMode implements InteractiveModeContext {
 					rightGutterWidth: COMPOSER_RIGHT_GUTTER_WIDTH,
 					collapseChangelog: settings.get("collapseChangelog"),
 					keyDisplayContext: this.#keyDisplayContext,
+					skipLogoAnimation,
 				},
 			);
 
@@ -2042,6 +2064,33 @@ export class InteractiveMode implements InteractiveModeContext {
 	openInBrowser(urlOrPath: string): void {
 		this.#commandController.openInBrowser(urlOrPath);
 	}
+	setOAuthAuthorizationUrl(url: string): number {
+		return this.#oauthAuthorizationUrl.set(url);
+	}
+
+	clearOAuthAuthorizationUrl(lease: number): void {
+		this.#oauthAuthorizationUrl.clear(lease);
+	}
+
+	hasOAuthAuthorizationUrl(): boolean {
+		return this.#oauthAuthorizationUrl.current !== undefined;
+	}
+
+	async copyOAuthAuthorizationUrl(): Promise<void> {
+		const url = this.#oauthAuthorizationUrl.current;
+		if (!url) {
+			this.showWarning("No OAuth authorization URL is available to copy.");
+			return;
+		}
+		try {
+			await copyToClipboard(url);
+			this.showStatus("OAuth authorization URL copied to clipboard");
+		} catch (error) {
+			this.showError(
+				`Failed to copy OAuth authorization URL: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
 
 	// Selector handling
 	showCommandPalette(
@@ -2104,10 +2153,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showSessionSelector();
 	}
 
-	handleResumeSession(sessionPath: string): Promise<void> {
-		this.#btwController.dispose();
-		this.resetObserverRegistry();
-		return this.#selectorController.handleResumeSession(sessionPath);
+	handleResumeSession(sessionPath: string, options?: { requireIdle?: boolean }): Promise<boolean> {
+		return this.#selectorController.handleResumeSession(sessionPath, options, () => {
+			this.#btwController.dispose();
+			this.resetObserverRegistry();
+		});
 	}
 
 	handleSessionDeleteCommand(): Promise<void> {

package/src/modes/shared/agent-wire/unattended-session.ts

@@ -104,6 +104,12 @@ export function modelSupportsTokenCostMetrics(model: Model | undefined): boolean
 export interface WorkflowGateEmitter {
 	/** True only when unattended mode has been negotiated. */
 	isUnattended(): boolean;
+	/**
+	 * True when gates emitted through this emitter can be answered remotely
+	 * (workflow_gate_response over RPC/bridge). The ask tool refuses headless
+	 * execution unless this reports true.
+	 */
+	supportsRemoteGateAnswers(): boolean;
 	/** Open + emit a gate; resolves with the agent's answer (from workflow_gate_response). */
 	emitGate(input: OpenGateInput): Promise<unknown>;
 	/**
@@ -157,6 +163,10 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		return this.#controller !== undefined;
 	}
 
+	supportsRemoteGateAnswers(): boolean {
+		return true;
+	}
+
 	/** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
 	onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void {
 		this.#gateListeners.add(listener);
@@ -219,19 +229,27 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		this.#broker = new WorkflowGateBroker(this.opts.runId, this.opts.store ?? new MemoryGateStore(), {
 			emit: gate => this.opts.emitFrame(gate),
 			audit: e => this.opts.audit?.(e),
-			advance: (gate, answer) => {
-				const pending = this.#pending.get(gate.gate_id);
+			// The broker verifies the continuation is still live *after* `advance`
+			// returns, so the pending waiter must survive advance and only settle in
+			// `completeAccepted` (mirroring the session-side gate emitter).
+			advance: () => {},
+			completeAccepted: record => {
+				const pending = this.#pending.get(record.gate.gate_id);
 				if (pending) {
-					this.#pending.delete(gate.gate_id);
-					pending.resolve(answer);
+					this.#pending.delete(record.gate.gate_id);
+					pending.resolve(record.answer);
 					return;
 				}
 				// A controller may answer synchronously while emitFrame is still on the
 				// stack. Keep the accepted answer so emitGate can still resolve after
 				// openGate returns and the caller starts awaiting.
-				this.#earlyAnswers.set(gate.gate_id, answer);
+				this.#earlyAnswers.set(record.gate.gate_id, record.answer);
 			},
 			finalizeAccepted: record => this.#finalizeAcceptedGate(record),
+			// The control plane's durable record is the gate store itself; it never
+			// publishes a separate terminal transcript, so accepted gates (live and
+			// recovered) terminalize with the designed "not_published" proof.
+			terminalizeAccepted: () => "not_published",
 		});
 		this.#brokerReady = true;
 		void this.startRecoveryOnce();
@@ -496,7 +514,21 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		if (!this.#broker) {
 			return Promise.reject(new Error("cannot emit a workflow gate before unattended mode is negotiated"));
 		}
-		const gate = this.#broker.openGate(input);
+		// Opening without a continuation quarantines the gate as
+		// "opened_without_continuation", which makes it permanently unanswerable.
+		// Register the pending waiter through the continuation contract so the
+		// broker records a live, resolvable gate and can fence it on release.
+		const waiter = Promise.withResolvers<unknown>();
+		const gate = this.#broker.openGate(input, {
+			activate: opened => this.#pending.set(opened.gate_id, { resolve: waiter.resolve, reject: waiter.reject }),
+			isLive: gateId => this.#pending.has(gateId),
+			release: gateId => {
+				const pending = this.#pending.get(gateId);
+				if (!pending) return;
+				this.#pending.delete(gateId);
+				pending.reject(new Error(`workflow gate ${gateId} continuation was fenced`));
+			},
+		});
 		for (const listener of this.#gateListeners) {
 			try {
 				listener(gate);
@@ -507,11 +539,10 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		if (this.#earlyAnswers.has(gate.gate_id)) {
 			const answer = this.#earlyAnswers.get(gate.gate_id);
 			this.#earlyAnswers.delete(gate.gate_id);
+			this.#pending.delete(gate.gate_id);
 			return Promise.resolve(answer);
 		}
-		const { promise, resolve, reject } = Promise.withResolvers<unknown>();
-		this.#pending.set(gate.gate_id, { resolve, reject });
-		return promise;
+		return waiter.promise;
 	}
 
 	async recover(): Promise<void> {

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -96,6 +96,8 @@ export interface AskSelectedAckRecoveryParticipant {
 /** SDK-native surface for emitting a workflow gate and awaiting its answer. */
 export interface WorkflowGateEmitter {
 	supportsRemoteGateAnswers(): boolean;
+	/** True when an unattended run has been negotiated for this emitter (control-plane emitters). */
+	isUnattended?(): boolean;
 	emitGate(input: OpenGateInput): Promise<unknown>;
 	onGateEmitted?(listener: (gate: WorkflowGate) => void): () => void;
 	resolveGate?(response: WorkflowGateResponse): Promise<WorkflowGateResolution>;

package/src/modes/types.ts

@@ -298,6 +298,10 @@ export interface InteractiveModeContext {
 	): Promise<CompactionOutcome>;
 
 	openInBrowser(urlOrPath: string): void;
+	setOAuthAuthorizationUrl(url: string): number;
+	hasOAuthAuthorizationUrl(): boolean;
+	clearOAuthAuthorizationUrl(lease: number): void;
+	copyOAuthAuthorizationUrl(): Promise<void>;
 	/** Resolved source of truth for slash autocomplete and command palette entries. */
 	getSlashCommands?(): readonly SlashCommand[];
 	refreshSlashCommandState(cwd?: string): Promise<void>;
@@ -322,7 +326,7 @@ export interface InteractiveModeContext {
 	showTreeSelector(): void;
 	showSessionSelector(): void;
 	showSessionsDashboard(): void;
-	handleResumeSession(sessionPath: string): Promise<void>;
+	handleResumeSession(sessionPath: string, options?: { requireIdle?: boolean }): Promise<boolean>;
 	handleSessionDeleteCommand(): Promise<void>;
 	showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;