@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/src/modes/acp/acp-client-bridge.ts

@@ -21,27 +21,9 @@ import type {
 	ClientBridgePermissionToolCall,
 	ClientBridgeTerminalHandle,
 } from "../../session/client-bridge";
+import { resolveAcpPermissionMode } from "./permission-mode";
 
-type AcpPermissionMode = "auto" | "prompt" | "always-allow";
-
-const ACP_PERMISSION_MODE_ENV = "SKC_ACP_PERMISSION_MODE";
-
-function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
-	if (value === "auto" || value === "prompt" || value === "always-allow") return value;
-	return "prompt";
-}
-
-/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
-function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined): AcpPermissionMode {
-	const meta = clientCapabilities?._meta;
-	if (typeof meta === "object" && meta !== null) {
-		const skc = (meta as { skc?: unknown }).skc;
-		if (typeof skc === "object" && skc !== null && "permissionHandling" in skc) {
-			return parseAcpPermissionMode((skc as { permissionHandling?: unknown }).permissionHandling);
-		}
-	}
-	return parseAcpPermissionMode(process.env[ACP_PERMISSION_MODE_ENV]);
-}
+export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 
 export function createAcpClientBridge(
 	connection: AgentSideConnection,

package/src/modes/acp/acp-event-mapper.ts

@@ -232,6 +232,24 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "todo_auto_clear":
 			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries: [] })];
+		case "model_fallback_switched":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						skcModelFallbackSwitched: true,
+						skcModelFallbackEventId: event.eventId,
+						skcModelFallbackFrom: event.from,
+						skcModelFallbackTo: event.to,
+						skcModelFallbackReason: event.reason,
+						skcModelFallbackRole: event.role,
+						skcModelFallbackScope: event.scope,
+						skcModelFallbackActiveIndex: event.activeIndex,
+						skcModelFallbackChainLength: event.chainLength,
+						skcModelFallbackAttemptsUsed: event.attemptsUsed,
+					},
+				}),
+			];
 		// These event types are intentionally not represented as ACP session updates.
 		case "agent_start":
 		case "agent_end":
@@ -278,8 +296,6 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "auto_retry_start":
 		case "auto_retry_end":
-		case "retry_fallback_applied":
-		case "retry_fallback_succeeded":
 		case "ttsr_triggered":
 		case "irc_message":
 		case "subagent_steer_message":

package/src/modes/acp/acp-mode.ts

@@ -1,50 +1,22 @@
 import * as stream from "node:stream";
 import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
-import type { AgentSession } from "../../session/agent-session";
 import { AcpAgent } from "./acp-agent";
+import type { AcpStartupOptions } from "./startup-options";
 
-export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-
-export interface AcpConnectionHandle {
-	connection: AgentSideConnection;
-	agent: AcpAgent;
-}
-
-export function createAcpConnection(
-	transport: Stream,
-	createSession: AcpSessionFactory,
-	initialSession?: AgentSession,
-): AgentSideConnection {
-	return createAcpConnectionWithAgent(transport, createSession, initialSession).connection;
+export interface AcpModeOptions {
+	agentDir?: string;
+	startupOptions?: AcpStartupOptions;
 }
 
-/**
- * Create an ACP connection and return both the {@link AgentSideConnection} and the
- * underlying {@link AcpAgent}. Callers that need to await agent shutdown (terminal
- * delete/dispose work) after transport closure should use this instead of
- * {@link createAcpConnection}.
- */
-export function createAcpConnectionWithAgent(
-	transport: Stream,
-	createSession: AcpSessionFactory,
-	initialSession?: AgentSession,
-): AcpConnectionHandle {
-	let agent: AcpAgent | undefined;
-	const connection = new AgentSideConnection(conn => {
-		agent = new AcpAgent(conn, createSession, initialSession);
-		return agent;
-	}, transport);
-	return { connection, agent: agent! };
+export function createAcpConnection(transport: Stream, options: AcpModeOptions = {}): AgentSideConnection {
+	return new AgentSideConnection(conn => new AcpAgent(conn, options), transport);
 }
 
-export async function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never> {
+export async function runAcpMode(options: AcpModeOptions = {}): Promise<never> {
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);
-	const { connection, agent } = createAcpConnectionWithAgent(transport, createSession, initialSession);
+	const connection = createAcpConnection(transport, options);
 	await connection.closed;
-	// Await connection-local terminal work (active deletes, disposal) so
-	// `process.exit` never kills in-flight deletion/cleanup.
-	await agent.shutdownPromise;
 	process.exit(0);
 }

package/src/modes/acp/permission-mode.ts

@@ -0,0 +1,25 @@
+import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+
+export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+
+const ACP_PERMISSION_MODE_ENV = "SKC_ACP_PERMISSION_MODE";
+
+function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
+	if (value === "auto" || value === "prompt" || value === "always-allow") return value;
+	return "prompt";
+}
+
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+export function resolveAcpPermissionMode(
+	clientCapabilities: ClientCapabilities | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): AcpPermissionMode {
+	const meta = clientCapabilities?._meta;
+	if (typeof meta === "object" && meta !== null) {
+		const skc = (meta as { skc?: unknown }).skc;
+		if (typeof skc === "object" && skc !== null && "permissionHandling" in skc) {
+			return parseAcpPermissionMode((skc as { permissionHandling?: unknown }).permissionHandling);
+		}
+	}
+	return parseAcpPermissionMode(env[ACP_PERMISSION_MODE_ENV]);
+}

package/src/modes/acp/startup-options.ts

@@ -0,0 +1,6 @@
+/** Startup settings that ACP can apply through the canonical SDK control surface. */
+export interface AcpStartupOptions {
+	modelId?: string;
+	modelPreset?: string;
+	thinkingLevel?: string;
+}

package/src/modes/action-registry.ts

@@ -0,0 +1,165 @@
+import type { AppKeybinding } from "../config/keybindings";
+
+export type FocusDomain = "composer" | "selector" | "overlay" | "global";
+
+export interface ActionMetadata {
+	id: AppKeybinding;
+	title: string;
+	category: string;
+	bindingId?: AppKeybinding;
+	domains: readonly FocusDomain[];
+	exclusiveGroup?: string | false;
+}
+
+const action = (
+	id: AppKeybinding,
+	title: string,
+	category: string,
+	domains: FocusDomain[],
+	exclusiveGroup?: string | false,
+): ActionMetadata => ({
+	id,
+	title,
+	category,
+	bindingId: id,
+	domains,
+	exclusiveGroup,
+});
+
+export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
+	action("app.interrupt", "Interrupt", "Session", ["global"], false),
+	action("app.clear", "Clear", "Session", ["global"]),
+	action("app.exit", "Exit", "Session", ["global"]),
+	action("app.suspend", "Suspend", "Session", ["global"]),
+	action("app.thinking.cycle", "Cycle thinking level", "Thinking", ["composer"]),
+	action("app.thinking.toggle", "Toggle thinking", "Thinking", ["composer"]),
+	action("app.commandPalette.open", "Open command palette", "Navigation", ["composer"]),
+	action("app.model.cycleForward", "Next model", "Model", ["composer"]),
+	action("app.model.cycleBackward", "Previous model", "Model", ["composer"]),
+	action("app.model.select", "Select model", "Model", ["composer"]),
+	action("app.model.selectTemporary", "Select temporary model", "Model", ["composer"]),
+	action("app.tools.expand", "Toggle tool expansion", "Tools", ["composer"]),
+	action("app.tool.backgroundFold", "Fold foreground tool", "Tools", ["composer"]),
+	action("app.editor.external", "Open external editor", "Editor", ["composer"]),
+	action("app.message.followUp", "Send follow-up", "Messages", ["composer"]),
+	action("app.message.queue", "Queue message", "Messages", ["composer"]),
+	action("app.message.dequeue", "Edit queued message", "Messages", ["composer"]),
+	action("app.clipboard.pasteImage", "Paste image", "Clipboard", ["composer"]),
+	action("app.clipboard.copyLine", "Copy line", "Clipboard", ["composer"]),
+	action("app.clipboard.copyPrompt", "Copy prompt", "Clipboard", ["composer"]),
+	action("app.session.new", "New session", "Session", ["composer"]),
+	action("app.session.tree", "Session tree", "Session", ["composer"]),
+	action("app.session.fork", "Fork session", "Session", ["composer"]),
+	action("app.session.resume", "Resume session", "Session", ["composer"]),
+	action("app.session.observe", "Observe sessions", "Session", ["composer"]),
+	action("app.session.dashboard", "Show sessions dashboard", "Session", ["composer"]),
+	action("app.jobs.open", "Open jobs", "Jobs", ["composer"]),
+	action("app.session.togglePath", "Toggle session path", "Session", ["selector"]),
+	action("app.session.toggleSort", "Toggle session sort", "Session", ["selector"]),
+	action("app.session.rename", "Rename session", "Session", ["selector"]),
+	action("app.session.delete", "Delete session", "Session", ["selector"]),
+	action("app.session.deleteNoninvasive", "Delete selected session", "Session", ["selector"]),
+	action("app.tree.foldOrUp", "Fold tree item", "Session", ["selector"]),
+	action("app.tree.unfoldOrDown", "Unfold tree item", "Session", ["selector"]),
+	action("app.plan.toggle", "Toggle plan mode", "Mode", ["composer"]),
+	action("app.history.search", "Search history", "Navigation", ["composer"]),
+	action("app.stt.toggle", "Toggle speech-to-text", "Speech", ["composer"]),
+	action("app.irc.sidebar.toggle", "Toggle IRC sidebar", "IRC", ["composer"]),
+	action("app.transcript.browse", "Browse transcript", "Transcript", ["composer"]),
+	action("app.transcript.prevTurn", "Previous transcript turn", "Transcript", ["composer"]),
+	action("app.transcript.nextTurn", "Next transcript turn", "Transcript", ["composer"]),
+	action("app.mode.cycle", "Cycle mode", "Mode", ["composer"]),
+	action("app.tasks.toggle", "Toggle tasks pane", "Jobs", ["composer"]),
+	action("app.queue.togglePane", "Toggle queue pane", "Messages", ["composer"]),
+	action("app.message.sendNow", "Send message now", "Messages", ["composer"]),
+];
+
+export interface ActionDefinition<Context> extends ActionMetadata {
+	availability(context: Context): boolean;
+	execute(context: Context): void | Promise<void>;
+}
+
+export interface ActionRegistryOptions<Context> {
+	context: Context;
+	showError(error: string): void;
+}
+
+export class ActionRegistry<Context> {
+	readonly #actions = new Map<AppKeybinding, ActionDefinition<Context>>();
+	readonly #busy = new Set<AppKeybinding>();
+	readonly #busyGroups = new Set<string>();
+	readonly #availability = new Map<AppKeybinding, boolean>();
+	#availabilityResetQueued = false;
+
+	constructor(private readonly options: ActionRegistryOptions<Context>) {}
+
+	register(action: ActionDefinition<Context>): void {
+		if (this.#actions.has(action.id)) throw new Error(`Action already registered: ${action.id}`);
+		this.#actions.set(action.id, action);
+	}
+
+	get(id: AppKeybinding): ActionDefinition<Context> | undefined {
+		return this.#actions.get(id);
+	}
+	all(): readonly ActionDefinition<Context>[] {
+		return [...this.#actions.values()];
+	}
+
+	#reportError(id: AppKeybinding, phase: "availability" | "execution", error: unknown): void {
+		const cause = error instanceof Error ? error.message : String(error);
+		try {
+			this.options.showError(`Action ${id} ${phase} failed: ${cause}`);
+		} catch {
+			// Error reporting must not escape an action dispatch.
+		}
+	}
+
+	#evaluateAvailability(id: AppKeybinding, action: ActionDefinition<Context>): boolean {
+		const cached = this.#availability.get(id);
+		if (cached !== undefined) return cached;
+		let available: boolean;
+		try {
+			available = Boolean(action.availability(this.options.context));
+		} catch (error) {
+			this.#reportError(id, "availability", error);
+			available = false;
+		}
+		this.#availability.set(id, available);
+		if (!this.#availabilityResetQueued) {
+			this.#availabilityResetQueued = true;
+			queueMicrotask(() => {
+				this.#availability.clear();
+				this.#availabilityResetQueued = false;
+			});
+		}
+		return available;
+	}
+
+	#exclusiveGroup(action: ActionDefinition<Context>): string | undefined {
+		return action.exclusiveGroup === false ? undefined : (action.exclusiveGroup ?? "default");
+	}
+
+	isAvailable(id: AppKeybinding): boolean {
+		const action = this.#actions.get(id);
+		return action ? this.#evaluateAvailability(id, action) : false;
+	}
+
+	async execute(id: AppKeybinding): Promise<boolean> {
+		const current = this.#actions.get(id);
+		if (!current || this.#busy.has(id) || !this.#evaluateAvailability(id, current)) return false;
+		const group = this.#exclusiveGroup(current);
+		if (group && this.#busyGroups.has(group)) return false;
+		this.#busy.add(id);
+		if (group) this.#busyGroups.add(group);
+		try {
+			await current.execute(this.options.context);
+			return true;
+		} catch (error) {
+			this.#reportError(id, "execution", error);
+			return false;
+		} finally {
+			this.#busy.delete(id);
+			if (group) this.#busyGroups.delete(group);
+		}
+	}
+}

package/src/modes/bridge/bridge-mode.ts

@@ -6,9 +6,9 @@ import type { RpcCommand, RpcResponse, RpcWorkflowGateResponse } from "../rpc/rp
 import { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
 import { isRpcCommand } from "../shared/agent-wire/command-validation";
 import {
-	BridgeFrameSequencer,
-	toBridgeEventFrame,
-	toBridgeWorkflowGateFrame,
+	AgentWireFrameSequencer as BridgeFrameSequencer,
+	toAgentWireEventFrame as toBridgeEventFrame,
+	toAgentWireWorkflowGateFrame as toBridgeWorkflowGateFrame,
 } from "../shared/agent-wire/event-envelope";
 import type { BridgeCapability } from "../shared/agent-wire/handshake";
 import {
@@ -636,7 +636,9 @@ export async function runBridgeMode(
 			return { tokens: stats.tokens.total, costUsd: stats.cost };
 		},
 	});
-	session.setWorkflowGateEmitter(unattendedControlPlane);
+	// Upstream v0.11 split WorkflowGateEmitter into broker/unattended-session variants with
+	// structurally incompatible optional-method signatures; the runtime surface is identical.
+	session.setWorkflowGateEmitter(unattendedControlPlane as never);
 	unattendedControlPlane
 		.recover()
 		.catch(err =>

package/src/modes/components/agent-dashboard.ts

@@ -40,6 +40,7 @@ import {
 	resolveConfiguredModelPatterns,
 	resolveModelOverride,
 } from "../../config/model-resolver";
+import { type ModelSelectorValue, selectorHead } from "../../config/model-selector-value";
 import { Settings } from "../../config/settings";
 import agentCreationArchitectPrompt from "../../prompts/system/agent-creation-architect.md" with { type: "text" };
 import agentCreationUserPrompt from "../../prompts/system/agent-creation-user.md" with { type: "text" };
@@ -84,6 +85,35 @@ interface AgentDashboardModelContext {
 	defaultModelPattern?: string;
 }
 
+export function resolveAgentCreationModel(
+	modelPatterns: string[],
+	modelRegistry: ModelRegistry,
+	settings: Settings | undefined,
+) {
+	const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	if (model) return model;
+	if (modelPatterns.length > 0) {
+		throw new Error(`Configured model selector(s) did not resolve: ${modelPatterns.join(", ")}.`);
+	}
+
+	const fallbackModel = modelRegistry.getAvailable()[0];
+	if (!fallbackModel) {
+		throw new Error("No available model to generate agent specification.");
+	}
+	return fallbackModel;
+}
+
+export function updateAgentModelOverride(
+	overrides: Record<string, ModelSelectorValue>,
+	agentName: string,
+	rawValue: string,
+): Record<string, ModelSelectorValue> {
+	const value = rawValue.trim();
+	if (value) return { ...overrides, [agentName]: value };
+	const { [agentName]: _, ...remainingOverrides } = overrides;
+	return remainingOverrides;
+}
+
 const SOURCE_ORDER: Record<AgentSource, number> = {
 	project: 0,
 	user: 1,
@@ -370,7 +400,7 @@ export class AgentDashboard extends Container {
 				.map(agent => ({
 					...agent,
 					disabled: disabled.has(agent.name),
-					overrideModel: overrides[agent.name]?.trim() || undefined,
+					overrideModel: selectorHead(overrides[agent.name])?.trim() || undefined,
 				}));
 
 			this.#tabs = this.#buildTabs(this.#allAgents);
@@ -465,16 +495,10 @@ export class AgentDashboard extends Container {
 		this.#settingsManager.set("task.disabledAgents", disabled);
 	}
 
-	#persistModelOverrides(): void {
+	#persistModelOverride(agentName: string, rawValue: string): void {
 		if (!this.#settingsManager) return;
-		const overrides: Record<string, string> = {};
-		for (const agent of this.#allAgents) {
-			const value = agent.overrideModel?.trim();
-			if (value) {
-				overrides[agent.name] = value;
-			}
-		}
-		this.#settingsManager.set("task.agentModelOverrides", overrides);
+		const overrides = this.#settingsManager.get("task.agentModelOverrides");
+		this.#settingsManager.set("task.agentModelOverrides", updateAgentModelOverride(overrides, agentName, rawValue));
 	}
 
 	#toggleSelectedAgent(): void {
@@ -506,7 +530,7 @@ export class AgentDashboard extends Container {
 		if (!selected) return;
 		const value = rawValue.trim();
 		selected.overrideModel = value || undefined;
-		this.#persistModelOverrides();
+		this.#persistModelOverride(selected.name, value);
 		this.#editingAgentName = null;
 		this.#editInput = null;
 		this.#applyFilters();
@@ -587,12 +611,7 @@ export class AgentDashboard extends Container {
 				settings?.getModelRole("default"),
 			settings,
 		);
-		const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
-		const fallbackModel = modelRegistry.getAvailable()[0];
-		const selectedModel = model ?? fallbackModel;
-		if (!selectedModel) {
-			throw new Error("No available model to generate agent specification.");
-		}
+		const selectedModel = resolveAgentCreationModel(modelPatterns, modelRegistry, settings);
 
 		const systemPrompt = prompt.render(agentCreationArchitectPrompt, { TASK_TOOL_NAME: "task" });
 		const userPrompt = prompt.render(agentCreationUserPrompt, { request: description });
@@ -605,6 +624,7 @@ export class AgentDashboard extends Container {
 			model: selectedModel,
 			systemPrompt: [systemPrompt],
 			hasUI: false,
+			notificationHostModeSupported: false,
 			enableLsp: false,
 			enableMCP: false,
 			disableExtensionDiscovery: true,

package/src/modes/components/ansi-display-validator.ts

@@ -0,0 +1,54 @@
+/** Removes every terminal control sequence except bounded SGR parameters (0-255). */
+export function validateDisplayLine(line: string): string {
+	let result = "";
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index]!;
+		const code = char.charCodeAt(0);
+		if (char === "\t") {
+			result += "    ";
+			continue;
+		}
+		if (char === "\x1b") {
+			const next = line[index + 1];
+			if (next === "[") {
+				const match = /^\x1b\[([0-9]{1,3}(?:;[0-9]{1,3})*)m/.exec(line.slice(index));
+				if (match && match[0].length <= 64 && match[1]!.split(";").every(parameter => Number(parameter) <= 255)) {
+					result += match[0];
+					index += match[0].length - 1;
+					continue;
+				}
+				index = skipEscapeSequence(line, index + 2, /[@-~]/);
+				continue;
+			}
+			if (next === "]" || next === "P" || next === "_" || next === "^" || next === "X") {
+				index = skipStringControl(line, index + 2);
+				continue;
+			}
+			if (next === "_") {
+				index = skipStringControl(line, index + 2);
+				continue;
+			}
+			index += next ? 1 : 0;
+			continue;
+		}
+		if (code >= 0x80 && code <= 0x9f) continue;
+		if (code < 0x20 || code === 0x7f) continue;
+		result += char;
+	}
+	return result;
+}
+
+function skipEscapeSequence(text: string, start: number, final: RegExp): number {
+	for (let index = start; index < text.length; index++) {
+		if (final.test(text[index]!)) return index;
+	}
+	return text.length - 1;
+}
+
+function skipStringControl(text: string, start: number): number {
+	for (let index = start; index < text.length; index++) {
+		if (text[index] === "\x07") return index;
+		if (text[index] === "\x1b" && text[index + 1] === "\\") return index + 1;
+	}
+	return text.length - 1;
+}

package/src/modes/components/chrome.ts

@@ -0,0 +1,40 @@
+import { Container, type SelectItem, SelectList, Text } from "@sayknow-cli/tui";
+import { getSelectListTheme, theme } from "../../modes/theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+export interface FramedSelectOptions {
+	maxVisible?: number;
+	selectedValue?: string;
+	onSelect?: (item: SelectItem) => void;
+	onCancel?: () => void;
+	onSelectionChange?: (item: SelectItem) => void;
+}
+
+export interface FramedSelect {
+	container: Container;
+	selectList: SelectList;
+}
+
+/** Build the shared border/list selector chrome used by compact mode selectors. */
+export function FramedSelect(
+	title: string | undefined,
+	items: ReadonlyArray<SelectItem>,
+	opts: FramedSelectOptions = {},
+): FramedSelect {
+	const container = new Container();
+	container.addChild(new DynamicBorder());
+	if (title) {
+		container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
+	}
+
+	const selectList = new SelectList(items, opts.maxVisible ?? Math.min(items.length, 10), getSelectListTheme());
+	const selectedIndex =
+		opts.selectedValue === undefined ? -1 : items.findIndex(item => item.value === opts.selectedValue);
+	if (selectedIndex !== -1) selectList.setSelectedIndex(selectedIndex);
+	selectList.onSelect = item => opts.onSelect?.(item);
+	selectList.onCancel = () => opts.onCancel?.();
+	if (opts.onSelectionChange) selectList.onSelectionChange = opts.onSelectionChange;
+	container.addChild(selectList);
+	container.addChild(new DynamicBorder());
+	return { container, selectList };
+}