@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/session/yield-queue.ts

@@ -18,8 +18,9 @@ export interface YieldDispatcher<P> {
 export interface YieldQueueOptions {
 	isStreaming: () => boolean;
 	injectStreaming(msg: AgentMessage): void;
-	injectIdle(messages: AgentMessage[]): Promise<void>;
-	scheduleIdleFlush(run: () => Promise<void>): void;
+	injectIdle(messages: AgentMessage[], signal?: AbortSignal): Promise<void>;
+	scheduleIdleFlush(run: (signal?: AbortSignal) => Promise<void>, onSkip: () => void): void;
+	getIdleFlushSignal?(): AbortSignal | undefined;
 }
 
 type YieldFlushMode = "streaming" | "idle";
@@ -39,6 +40,7 @@ export class YieldQueue {
 	readonly #dispatchers = new Map<string, StoredDispatcher>();
 	readonly #entries = new Map<string, unknown[]>();
 	#idleFlushPending = false;
+	#idleFlushPendingOwner: symbol | undefined;
 
 	constructor(options: YieldQueueOptions) {
 		this.#options = options;
@@ -82,9 +84,10 @@ export class YieldQueue {
 		return false;
 	}
 
-	async flush(mode: YieldFlushMode): Promise<void> {
+	async flush(mode: YieldFlushMode, signal?: AbortSignal): Promise<void> {
 		if (mode === "idle") {
 			this.#idleFlushPending = false;
+			this.#idleFlushPendingOwner = undefined;
 		}
 		const idleMessages: AgentMessage[] = [];
 		for (const [kind, dispatcher] of this.#dispatchers) {
@@ -105,16 +108,20 @@ export class YieldQueue {
 		}
 		if (mode === "idle" && idleMessages.length > 0) {
 			try {
-				await this.#options.injectIdle(idleMessages);
+				await this.#options.injectIdle(idleMessages, signal ?? this.#options.getIdleFlushSignal?.());
 			} catch (error) {
 				logger.warn("Yield queue idle dispatch failed", { error: formatError(error) });
 			}
 		}
 	}
 
-	clear(): void {
+	clear(onDrop?: (kind: string, entries: readonly unknown[]) => void): void {
+		if (onDrop) {
+			for (const [kind, entries] of this.#entries) onDrop(kind, entries);
+		}
 		this.#entries.clear();
 		this.#idleFlushPending = false;
+		this.#idleFlushPendingOwner = undefined;
 	}
 
 	/** Drop only the queued entries of a single kind, leaving other kinds intact. */
@@ -140,14 +147,21 @@ export class YieldQueue {
 	#scheduleIdleFlush(): void {
 		if (this.#idleFlushPending) return;
 		this.#idleFlushPending = true;
+		const owner = Symbol("idle-flush");
+		this.#idleFlushPendingOwner = owner;
+		const releaseOwner = () => {
+			if (this.#idleFlushPendingOwner !== owner) return;
+			this.#idleFlushPendingOwner = undefined;
+			this.#idleFlushPending = false;
+		};
 		try {
-			this.#options.scheduleIdleFlush(async () => {
-				this.#idleFlushPending = false;
+			this.#options.scheduleIdleFlush(async signal => {
+				releaseOwner();
 				if (this.#options.isStreaming()) return;
-				await this.flush("idle");
-			});
+				await this.flush("idle", signal);
+			}, releaseOwner);
 		} catch (error) {
-			this.#idleFlushPending = false;
+			releaseOwner();
 			logger.warn("Yield queue idle flush scheduling failed", { error: formatError(error) });
 		}
 	}

package/src/setup/frictionless-onboarding.ts

@@ -748,6 +748,7 @@ export function shouldOfferOnboarding(state: FrictionlessOnboardingState): boole
 
 export interface AutomaticOnboardingInput {
 	normalInteractive: boolean;
+	automation?: boolean;
 	initialMessage?: string;
 	initialMessages: readonly string[];
 	initialImages?: readonly unknown[];
@@ -757,6 +758,7 @@ export interface AutomaticOnboardingInput {
 export function shouldOfferAutomaticOnboarding(input: AutomaticOnboardingInput): boolean {
 	return (
 		input.normalInteractive &&
+		!input.automation &&
 		!input.initialMessage &&
 		input.initialMessages.length === 0 &&
 		(input.initialImages?.length ?? 0) === 0 &&

package/src/slash-commands/builtin-registry.ts

@@ -139,6 +139,29 @@ function toSlashCommandRuntime(runtime: TuiSlashCommandRuntime): SlashCommandRun
 	};
 }
 
+async function updateSessionStar(
+	starred: boolean,
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+): Promise<SlashCommandResult> {
+	if (command.args) return usage(`Usage: /${starred ? "star" : "unstar"}`, runtime);
+	if (!runtime.sessionManager.isPersisted()) {
+		await runtime.output("Session stars require a persisted session.");
+		return commandConsumed();
+	}
+	const changed = await runtime.sessionManager.setSessionStarred(starred);
+	await runtime.output(
+		changed
+			? starred
+				? "Session starred."
+				: "Session unstarred."
+			: starred
+				? "Session is already starred."
+				: "Session is not starred.",
+	);
+	return commandConsumed();
+}
+
 function parseProviderSetupSlashArgs(args: string): {
 	preset?: string;
 	compat?: string;
@@ -1961,6 +1984,24 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleContributionPrepCommand(command.args || undefined);
 		},
 	},
+	{
+		name: "star",
+		priority: 91,
+		description: "Star the current session for easier discovery",
+		// Accept args at dispatch so the handler can consume them as a usage error
+		// instead of silently forwarding `/star ...` to the model.
+		allowArgs: true,
+		handle: (command, runtime) => updateSessionStar(true, command, runtime),
+	},
+	{
+		name: "unstar",
+		priority: 91,
+		description: "Remove the star from the current session",
+		// Accept args at dispatch so the handler can consume them as a usage error
+		// instead of silently forwarding `/unstar ...` to the model.
+		allowArgs: true,
+		handle: (command, runtime) => updateSessionStar(false, command, runtime),
+	},
 	{
 		name: "resume",
 		priority: 92,

package/src/task/executor.ts

@@ -2114,12 +2114,17 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 			if (extensionRunner && !options.preflightProbe) {
 				extensionRunner.initialize(
 					{
+						// Extension sends are INDEPENDENT producers (see runtime-init):
+						// classify them at the trusted adapter so a terminal abort keeps
+						// them rather than dropping them as turn-owned continuations.
 						sendMessage: (message, options) => {
-							const sendPromise = session.sendCustomMessage(message, options).catch(e => {
-								logger.error("Extension sendMessage failed", {
-									error: e instanceof Error ? e.message : String(e),
+							const sendPromise = session
+								.sendCustomMessage(message, { ...options, origin: "external" })
+								.catch(e => {
+									logger.error("Extension sendMessage failed", {
+										error: e instanceof Error ? e.message : String(e),
+									});
 								});
-							});
 							pendingExtensionMessages.push(sendPromise);
 						},
 						sendUserMessage: (content, options) => {