@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/src/modes/tasks-aggregator.ts

@@ -0,0 +1,199 @@
+import type { AsyncJob, AsyncJobManager, SubagentRecord } from "../async/job-manager";
+import type { CronJobView, JobsObserver } from "./jobs-observer";
+import type { ObservableSession, SessionObserverRegistry } from "./session-observer-registry";
+
+export type TaskStatus = "running" | "waiting" | "done" | "failed" | "cancelled";
+export type TaskKind = "bash" | "subagent" | "cron";
+
+export interface TaskRow {
+	id: string;
+	kind: TaskKind;
+	label: string;
+	status: TaskStatus;
+	startedAt: number;
+	resumable?: boolean;
+	monitorOutputLines?: number;
+}
+
+export interface TasksSnapshot {
+	rows: TaskRow[];
+	worstState: TaskStatus | "none";
+	failedUnacknowledged: boolean;
+}
+
+export const EMPTY_TASKS_SNAPSHOT: TasksSnapshot = { rows: [], worstState: "none", failedUnacknowledged: false };
+
+const ASYNC_STATUS: Record<AsyncJob["status"], TaskStatus> = {
+	running: "running",
+	paused: "waiting",
+	completed: "done",
+	failed: "failed",
+	cancelled: "cancelled",
+};
+const SESSION_STATUS: Record<ObservableSession["status"], TaskStatus> = {
+	active: "running",
+	completed: "done",
+	failed: "failed",
+	aborted: "cancelled",
+};
+const SUBAGENT_STATUS: Record<SubagentRecord["status"], TaskStatus> = {
+	running: "running",
+	queued: "waiting",
+	paused: "waiting",
+	completed: "done",
+	failed: "failed",
+	cancelled: "cancelled",
+};
+const STATUS_RANK: Record<TaskStatus, number> = { done: 1, cancelled: 2, waiting: 3, running: 4, failed: 5 };
+
+const MAX_TERMINAL_HISTORY_ROWS = 100;
+
+export function mapAsyncJobStatus(status: AsyncJob["status"]): TaskStatus {
+	return ASYNC_STATUS[status];
+}
+
+export function mapSessionStatus(status: ObservableSession["status"]): TaskStatus {
+	return SESSION_STATUS[status];
+}
+
+export function mapSubagentStatus(status: SubagentRecord["status"]): TaskStatus {
+	return SUBAGENT_STATUS[status];
+}
+
+export function mapCronStatus(cron: Pick<CronJobView, "firing">): TaskStatus {
+	return cron.firing ? "running" : "waiting";
+}
+
+/** Joins manager jobs, monitor/cron views, and live session metadata. Stable
+ * subagent records are canonical for lifecycle state; the registry contributes
+ * only the current display label and timestamp. */
+export class TasksAggregator {
+	readonly #listeners = new Set<() => void>();
+	readonly #unsubscribers: Array<() => void> = [];
+	#snapshot: TasksSnapshot = EMPTY_TASKS_SNAPSHOT;
+	#scheduled = false;
+	#disposed = false;
+
+	constructor(
+		readonly manager: AsyncJobManager,
+		readonly jobsObserver: JobsObserver,
+		readonly sessions: SessionObserverRegistry,
+		readonly ownerId?: string,
+	) {
+		this.#unsubscribers.push(manager.onChange(() => this.#changed()));
+		this.#unsubscribers.push(jobsObserver.onChange(() => this.#changed()));
+		this.#unsubscribers.push(sessions.onChange(() => this.#changed()));
+		this.#recompute();
+	}
+
+	onChange(cb: () => void): () => void {
+		this.#listeners.add(cb);
+		return () => this.#listeners.delete(cb);
+	}
+
+	getSnapshot(): TasksSnapshot {
+		return this.#snapshot;
+	}
+
+	acknowledgeFailures(): void {
+		this.jobsObserver.acknowledgeFailures();
+		this.#recompute();
+	}
+
+	#changed(): void {
+		if (this.#disposed) return;
+		this.#recompute();
+		if (this.#scheduled) return;
+		this.#scheduled = true;
+		queueMicrotask(() => {
+			this.#scheduled = false;
+			if (!this.#disposed) for (const listener of this.#listeners) listener();
+		});
+	}
+
+	#recompute(): void {
+		const rows: TaskRow[] = [];
+		const filter = this.ownerId ? { ownerId: this.ownerId } : undefined;
+		const jobs = this.manager.getAllJobs(filter);
+		const monitorIds = new Set(this.jobsObserver.getSnapshot().monitors.map(monitor => monitor.id));
+		for (const job of jobs) {
+			// A subagent task is represented by its stable control-plane record.
+			if (job.metadata?.subagent) continue;
+			if (job.type !== "bash") continue;
+			rows.push({
+				id: `bash:${job.id}`,
+				kind: "bash",
+				label: job.label,
+				status: ASYNC_STATUS[job.status],
+				startedAt: job.startTime,
+				monitorOutputLines: monitorIds.has(job.id)
+					? lineCount(this.jobsObserver.getMonitorOutput(job.id))
+					: undefined,
+			});
+		}
+
+		const records = new Map(this.manager.getSubagentRecords(filter).map(record => [record.subagentId, record]));
+		const liveIds = new Set<string>();
+		for (const session of this.sessions.getSessions()) {
+			if (session.kind !== "subagent") continue;
+			liveIds.add(session.id);
+			const record = records.get(session.id);
+			rows.push({
+				id: `subagent:${session.id}`,
+				kind: "subagent",
+				label: session.label,
+				status: record ? SUBAGENT_STATUS[record.status] : SESSION_STATUS[session.status],
+				startedAt: session.lastUpdate,
+				resumable: record?.resumable,
+			});
+		}
+		for (const record of records.values()) {
+			if (liveIds.has(record.subagentId)) continue;
+			rows.push({
+				id: `subagent:${record.subagentId}`,
+				kind: "subagent",
+				label: record.subagentId,
+				status: SUBAGENT_STATUS[record.status],
+				startedAt: record.queued?.createdAt ?? 0,
+				resumable: record.resumable,
+			});
+		}
+		for (const cron of this.jobsObserver.getSnapshot().crons) rows.push(cronRow(cron));
+		rows.sort((a, b) => b.startedAt - a.startedAt || a.id.localeCompare(b.id));
+		let terminalRows = 0;
+		const boundedRows = rows.filter(row => {
+			if (row.status !== "done" && row.status !== "failed" && row.status !== "cancelled") return true;
+			terminalRows++;
+			return terminalRows <= MAX_TERMINAL_HISTORY_ROWS;
+		});
+		const failedUnacknowledged = this.jobsObserver.getSnapshot().failedUnacknowledged;
+		const worstState = failedUnacknowledged
+			? "failed"
+			: boundedRows.reduce<TasksSnapshot["worstState"]>(
+					(worst, row) => (worst === "none" || STATUS_RANK[row.status] > STATUS_RANK[worst] ? row.status : worst),
+					"none",
+				);
+		this.#snapshot = { rows: boundedRows, worstState, failedUnacknowledged };
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+		for (const unsubscribe of this.#unsubscribers) unsubscribe();
+		this.#unsubscribers.length = 0;
+		this.#listeners.clear();
+	}
+}
+
+function cronRow(cron: CronJobView): TaskRow {
+	return {
+		id: `cron:${cron.id}`,
+		kind: "cron",
+		label: cron.humanSchedule,
+		status: cron.firing ? "running" : "waiting",
+		startedAt: cron.createdAt,
+	};
+}
+
+function lineCount(output: string): number {
+	return output.length === 0 ? 0 : output.split("\n").length;
+}

package/src/modes/transcript-item-registry.ts

@@ -0,0 +1,229 @@
+export type TranscriptItemKind = "user" | "assistant-text" | "assistant-thinking" | "tool" | "read-group" | "custom";
+
+export type TranscriptItemCapabilities = {
+	copyable: boolean;
+	foldable: boolean;
+	rawViewable: boolean;
+};
+
+export type TranscriptSourcePayload = {
+	text: string;
+	metadata: Readonly<Record<string, unknown>>;
+	source: unknown;
+};
+
+export type TranscriptItem = {
+	id: string;
+	kind: TranscriptItemKind;
+	source: unknown;
+	getPayload?: (source: unknown) => TranscriptSourcePayload;
+	capabilities?: Partial<TranscriptItemCapabilities>;
+};
+
+export type RegisterTranscriptItem = Omit<TranscriptItem, "id"> & { id?: string };
+
+export type StreamingItemOptions = Omit<RegisterTranscriptItem, "id" | "kind"> & {
+	promptGeneration: number | string;
+	messageOrdinal: number;
+	kind?: "assistant-text" | "assistant-thinking";
+};
+
+const DEFAULT_CAPABILITIES: Record<TranscriptItemKind, TranscriptItemCapabilities> = {
+	user: { copyable: true, foldable: false, rawViewable: true },
+	"assistant-text": { copyable: true, foldable: false, rawViewable: true },
+	"assistant-thinking": { copyable: true, foldable: true, rawViewable: true },
+	tool: { copyable: true, foldable: true, rawViewable: true },
+	"read-group": { copyable: true, foldable: true, rawViewable: true },
+	custom: { copyable: true, foldable: false, rawViewable: true },
+};
+
+/** Stable transcript identities shared by the inline and overlay projections. */
+export const transcriptItemId = {
+	entry: (entryId: string): string => `entry:${entryId}`,
+	assistantContent: (entryId: string, contentIndex: number): string => `entry:${entryId}:content:${contentIndex}`,
+	tool: (toolCallId: string): string => `tool:${toolCallId}`,
+	readGroup: (groupId: string): string => `read-group:${groupId}`,
+	custom: (customId: string): string => `custom:${customId}`,
+	stream: (promptGeneration: number | string, messageOrdinal: number): string =>
+		`stream:${promptGeneration}:${messageOrdinal}`,
+};
+
+function defaultPayload(source: unknown): TranscriptSourcePayload {
+	if (typeof source === "string") return { text: source, metadata: {}, source };
+	if (!source || typeof source !== "object") return { text: "", metadata: {}, source };
+
+	const record = source as Record<string, unknown>;
+	const text = typeof record.text === "string" ? record.text : extractContentText(record.content);
+	const metadata = Object.fromEntries(Object.entries(record).filter(([key]) => key !== "text" && key !== "content"));
+	return { text, metadata, source };
+}
+
+function extractContentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map(item => {
+			if (!item || typeof item !== "object") return "";
+			const record = item as Record<string, unknown>;
+			if (typeof record.text === "string") return record.text;
+			if (typeof record.thinking === "string") return record.thinking;
+			return "";
+		})
+		.join("");
+}
+
+/**
+ * A session-local index of transcript projection items. It deliberately stores only
+ * structural sources, allowing interactive mode to supply live streaming objects
+ * and persisted session records without importing either implementation here.
+ */
+export class TranscriptItemRegistry {
+	#items = new Map<string, TranscriptItem>();
+	#aliases = new Map<string, string>();
+	#sessionId: string | undefined;
+
+	get sessionId(): string | undefined {
+		return this.#sessionId;
+	}
+
+	/** Ordered snapshot for read-only transcript projections. */
+	items(): readonly TranscriptItem[] {
+		return [...this.#items.values()];
+	}
+
+	register(item: RegisterTranscriptItem): string {
+		const id = item.id ?? this.#idForKind(item.kind, item.source);
+		if (this.#items.has(id)) throw new Error(`Transcript item already registered: ${id}`);
+		this.#items.set(id, { ...item, id });
+		return id;
+	}
+
+	replace(id: string, item: Omit<TranscriptItem, "id">): boolean {
+		const canonicalId = this.#resolveId(id);
+		if (!canonicalId || !this.#items.has(canonicalId)) return false;
+		this.#items.set(canonicalId, { ...item, id: canonicalId });
+		return true;
+	}
+
+	startStream(options: StreamingItemOptions): string {
+		const id = transcriptItemId.stream(options.promptGeneration, options.messageOrdinal);
+		if (this.#items.has(id) || this.#aliases.has(id)) throw new Error(`Transcript stream already registered: ${id}`);
+		this.#items.set(id, { ...options, id, kind: options.kind ?? "assistant-text" });
+		return id;
+	}
+
+	/** Reconciles one exact live stream with its persisted canonical item. */
+	endStream(streamId: string, item: RegisterTranscriptItem): string | undefined {
+		if (!streamId.startsWith("stream:") || !this.#items.has(streamId)) return undefined;
+		const canonicalId = item.id ?? this.#idForKind(item.kind, item.source);
+		if (canonicalId !== streamId && this.#items.has(canonicalId)) return undefined;
+		if (canonicalId === streamId) {
+			this.#items.set(streamId, { ...item, id: streamId });
+			return streamId;
+		}
+		this.#items.set(canonicalId, { ...item, id: canonicalId });
+		this.#items.delete(streamId);
+		this.#aliases.set(streamId, canonicalId);
+		return canonicalId;
+	}
+
+	retireStream(id: string): boolean {
+		if (!id.startsWith("stream:") || !this.#items.delete(id)) return false;
+		this.#aliases.delete(id);
+		return true;
+	}
+
+	coalesceReadGroup(groupId: string, source: unknown, toolCallIds: readonly string[] = []): string {
+		const id = transcriptItemId.readGroup(groupId);
+		this.#items.set(id, {
+			id,
+			kind: "read-group",
+			source,
+			getPayload: value => {
+				const payload = defaultPayload(value);
+				return { ...payload, metadata: { ...payload.metadata, groupId, toolCallIds } };
+			},
+		});
+		return id;
+	}
+
+	rebuild(items: readonly RegisterTranscriptItem[]): void {
+		this.#items.clear();
+		this.#aliases.clear();
+		for (const item of items) this.register(item);
+	}
+
+	evict(id: string): boolean {
+		const canonicalId = this.#resolveId(id);
+		if (!canonicalId || !this.#items.delete(canonicalId)) return false;
+		for (const [alias, target] of this.#aliases) {
+			if (target === canonicalId) this.#aliases.delete(alias);
+		}
+		return true;
+	}
+
+	switchSession(sessionId: string): void {
+		if (this.#sessionId === sessionId) return;
+		this.#sessionId = sessionId;
+		this.#items.clear();
+		this.#aliases.clear();
+	}
+
+	resolveSourcePayload(id: string): TranscriptSourcePayload | undefined {
+		const canonicalId = this.#resolveId(id);
+		const item = canonicalId ? this.#items.get(canonicalId) : undefined;
+		if (!item) return undefined;
+		return (item.getPayload ?? defaultPayload)(item.source);
+	}
+
+	capabilities(id: string): TranscriptItemCapabilities | undefined {
+		const canonicalId = this.#resolveId(id);
+		const item = canonicalId ? this.#items.get(canonicalId) : undefined;
+		if (!item) return undefined;
+		return { ...DEFAULT_CAPABILITIES[item.kind], ...item.capabilities };
+	}
+
+	has(id: string): boolean {
+		const canonicalId = this.#resolveId(id);
+		return canonicalId !== undefined && this.#items.has(canonicalId);
+	}
+
+	canonicalId(id: string): string | undefined {
+		return this.#resolveId(id);
+	}
+
+	#resolveId(id: string): string | undefined {
+		let resolved = id;
+		const seen = new Set<string>();
+		while (this.#aliases.has(resolved) && !seen.has(resolved)) {
+			seen.add(resolved);
+			resolved = this.#aliases.get(resolved)!;
+		}
+		return this.#items.has(resolved) ? resolved : undefined;
+	}
+
+	#idForKind(kind: TranscriptItemKind, source: unknown): string {
+		const record = source && typeof source === "object" ? (source as Record<string, unknown>) : {};
+		switch (kind) {
+			case "user":
+				if (typeof record.entryId === "string") return transcriptItemId.entry(record.entryId);
+				break;
+			case "assistant-text":
+			case "assistant-thinking":
+				if (typeof record.entryId === "string" && typeof record.contentIndex === "number") {
+					return transcriptItemId.assistantContent(record.entryId, record.contentIndex);
+				}
+				break;
+			case "tool":
+				if (typeof record.toolCallId === "string") return transcriptItemId.tool(record.toolCallId);
+				break;
+			case "read-group":
+				if (typeof record.groupId === "string") return transcriptItemId.readGroup(record.groupId);
+				break;
+			case "custom":
+				if (typeof record.id === "string") return transcriptItemId.custom(record.id);
+				break;
+		}
+		throw new Error(`Transcript item ${kind} requires an explicit id or canonical source identity.`);
+	}
+}

package/src/modes/types.ts

@@ -1,7 +1,7 @@
 import type { AgentMessage } from "@sayknow-cli/agent-core";
 import type { CompactionOutcome } from "@sayknow-cli/agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, UsageReport } from "@sayknow-cli/ai";
-import type { Component, Container, EditorTheme, Loader, Spacer, Text, TUI } from "@sayknow-cli/tui";
+import type { Component, Container, EditorTheme, Loader, SlashCommand, Spacer, Text, TUI } from "@sayknow-cli/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import type { Settings } from "../config/settings";
 import type {
@@ -12,8 +12,8 @@ import type {
 } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import type { Skill } from "../extensibility/skills";
-import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { MCPManager } from "../runtime-mcp";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
@@ -21,14 +21,15 @@ import type { CredentialAutoImportOptions } from "../setup/credential-auto-impor
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
+import type { CommandPaletteAction } from "./components/command-palette";
 import type { CustomEditor } from "./components/custom-editor";
 import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import type { PetMode } from "./components/sayknow-pet-widget";
-import type { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { StatusLineComponent } from "./components/tool-status-header";
 import type { IrcObservationLedger } from "./irc-observation-ledger";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
@@ -50,6 +51,17 @@ export type SubmittedUserInput = {
 	started: boolean;
 };
 
+export type ComposerSubmissionOptions = Readonly<{
+	ownsComposer: boolean;
+	editor: CustomEditor;
+}>;
+
+export function canApplyComposerSubmission(
+	options: ComposerSubmissionOptions | undefined,
+	editor: CustomEditor,
+): boolean {
+	return options === undefined || (options.ownsComposer && editor === options.editor);
+}
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 
 export type TodoItem = {
@@ -96,6 +108,10 @@ export interface InteractiveModeContext {
 	mcpManager?: MCPManager;
 	lspServers?: LspStartupServerInfo[];
 
+	/** Shared controller query; absent in ACP/lightweight test contexts. */
+	getCurrentSessionNotificationStatus?(): NotificationSessionStatus | undefined;
+	/** Toggle only the current session; absent in ACP/lightweight test contexts. */
+	setCurrentSessionNotificationsEnabled?(enabled: boolean): Promise<NotificationSessionReconcileResult | undefined>;
 	readonly ircLedger: IrcObservationLedger;
 	// State
 	isInitialized: boolean;
@@ -104,10 +120,6 @@ export interface InteractiveModeContext {
 	isBashNoContext: boolean;
 	toolOutputExpanded: boolean;
 	todoExpanded: boolean;
-	planModeEnabled: boolean;
-	goalModeEnabled: boolean;
-	goalModePaused: boolean;
-	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	pendingImages: ImageContent[];
 	compactionQueuedMessages: CompactionQueuedMessage[];
@@ -169,24 +181,36 @@ export interface InteractiveModeContext {
 	showNewVersionNotification(newVersion: string): void;
 	clearEditor(): void;
 	updatePendingMessagesDisplay(): void;
-	queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+	queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void;
 	flushCompactionQueue(options?: { willRetry?: boolean }): Promise<void>;
 	flushPendingBashComponents(): void;
-	flushPendingModelSwitch(): Promise<void>;
 	setWorkingMessage(message?: string): void;
 	applyPendingWorkingMessage(): void;
 	ensureLoadingAnimation(): void;
-	setPetMode(mode: PetMode): void;
+	/**
+	 * Commit a pet mode through the shared result-returning policy: capability
+	 * is rechecked immediately before mutation and the preference persists only
+	 * on acceptance. Returns whether the commit was accepted.
+	 */
+	setPetMode(mode: PetMode): boolean;
 	/** Live-preview a pet skin during a selector without persisting. */
 	previewPetMode(mode: PetMode): void;
+	/**
+	 * Commit a settings-overlay pet change without re-mounting the composer.
+	 * Same shared commit policy and result semantics as `setPetMode`.
+	 */
+	commitPetPreviewMode(mode: PetMode): boolean;
 	/** Re-mount the composer (pet-aware) after an overlay/selector closes. */
 	restoreComposer(): void;
-	startPendingSubmission(input: {
-		text: string;
-		images?: ImageContent[];
-		customType?: string;
-		display?: boolean;
-	}): SubmittedUserInput;
+	startPendingSubmission(
+		input: {
+			text: string;
+			images?: ImageContent[];
+			customType?: string;
+			display?: boolean;
+		},
+		options?: ComposerSubmissionOptions,
+	): SubmittedUserInput;
 	cancelPendingSubmission(): boolean;
 	markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
 	finishPendingSubmission(input: SubmittedUserInput): void;
@@ -248,9 +272,9 @@ export interface InteractiveModeContext {
 	handleContextCommand(): void;
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
-	handleClearCommand(): Promise<void>;
+	handleClearCommand(): Promise<boolean>;
 	handleContextClearCommand(): Promise<void>;
-	handleDropCommand(): Promise<void>;
+	handleDropCommand(): Promise<boolean>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
@@ -267,10 +291,18 @@ export interface InteractiveModeContext {
 		customInstructionsOrOptions?: string | CompactOptions,
 		isAuto?: boolean,
 	): Promise<CompactionOutcome>;
+
 	openInBrowser(urlOrPath: string): void;
+	/** Resolved source of truth for slash autocomplete and command palette entries. */
+	getSlashCommands?(): readonly SlashCommand[];
 	refreshSlashCommandState(cwd?: string): Promise<void>;
 
 	// Selector handling
+	showCommandPalette(
+		commands: SlashCommand[],
+		actions: CommandPaletteAction[],
+		executeSlashCommand: (name: string) => Promise<void>,
+	): void;
 	showSettingsSelector(): void;
 	showThemeSelector(): void;
 	showPetSelector(): void;
@@ -284,6 +316,7 @@ export interface InteractiveModeContext {
 	showUserMessageSelector(): void;
 	showTreeSelector(): void;
 	showSessionSelector(): void;
+	showSessionsDashboard(): void;
 	handleResumeSession(sessionPath: string): Promise<void>;
 	handleSessionDeleteCommand(): Promise<void>;
 	showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
@@ -291,6 +324,10 @@ export interface InteractiveModeContext {
 	showDebugSelector(): void;
 	showSessionObserver(): void;
 	showJobsOverlay(): void;
+	showTasksPane(): void;
+	showTranscriptViewer(): void;
+	isTranscriptViewerOpen(): boolean;
+	refreshTranscriptViewer(): void;
 	resetObserverRegistry(): void;
 
 	// Input handling
@@ -310,9 +347,6 @@ export interface InteractiveModeContext {
 	toggleThinkingBlockVisibility(): void;
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;
-	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
-	handleGoalModeCommand(rest?: string): Promise<void>;
-	handlePlanApproval(details: PlanApprovalDetails): Promise<void>;
 
 	// Hook UI methods
 	initHooksAndCustomTools(): Promise<void>;
@@ -320,6 +354,14 @@ export interface InteractiveModeContext {
 		reason: "start" | "switch" | "branch" | "tree" | "shutdown",
 		previousSessionFile?: string,
 	): Promise<void>;
+	planModeController: Pick<
+		import("./controllers/plan-mode-controller").PlanModeController,
+		"enabled" | "paused" | "planFilePath" | "handleCommand" | "handleApproval" | "flushPendingModelSwitch"
+	>;
+	goalModeController: Pick<
+		import("./controllers/goal-mode-controller").GoalModeController,
+		"enabled" | "paused" | "handleCommand"
+	>;
 	setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
 	setHookStatus(key: string, text: string | undefined): void;
 	showHookSelector(

package/src/modes/utils/ui-helpers.ts

@@ -21,11 +21,13 @@ import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { UserMessageComponent } from "../../modes/components/user-message";
 import { theme } from "../../modes/theme/theme";
-import type {
-	CompactionQueuedMessage,
-	InteractiveModeContext,
-	IrcArrivalSnapshot,
-	TranscriptRebuildPolicy,
+import {
+	type CompactionQueuedMessage,
+	type ComposerSubmissionOptions,
+	canApplyComposerSubmission,
+	type InteractiveModeContext,
+	type IrcArrivalSnapshot,
+	type TranscriptRebuildPolicy,
 } from "../../modes/types";
 import {
 	type CustomMessage,
@@ -291,7 +293,11 @@ export class UiHelpers {
 		const semanticId = getSessionMessageViewportAnchorId(message);
 		if (semanticId) return semanticId;
 		const entryId = getSessionMessageEntryId(message);
-		if (entryId) return `user:entry:${entryId}`;
+		if (entryId) {
+			const id = `user:entry:${entryId}`;
+			associateSessionMessageViewportAnchorId(message, id);
+			return id;
+		}
 		const base = `user:local:${message.timestamp}:${stableSemanticIdPart(JSON.stringify(message.content))}`;
 		const id = this.#viewportAnchorOccurrenceId(message, base);
 		associateSessionMessageViewportAnchorId(message, id);
@@ -922,14 +928,16 @@ export class UiHelpers {
 		}
 	}
 
-	queueCompactionMessage(text: string, mode: "steer" | "followUp"): void {
+	queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void {
 		const entry: CompactionQueuedMessage = { text, mode };
 		if (mode === "followUp") {
 			entry.followUpQueuePolicy = "sequential";
 		}
 		this.ctx.compactionQueuedMessages.push(entry);
-		this.ctx.editor.addToHistory(text);
-		this.ctx.editor.setText("");
+		if (canApplyComposerSubmission(options, this.ctx.editor)) {
+			this.ctx.editor.addToHistory(text);
+			this.ctx.editor.setText("");
+		}
 		this.ctx.updatePendingMessagesDisplay();
 		this.ctx.showStatus("Queued message for after compaction");
 	}

package/src/notifications/index.ts

@@ -1417,8 +1417,14 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 					activeRuntime.disposeAckRecoveryParticipant = () => gate.setAckRecoveryParticipant?.(null);
 				}
 			};
-			activeRuntime.disposeGateEmitterListener = registerWorkflowGateEmitterListener(id, attachWorkflowGate);
-			if (ctx.workflowGate) attachWorkflowGate(ctx.workflowGate);
+			// Upstream v0.11 split WorkflowGateEmitter into broker/unattended-session variants with
+			// structurally incompatible optional-method signatures; at runtime BrokerWorkflowGateEmitter
+			// satisfies both, so the listener is registered with a widened signature.
+			activeRuntime.disposeGateEmitterListener = registerWorkflowGateEmitterListener(
+				id,
+				attachWorkflowGate as never,
+			);
+			if (ctx.workflowGate) attachWorkflowGate(ctx.workflowGate as never);
 			return "started";
 		} catch (e) {
 			logger.warn(`notifications: failed to start server: ${String(e)}`);