@gajae-code/coding-agent 0.17.2 → 0.17.5

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

@@ -155,7 +155,12 @@ import {
 	MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
 	MODEL_ONBOARDING_SETUP_COMMAND,
 } from "../../setup/model-onboarding-guidance";
-import { addApiCompatibleProvider, formatProviderSetupResult } from "../../setup/provider-onboarding";
+import {
+	addApiCompatibleProvider,
+	formatProviderSetupResult,
+	probeOpenAIModelsList,
+	reloadAndRefreshDiscoveryCatalog,
+} from "../../setup/provider-onboarding";
 import { getThinkingLevelMetadata } from "../../thinking";
 import {
 	isConfigurableSearchProviderId,
@@ -1821,15 +1826,48 @@ export class SelectorController {
 		this.showSelector(done => {
 			let wizard: CustomProviderWizardComponent;
 			const submit = async (input: CustomProviderWizardSubmit): Promise<void> => {
+				// Component-owned generation: revision or cancel after submit
+				// start invalidates this attempt. Both completion branches
+				// check it so a stale refresh cannot report success or
+				// rerender over inputs the user has since revised.
+				const generation = wizard.currentSubmitGeneration();
+				const isCurrentSubmission = (): boolean => wizard.isSubmitCurrent(generation);
 				try {
-					const result = await addApiCompatibleProvider(input);
-					await this.ctx.session.modelRegistry.refresh("offline", this.ctx.session.credentialSessionId);
+					const result = await addApiCompatibleProvider({
+						...input,
+						authStorage: this.ctx.session.modelRegistry.authStorage,
+					});
+					let recoveryHint: string | null = null;
+					if (result.discoveryEnabled && !result.preset) {
+						// A discovery-only add has no static models and no cache yet,
+						// so an offline reload alone leaves an empty catalog. Refresh
+						// only the new provider online; a hint is surfaced instead
+						// of unconditional success when it stays unavailable.
+						recoveryHint = await reloadAndRefreshDiscoveryCatalog(
+							this.ctx.session.modelRegistry,
+							result.providerId,
+							this.ctx.session.credentialSessionId,
+						);
+					} else {
+						await this.ctx.session.modelRegistry.refresh("offline", this.ctx.session.credentialSessionId);
+					}
 					await this.ctx.notifyConfigChanged?.();
-					this.ctx.showStatus(formatProviderSetupResult(result));
+					// A late settle after Esc-cancel or a mid-submit revision
+					// must not drive completion UI: done() restores the
+					// composer and could close a selector the user opened
+					// after dismissal, and a stale refresh must not report
+					// success over revised inputs.
+					if (!isCurrentSubmission()) return;
+					this.ctx.showStatus(
+						recoveryHint
+							? `${formatProviderSetupResult(result)}\n${recoveryHint}`
+							: formatProviderSetupResult(result),
+					);
 					wizard.complete();
 					done();
 					this.ctx.ui.requestRender();
 				} catch (err) {
+					if (!isCurrentSubmission()) return;
 					const message = err instanceof Error ? err.message : String(err);
 					wizard.setSubmitError(`Provider setup failed: ${message}`);
 				}
@@ -1843,6 +1881,9 @@ export class SelectorController {
 					this.ctx.ui.requestRender();
 				},
 				() => this.ctx.ui.requestRender(),
+				{
+					discoverModels: async request => probeOpenAIModelsList(request),
+				},
 			);
 			return { component: wizard, focus: wizard };
 		});
@@ -3070,36 +3111,138 @@ export class SelectorController {
 		});
 	}
 
-	showUserMessageSelector(): void {
-		const userMessages = this.ctx.session.getUserMessagesForBranching();
+	#forkBusyReason(): string | undefined {
+		if (this.ctx.session.isStreaming) {
+			return "Wait for the current response to finish or abort it before forking.";
+		}
+		if (this.ctx.session.isCompacting) {
+			return "Wait for compaction to finish or abort it before forking.";
+		}
+		if (this.ctx.hasPendingSubmission()) {
+			return "Wait for the pending message to be submitted or cancel it before forking.";
+		}
+		if (this.ctx.bashComponent || this.ctx.pythonComponent) {
+			return "Wait for the foreground command to finish or cancel it before forking.";
+		}
+		return undefined;
+	}
 
+	showUserMessageSelector(onCommitted?: () => void): void {
+		const openedSessionId = this.ctx.sessionManager.getSessionId();
+		const openedSessionFile = this.ctx.sessionManager.getSessionFile();
+		if (!openedSessionFile) {
+			this.ctx.showError("Fork requires a persisted session");
+			return;
+		}
+		const busyReason = this.#forkBusyReason();
+		if (busyReason) {
+			this.ctx.showWarning(busyReason);
+			return;
+		}
+
+		const userMessages = this.ctx.session.getUserMessagesForBranching();
 		if (userMessages.length === 0) {
 			this.ctx.showStatus("No messages to branch from");
 			return;
 		}
 
+		this.ctx.goalModeController.cancelContinuation();
+		// Close the side-chat composer before the picker takes ownership, including
+		// paths that cancel, fail, or stop while branch() is pending.
+		if (this.ctx.hasActiveBtw()) this.ctx.handleBtwEscape();
+
 		this.showSelector(done => {
+			let selectionInFlight = false;
+			const closeWithoutBranch = (message: string, error = false): void => {
+				done();
+				if (error) {
+					this.ctx.showError(message);
+				} else {
+					this.ctx.showStatus(message);
+				}
+				this.ctx.goalModeController.scheduleContinuation();
+				this.ctx.ui.requestRender();
+			};
 			const selector = new UserMessageSelectorComponent(
 				userMessages.map(m => ({ id: m.entryId, text: m.text })),
 				async entryId => {
-					const result = await this.ctx.session.branch(entryId);
-					if (result.cancelled) {
-						// Hook cancelled the branch
-						done();
-						this.ctx.ui.requestRender();
+					if (selectionInFlight) return;
+					selectionInFlight = true;
+
+					if (
+						this.ctx.sessionManager.getSessionId() !== openedSessionId ||
+						this.ctx.sessionManager.getSessionFile() !== openedSessionFile
+					) {
+						closeWithoutBranch("Fork cancelled because the active session changed", true);
+						return;
+					}
+					const busyReason = this.#forkBusyReason();
+					if (busyReason) {
+						closeWithoutBranch(busyReason);
 						return;
 					}
-					this.ctx.resetIrcSidebarSession();
 
-					this.ctx.rebuildInitialMessages("replace-identity");
-					this.ctx.editor.setText(result.selectedText);
+					let selectedText = userMessages.find(message => message.entryId === entryId)!.text;
+					let branchFailure: unknown;
+					try {
+						const result = await this.ctx.session.branch(entryId);
+						if (this.ctx.isStopped?.()) return;
+						if (result.cancelled) {
+							closeWithoutBranch("Fork cancelled");
+							return;
+						}
+						selectedText = result.selectedText;
+					} catch (error) {
+						if (this.ctx.isStopped?.()) return;
+						const committed =
+							this.ctx.sessionManager.getSessionId() !== openedSessionId ||
+							this.ctx.sessionManager.getSessionFile() !== openedSessionFile;
+						if (!committed) {
+							closeWithoutBranch(`Fork failed: ${error instanceof Error ? error.message : String(error)}`, true);
+							return;
+						}
+						// The successor is already durable. Never describe this as a
+						// cancelled transition or roll it back to the parent's UI.
+						branchFailure = error;
+					}
+
+					try {
+						onCommitted?.();
+					} catch (error) {
+						branchFailure ??= error;
+					}
+					try {
+						this.ctx.resetIrcSidebarSession();
+						this.ctx.resetObserverRegistry();
+						this.#refreshSessionTerminalTitle();
+						this.ctx.statusLine.invalidate();
+						this.ctx.statusLine.setSessionStartTime(Date.now());
+						this.ctx.updateEditorTopBorder();
+						this.ctx.updateEditorBorderColor();
+						this.ctx.rebuildInitialMessages("replace-identity");
+						await this.ctx.reloadTodos();
+					} catch (error) {
+						branchFailure ??= error;
+					}
+					if (this.ctx.isStopped?.()) return;
+					this.ctx.editor.setText(selectedText);
 					done();
-					this.ctx.showStatus("Branched to new session");
+					if (branchFailure !== undefined) {
+						this.ctx.showError(
+							`Fork created, but session setup failed: ${branchFailure instanceof Error ? branchFailure.message : String(branchFailure)}`,
+						);
+					} else {
+						this.ctx.showStatus("Forked to a new session; edit the selected prompt to continue");
+					}
+					// Do not schedule goal continuation over the selected prompt draft.
+					this.ctx.ui.requestRender();
 				},
 				() => {
 					done();
+					this.ctx.goalModeController.scheduleContinuation();
 					this.ctx.ui.requestRender();
 				},
+				() => this.ctx.ui.terminal.rows,
 			);
 			return { component: selector, focus: selector.getMessageList() };
 		});
@@ -3274,6 +3417,9 @@ export class SelectorController {
 						});
 					}
 				},
+				undefined,
+				undefined,
+				(session, starred) => this.ctx.sessionManager.setSessionStarredForPicker(session, starred),
 			);
 			selector.setOnRequestRender(() => this.ctx.ui.requestRender());
 			return { component: selector, focus: selector };

package/src/modes/interactive-mode.ts

@@ -2265,10 +2265,24 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	#prepareSessionSwitch(cleanupPreviousSessionUi?: () => void): void {
-		this.#btwController.dispose();
-		if (cleanupPreviousSessionUi) cleanupPreviousSessionUi();
-		else this.#extensionUiController.clearExtensionTerminalInputListeners();
-		this.#planModeController.clearReview();
+		const errors: unknown[] = [];
+		try {
+			this.#btwController.dispose();
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			if (cleanupPreviousSessionUi) cleanupPreviousSessionUi();
+			else this.#extensionUiController.clearExtensionTerminalInputListeners();
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			this.#planModeController.clearReview();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Previous session UI cleanup failed");
 	}
 
 	async handleClearCommand(): Promise<boolean> {
@@ -2291,7 +2305,6 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	handleForkCommand(): Promise<void> {
-		this.#btwController.dispose();
 		return this.#commandController.handleForkCommand();
 	}
 
@@ -2299,7 +2312,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleMoveCommand(targetPath);
 	}
 
-	handleRenameCommand(title: string): Promise<void> {
+	handleRenameCommand(title?: string): Promise<void> {
 		return this.#commandController.handleRenameCommand(title);
 	}
 
@@ -2564,7 +2577,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	showUserMessageSelector(): void {
-		this.#selectorController.showUserMessageSelector();
+		const cleanupPreviousSessionUi = this.#extensionUiController.captureSessionUiCleanup();
+		this.#selectorController.showUserMessageSelector(() => this.#prepareSessionSwitch(cleanupPreviousSessionUi));
 	}
 
 	showTreeSelector(): void {

package/src/modes/runtime-init.ts

@@ -123,6 +123,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			getCredentialSessionId: () => session.credentialSessionId,
 			isIdle: () => !session.isStreaming,
 			getActivePromptHandle: () => session.activePromptHandle,
+			getSessionWorkLease: () => session.sessionWorkLease,
 			abort: () => session.abort(),
 			abortPromptAndWait: (handle, abortOptions) => session.abortPromptAndWait(handle, abortOptions),
 			hasPendingMessages: () => session.queuedMessageCount > 0,

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

@@ -24,6 +24,7 @@ import type {
 	WorkflowGateOption,
 	WorkflowGateQueryRecord,
 	WorkflowGateResolution,
+	WorkflowGateResolutionDiagnostic,
 	WorkflowGateResponse,
 	WorkflowGateValidationError,
 	WorkflowStage,
@@ -35,6 +36,9 @@ export type PersistedResolutionOrigin =
 	| { kind: "generic"; channel: "sdk" | "other" }
 	| { kind: "telegram_notification"; interactionActionId: string };
 
+/** Keep accepted diagnostics below the coordinator's cumulative Q12 snapshot cap. */
+export const MAX_ACCEPTED_WORKFLOW_GATE_QUERY_RECORDS = 32;
+
 export type PersistedAckPolicy =
 	| { kind: "none"; reason: "non_telegram" | "semantic_noncommit" | "legacy_unproven" }
 	| {
@@ -152,7 +156,7 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 	readonly #emitterHooks: Pick<BrokerHooks, "advance">;
 	#runtimeTurnProvider: (() => string | undefined) | undefined;
 
-	constructor(runId: string, store: GateStore, emitterHooks: Pick<BrokerHooks, "advance"> = {}) {
+	constructor(runId: string, store: GateStore, emitterHooks: Pick<BrokerHooks, "advance" | "continuationLost"> = {}) {
 		this.#runId = runId;
 		this.#store = store;
 		this.#emitterHooks = emitterHooks;
@@ -164,6 +168,7 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 			completeAccepted: record => this.#completeAccepted(record),
 			finalizeAccepted: record => this.#finalizeAccepted(record),
 			terminalizeAccepted: record => this.#terminalizeAccepted(record),
+			continuationLost: record => emitterHooks.continuationLost?.(record),
 		});
 	}
 
@@ -1147,6 +1152,8 @@ export type GateAuditEvent =
 	| { event: "gate_response_accepted"; gate_id: string; answer_hash: string }
 	| { event: "gate_response_rejected"; gate_id: string; answer_hash: string }
 	| { event: "gate_response_idempotent_replay"; gate_id: string }
+	/** An idempotent replay refused because this runtime cannot prove the continuation ran. */
+	| { event: "gate_response_replay_unproven"; gate_id: string }
 	| { event: "gate_response_idempotency_conflict"; gate_id: string }
 	| { event: "gate_response_already_resolved"; gate_id: string }
 	| { event: "gate_response_unknown_gate"; gate_id: string }
@@ -1171,6 +1178,8 @@ export interface BrokerHooks {
 	terminalizeAccepted?(record: PersistedGate): WorkflowGateTerminalProof | Promise<WorkflowGateTerminalProof>;
 	/** Runs only after a successful advance has been durably marked advanced. */
 	completeAccepted?(record: PersistedGate): void | Promise<void>;
+	/** Notifies the owning runtime when the accepted answer cannot reach its continuation. */
+	continuationLost?(record: PersistedGate): void;
 	/** Append-only audit sink. */
 	audit?(event: GateAuditEvent): void;
 }
@@ -1222,6 +1231,14 @@ export class WorkflowGateBroker {
 	private readonly gateLocks = new Map<string, Promise<void>>();
 	private readonly continuations = new Map<string, GateContinuation>();
 	readonly #terminalProofs = new Map<string, WorkflowGateTerminalProof>();
+	/**
+	 * Gates whose `completeAccepted` hook threw after `advanced:true` was already
+	 * committed, so the durable record claims completion the continuation never
+	 * received. In-memory by design: the stranded turn belongs to this process's
+	 * waiter, so a restart cannot resolve it either way and must not inherit a
+	 * claim it cannot honor (#5599).
+	 */
+	readonly #continuationLost = new Set<string>();
 
 	private async withGateLock<T>(gateId: string, operation: () => Promise<T>): Promise<T> {
 		const previous = this.gateLocks.get(gateId) ?? Promise.resolve();
@@ -1282,6 +1299,34 @@ export class WorkflowGateBroker {
 				`idempotency_conflict: gate ${response.gate_id} resolved with a different body`,
 			);
 		if (response.idempotency_key !== undefined && sameKey && sameBody) {
+			// A record whose `completeAccepted` threw is durably indistinguishable from a
+			// genuinely completed one: `advanced:true` is committed before the waiter is
+			// resolved, so the shape below matches either way. Reporting `completed` there
+			// told `resolveSdkWorkflowGate`'s catch path to return a successful resolution
+			// for a turn whose continuation was never resolved — `ok:true status:"accepted"`
+			// with an empty pending-gate list and a prompt stuck `in_flight` forever, with
+			// no recovery path because `recover()` skips advanced records (#5599).
+			//
+			// Downgrading to `accepted_incomplete` routes it through the existing
+			// recover-then-recheck branch and, when that cannot resolve it, surfaces the
+			// documented `terminal_uncertain` instead of a false success.
+			//
+			// TWO conditions, because the loss cannot be persisted: an `accepted` record
+			// may not carry a `lifecycle` and a `quarantined` one must be `advanced:false`,
+			// so the durable shape has nowhere to record it.
+			//
+			// 1. This runtime saw the hook throw.
+			if (this.#continuationLost.has(response.gate_id)) return { kind: "accepted_incomplete" };
+			// 2. The record belongs to a PREVIOUS runtime. A continuation waiter is
+			//    process-local and cannot survive a restart, so this process can never
+			//    prove the prior turn was resolved — and the in-memory set above is empty
+			//    after a restart, which is exactly how the first fix still handed back a
+			//    false `completed` on a cross-restart idempotent retry (#5599 review).
+			//    Fail closed instead. The cost is telling a retry "uncertain" about a gate
+			//    that did complete under the dead runtime; that is the honest answer
+			//    regardless, because the turn it belonged to died with that process and no
+			//    retry can continue it.
+			if (record.ownerInstanceId !== this.instanceId) return { kind: "accepted_incomplete" };
 			if (record.terminalized === true && record.advanced === true && record.resolution)
 				return { kind: "completed", resolution: record.resolution };
 			return { kind: "accepted_incomplete" };
@@ -1311,6 +1356,17 @@ export class WorkflowGateBroker {
 		return this.continuations.get(gateId)?.isLive(gateId) === true;
 	}
 
+	private recordContinuationLoss(gateId: string): void {
+		this.#continuationLost.add(gateId);
+		const lost = this.store.get(gateId);
+		if (!lost) return;
+		try {
+			this.hooks.continuationLost?.(lost);
+		} catch {
+			// A settlement notification must never replace the original resolution error.
+		}
+	}
+
 	hasRecoverableAcceptedGate(): boolean {
 		return this.store
 			.list()
@@ -1395,8 +1451,10 @@ export class WorkflowGateBroker {
 			.filter(
 				(
 					record,
-				): record is PersistedGate & { status: "quarantined"; lifecycle: WorkflowGateDiagnostic["lifecycle"] } =>
-					record.status === "quarantined" && record.lifecycle !== undefined,
+				): record is PersistedGate & {
+					status: "quarantined";
+					lifecycle: WorkflowGateDiagnostic["lifecycle"];
+				} => record.status === "quarantined" && record.lifecycle !== undefined,
 			)
 			.sort(
 				(left, right) =>
@@ -1408,6 +1466,7 @@ export class WorkflowGateBroker {
 				id: `diagnostic:${record.gate.gate_id}`,
 				tag: "quarantined",
 				lifecycle: record.lifecycle,
+				answer_recorded: Object.hasOwn(record, "answer"),
 			}));
 	}
 
@@ -1421,8 +1480,38 @@ export class WorkflowGateBroker {
 					this.hasLiveContinuation(record.gate.gate_id),
 			)
 			.sort(compareGates)
-			.map(record => ({ ...record.gate, id: `pending:${record.gate.gate_id}`, tag: "pending" }));
-		return [...pending, ...this.listGateDiagnostics()];
+			.map(record => ({
+				...record.gate,
+				id: `pending:${record.gate.gate_id}`,
+				tag: "pending" as const,
+				answer_recorded: false as const,
+			}));
+		const accepted: WorkflowGateResolutionDiagnostic[] = this.store
+			.list()
+			.filter((record): record is PersistedGate & { status: "accepted" } => record.status === "accepted")
+			.sort(
+				(left, right) =>
+					(right.resolution?.resolved_at ?? "").localeCompare(left.resolution?.resolved_at ?? "") ||
+					right.gate.gate_id.localeCompare(left.gate.gate_id),
+			)
+			.slice(0, MAX_ACCEPTED_WORKFLOW_GATE_QUERY_RECORDS)
+			.map(record => ({
+				...record.gate,
+				id: `diagnostic:${record.gate.gate_id}`,
+				tag: "accepted" as const,
+				answer_recorded: true as const,
+				resolved_at: record.resolution?.resolved_at ?? record.gate.created_at,
+				post_accept_disposition: this.#continuationLost.has(record.gate.gate_id)
+					? "continuation_lost"
+					: record.advanced
+						? record.ownerInstanceId === this.instanceId
+							? "advanced"
+							: "unknown"
+						: record.terminalized === true
+							? "terminalized"
+							: "accepted",
+			}));
+		return [...pending, ...accepted, ...this.listGateDiagnostics()];
 	}
 
 	/** Open and emit a gate. The pending record is persisted BEFORE emission. */
@@ -1516,6 +1605,17 @@ export class WorkflowGateBroker {
 			const sameBody = record.responseHash === responseHash;
 			const sameKey = record.idempotencyKey === response.idempotency_key;
 			if (response.idempotency_key !== undefined && sameKey && sameBody) {
+				// Same provenance rule as `lookupCompletedResolution`: an idempotent replay must
+				// not hand back an accepted resolution for a continuation this runtime cannot
+				// prove was resolved. Without this, a direct `resolveGate()` retry bypassed the
+				// lookup entirely and reproduced the original false success (#5599 review).
+				if (this.#continuationLost.has(response.gate_id) || record.ownerInstanceId !== this.instanceId) {
+					this.hooks.audit?.({ event: "gate_response_replay_unproven", gate_id: response.gate_id });
+					throw new WorkflowGateBrokerError(
+						"unknown_gate",
+						`accepted gate ${response.gate_id} cannot be replayed: this runtime cannot prove its continuation was resolved`,
+					);
+				}
 				this.hooks.audit?.({ event: "gate_response_idempotent_replay", gate_id: response.gate_id });
 				return record.resolution as WorkflowGateResolution;
 			}
@@ -1609,7 +1709,16 @@ export class WorkflowGateBroker {
 				`accepted gate ${response.gate_id} lost its continuation before advance completed`,
 			);
 		this.store.put({ ...latest, advanced: true });
-		await this.hooks.completeAccepted?.(this.store.get(response.gate_id) as PersistedGate);
+		// `advanced:true` is already durable, so a throw here cannot be undone — but it
+		// must not be reported as a completed resolution either. Mark the loss before
+		// rethrowing so `lookupCompletedResolution` stops claiming completion for a
+		// continuation that was never resolved (#5599).
+		try {
+			await this.hooks.completeAccepted?.(this.store.get(response.gate_id) as PersistedGate);
+		} catch (error) {
+			this.recordContinuationLoss(response.gate_id);
+			throw error;
+		}
 		this.continuations.get(response.gate_id)?.release?.(response.gate_id);
 		this.continuations.delete(response.gate_id);
 		return resolution;
@@ -1659,7 +1768,15 @@ export class WorkflowGateBroker {
 					if (latest?.status !== "accepted" || latest.advanced || !this.hasLiveContinuation(listed.gate.gate_id))
 						return;
 					this.store.put({ ...latest, advanced: true });
-					await this.hooks.completeAccepted?.(this.store.get(latest.gate.gate_id) as PersistedGate);
+					// Same durable-commit-then-resolve ordering as `resolve()`; mark the
+					// loss so a recovery attempt cannot leave behind a record that claims
+					// completion its continuation never received (#5599).
+					try {
+						await this.hooks.completeAccepted?.(this.store.get(latest.gate.gate_id) as PersistedGate);
+					} catch (error) {
+						this.recordContinuationLoss(latest.gate.gate_id);
+						throw error;
+					}
 					this.continuations.get(latest.gate.gate_id)?.release?.(latest.gate.gate_id);
 					this.continuations.delete(latest.gate.gate_id);
 					this.hooks.audit?.({ event: "gate_advance_recovered", gate_id: latest.gate.gate_id });

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

@@ -375,12 +375,26 @@ export interface WorkflowGateDiagnostic extends WorkflowGate {
 	id: string;
 	tag: "quarantined";
 	lifecycle: WorkflowGateLifecycle;
+	/** Whether the durable broker retained an answer for this gate. */
+	answer_recorded: boolean;
+}
+
+/** Durable acceptance evidence for a gate that is no longer pending. */
+export interface WorkflowGateResolutionDiagnostic extends WorkflowGate {
+	id: string;
+	tag: "accepted";
+	/** True when the accepted record contains the answer body. */
+	answer_recorded: true;
+	resolved_at: string;
+	/** Single post-accept disposition; raw answers and derived answer values stay private. */
+	post_accept_disposition: "accepted" | "terminalized" | "advanced" | "continuation_lost" | "unknown";
 }
 
 /** Stable Q12 row preserving the root WorkflowGate shape. */
 export type WorkflowGateQueryRecord =
-	| (WorkflowGate & { id: string; tag: "pending"; lifecycle?: undefined })
-	| WorkflowGateDiagnostic;
+	| (WorkflowGate & { id: string; tag: "pending"; lifecycle?: undefined; answer_recorded: false })
+	| WorkflowGateDiagnostic
+	| WorkflowGateResolutionDiagnostic;
 
 /** Inbound: the agent's answer to a workflow gate. */
 export interface WorkflowGateResponse {

package/src/modes/types.ts

@@ -409,7 +409,7 @@ export interface InteractiveModeContext {
 	handleHandoffCommand(customInstructions?: string): Promise<void>;
 	handleContributionPrepCommand(customInstructions?: string): Promise<void>;
 	handleMoveCommand(targetPath: string): Promise<void>;
-	handleRenameCommand(title: string): Promise<void>;
+	handleRenameCommand(title?: string): Promise<void>;
 	handleMemoryCommand(text: string): Promise<void>;
 	handleSTTToggle(): Promise<void>;
 	executeCompaction(
@@ -490,7 +490,7 @@ export interface InteractiveModeContext {
 	>;
 	goalModeController: Pick<
 		import("./controllers/goal-mode-controller").GoalModeController,
-		"enabled" | "paused" | "handleCommand"
+		"enabled" | "paused" | "handleCommand" | "cancelContinuation" | "scheduleContinuation"
 	>;
 	setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
 	setHookStatus(key: string, text: string | undefined): void;

package/src/prompts/agent-fragments/browser-aside.md

@@ -5,6 +5,7 @@ Routing:
 - Every task that requires a rendered page, authenticated/private browser state, live tabs, browser UI, screenshots, downloads behind cookies, history, saved credentials, or profile data MUST use Bash to invoke the installed Aside CLI.
 - Default to `aside repl '<JavaScript>'` for deterministic Playwright inspection and actions, even when the answer is unknown but the procedure is discoverable from `snapshot(page, { interactive: true })`.
 - Use `aside exec '<prompt>'` only for runtime judgment, source-heavy research, browser-history search, MFA or opaque password autofill, approval/notification waits, long monitoring, multi-site synthesis, routines, or work worth a second model. Continue with `aside exec --session <id> '<follow-up>'`. Use `--account`, `--model`, `--provider`, `--speed`, or `--effort` only when the task requires overriding user defaults.
+- Declare every Aside invocation on the Bash call itself with the structured `activity` argument: `{"kind":"browser","provider":"aside","mode":"repl"}` for `aside repl`, and `{"kind":"browser","provider":"aside","mode":"exec"}` for `aside exec` including `--session <id>` follow-ups. The declaration names the operation, not the command spelling: send it unchanged across wrappers, env prefixes, absolute CLI paths, quoting, and multiline commands, and omit it on Bash calls that do not invoke Aside.
 - Cookie-free public HTTP content that does not require rendered or authenticated browser state may use GJC `read` directly.
 
 Deterministic procedure:

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

@@ -1,2 +1,2 @@
-Generate a 3-6 word title for a coding session from the user's first message. Capture the main task or topic.
+Generate a 3-6 word title for a coding session from the supplied user message or conversation digest. If multiple messages are supplied, identify the primary/current task from the digest, weighting the newest substantive message highest; do not assume the first message is the task. If one message is supplied, capture its main task or topic.
 Output ONLY the title. No quotes or trailing punctuation.

package/src/prompts/tools/bash.md

@@ -17,7 +17,7 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
 {{/if}}
 {{#if foregroundFoldEnabled}}
-- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
+- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. The `job` tool's own await uses the same steer-fold behavior and grace window; `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
 - A user steer folds the same way: when the user sends a message while a foreground command has already run for at least 2 seconds, the command is folded into a background job and this call returns the background-start result plus the line `Folded into background job <id> because a user steer arrived; the command keeps running with its original timeout and its result will wake a later turn.` The steer is then delivered at this tool boundary, so handle it next; do not re-run the folded command. Steers that arrive within the first 2 seconds let the command finish normally. This applies only while `busyPromptMode` is `steer`; `toolInterruptPolicy` is not a gate, since a fold never kills the command.
 {{/if}}
 </instruction>

package/src/prompts/tools/job.md

@@ -2,7 +2,7 @@ Inspects, waits, or cancels async jobs.
 
 Background job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.
 
-In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
+In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. A `job` await also folds after the same 2-second grace window when a steer arrives, returning immediately with the still-running job id(s) while those jobs keep their original deadlines and wake a later turn with their results. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
 
 # Operations
 

package/src/prompts/tools/read.md

@@ -73,6 +73,8 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 `agent://<id>`, `artifact://<id>`, `rule://<name>`, and `local://<name>.md` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
 
+Bundled skills have no filesystem home, so the skill tool and skill discovery report them as `embedded:gjc/skills/<name>/SKILL.md`; read that identifier verbatim. Bundled skill fragments, when surfaced, likewise use `embedded:gjc/skill-fragments/...` identifiers.
+
 <critical>
 - Always include `path`; never call `read` with `{}`.
 - For line ranges, append the selector to `path`.