@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/interactive/application-controller.ts

@@ -6,32 +6,33 @@ import { isEscapeKey, type OverlayState, overlayOwnsInput } from "./overlay-life
 export const APPLICATION_DOUBLE_TAP_MS = 500;
 
 const CLOSED_ACTION_ORDER = [
-	"clio.notifications.dismiss",
-	"clio.tool.expand",
-	"clio.tool.expandAll",
-	"clio.tool.liveOutput",
-	"clio.editor.external",
-	"clio.message.followUp",
-	"clio.message.interrupt",
-	"clio.message.dequeue",
-	"clio.thinking.expand",
-	"clio.thinking.expandAll",
+	"clio-coder.notifications.dismiss",
+	"clio-coder.tool.expand",
+	"clio-coder.tool.expandAll",
+	"clio-coder.tool.liveOutput",
+	"clio-coder.editor.external",
+	"clio-coder.message.followUp",
+	"clio-coder.message.interrupt",
+	"clio-coder.message.dequeue",
+	"clio-coder.thinking.expand",
+	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
-const GLOBAL_ACTION_ORDER = [
-	"clio.status.toggle",
-	"clio.thinking.cycle",
-	"clio.session.tree",
-	"clio.dispatchBoard.toggle",
-	"clio.tasks.open",
-	"clio.decisions.open",
-	"clio.dispatch.background",
-	"clio.model.select",
+export const GLOBAL_ACTION_ORDER = [
+	"clio-coder.status.toggle",
+	"clio-coder.thinking.cycle",
+	"clio-coder.session.tree",
+	"clio-coder.dispatchBoard.toggle",
+	"clio-coder.files.toggle",
+	"clio-coder.tasks.open",
+	"clio-coder.decisions.open",
+	"clio-coder.dispatch.background",
+	"clio-coder.model.select",
 	// Backward stays ahead of forward so prefix-overlapping user bindings keep
 	// the same more-specific-first behavior as the original input listener.
-	"clio.model.cycleBackward",
-	"clio.model.cycleForward",
-	"clio.exit",
+	"clio-coder.model.cycleBackward",
+	"clio-coder.model.cycleForward",
+	"clio-coder.exit",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
 export type CtrlCAction = "cancel-stream" | "close-overlay" | "clear-editor" | "arm-shutdown" | "shutdown";

package/src/interactive/bus-notices.ts

@@ -72,7 +72,7 @@ function isSafetyBlockedPayload(value: unknown): value is SafetyBlockedPayload {
 function isMiddlewareHookFailedPayload(value: unknown): value is MiddlewareHookFailedPayload {
 	if (!value || typeof value !== "object") return false;
 	const p = value as Record<string, unknown>;
-	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded") return false;
+	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded" && p.kind !== "registration_conflict") return false;
 	if (typeof p.registrationId !== "string" || p.registrationId.length === 0) return false;
 	if (typeof p.hook !== "string" || p.hook.length === 0) return false;
 	if (p.message !== undefined && typeof p.message !== "string") return false;
@@ -125,7 +125,7 @@ function workerEscalationAxis(
 	return null;
 }
 
-export function middlewareBudgetWarningKey(payload: unknown): string | null {
+function middlewareBudgetWarningKey(payload: unknown): string | null {
 	if (!isMiddlewareHookFailedPayload(payload)) return null;
 	if (payload.kind !== "budget_exceeded") return null;
 	return `${payload.registrationId}\u0000${payload.hook}`;
@@ -137,11 +137,18 @@ export function middlewareBudgetWarningKey(payload: unknown): string | null {
  * either way; this warn notice is the operator's only interactive signal
  * that a guard or assessor is misbehaving.
  */
-export function middlewareHookFailedNotice(
+function middlewareHookFailedNotice(
 	payload: unknown,
 	options: MiddlewareHookFailedNoticeOptions = {},
 ): BusNotice | null {
 	if (!isMiddlewareHookFailedPayload(payload)) return null;
+	if (payload.kind === "registration_conflict") {
+		const detail =
+			payload.message !== undefined && payload.message.length > 0
+				? payload.message
+				: `registration '${payload.registrationId}' conflicts with an existing id`;
+		return { level: "warn", text: `[middleware] ${detail}` };
+	}
 	if (payload.kind === "hook_failed") {
 		const detail = payload.message !== undefined && payload.message.length > 0 ? `: ${payload.message}` : "";
 		return {

package/src/interactive/chat-loop-messages.ts

@@ -21,12 +21,13 @@ import {
 } from "../core/response-model-id.js";
 import type { PendingSkillRequest, PendingSkillToolPolicy, SkillDeclaredToolPolicy } from "../core/skill-activation.js";
 import { ToolNames } from "../core/tool-names.js";
-import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import { sha256 } from "../domains/prompts/hash.js";
 import { toContextOverflowError } from "../domains/providers/errors.js";
 import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
 import { ceilChars, extractReasoningTokens } from "../domains/session/context-accounting.js";
 import type { AgentMessage } from "../engine/types.js";
 import type { AskUserToolPolicy } from "../tools/registry.js";
+import { attachedToolSchemaBytes, attachedToolSchemasFromState } from "./prompt-cache-identity.js";
 
 /** Minimal structural view of the engine agent used by state-inspection helpers. */
 export interface AgentStateView {
@@ -291,18 +292,7 @@ export function pendingSkillRequestPreamble(requests: ReadonlyArray<PendingSkill
  * tool-surface change.
  */
 export function toolSignatureFromState(tools: ReadonlyArray<unknown>): string {
-	const schemas: Array<{ name: string; description: string; parameters: unknown }> = [];
-	for (const tool of tools) {
-		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
-		const record = tool as Record<string, unknown>;
-		schemas.push({
-			name: typeof record.name === "string" ? record.name : "",
-			description: typeof record.description === "string" ? record.description : "",
-			parameters: record.parameters ?? null,
-		});
-	}
-	schemas.sort((a, b) => a.name.localeCompare(b.name));
-	return sha256(canonicalJson(schemas));
+	return sha256(attachedToolSchemaBytes(attachedToolSchemasFromState(tools)));
 }
 
 /**

package/src/interactive/chat-loop.ts

@@ -215,7 +215,7 @@ export interface ChatSubmitOptions {
  * the turn runtime's own local fallback, so a `/btw` round against a local
  * server authenticates exactly the way a turn against it does.
  */
-const LOCAL_SIDE_QUESTION_API_KEY = "clio-local-target";
+const LOCAL_SIDE_QUESTION_API_KEY = "clio-coder-local-target";
 
 /** Closing notice an operator interrupt leaves in the transcript and the ledger. */
 const INTERRUPT_CANCEL_REASON = "[Clio Coder] run interrupted by operator; delivering the new message now.";
@@ -372,7 +372,7 @@ export interface CreateChatLoopDeps {
 	/**
 	 * Whitelist of target ids that the chat-loop is allowed to drive. The
 	 * orchestrator composes this from `providers.list()` so an unknown
-	 * `settings.orchestrator.target` surfaces a configuration error before
+	 * `settings.chat.target` surfaces a configuration error before
 	 * the agent is constructed.
 	 */
 	knownTargets: () => ReadonlySet<string>;
@@ -527,7 +527,7 @@ export interface CreateChatLoopDeps {
 	registerPrewarmEndpointSlot?: (runtime: AgentRuntime) => (() => void) | null;
 }
 
-export function reloadProtectedArtifactsForSession(
+function reloadProtectedArtifactsForSession(
 	protectedArtifacts: NonNullable<CreateChatLoopDeps["protectedArtifacts"]>,
 	readSessionEntries: (() => ReadonlyArray<SessionEntry>) | undefined,
 ): void {
@@ -547,7 +547,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	const sideQuestionRound = deps.runSideQuestion ?? runSideQuestion;
 	const handoffRound = deps.runHandoffRound ?? runHandoffRound;
 	const middlewareToolChoice = deps.middlewareToolChoice ?? createMiddlewareToolChoiceControl();
-	const state = createTurnState(deps.getSettings().orchestrator.thinkingLevel ?? "off");
+	const state = createTurnState(deps.getSettings().chat.thinkingLevel ?? "off");
 	const toolStartTimes = new Map<string, number>();
 
 	const preparationListeners = new Set<(phase: TurnPreparationPhase) => void>();
@@ -639,16 +639,18 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	 * collapsing them sent a client with a configured target to the wrong fix.
 	 */
 	const nullRuntimeAdmissionReason = (): string => {
-		const orchestrator = deps.getSettings().orchestrator;
+		const orchestrator = deps.getSettings().chat;
 		const target = orchestrator.target?.trim() ?? "";
 		const model = orchestrator.model?.trim() ?? "";
 		return target.length > 0 && model.length === 0 ? "model-not-configured" : "orchestrator-not-configured";
 	};
 
-	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().retry);
+	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().chat.retry);
 
 	const currentToolInvokeOptions = (): Partial<ToolInvokeOptions> => {
-		const options: Partial<ToolInvokeOptions> = {};
+		const options: Partial<ToolInvokeOptions> = {
+			toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes,
+		};
 		const sessionId = deps.session?.current()?.id ?? null;
 		if (sessionId) options.sessionId = sessionId;
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -764,6 +766,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		deps.bus?.on(BusChannels.ConfigHotReload, () => {
 			context.invalidateSessionPromptCache();
 		}) ?? null;
+	// A committed extension generation with new content can change the skill
+	// and prompt inputs the session prompt compiles from; same invalidation.
+	const unsubscribeExtensionsReload =
+		deps.bus?.on(BusChannels.ExtensionsReloaded, (payload) => {
+			if (payload.changed) context.invalidateSessionPromptCache();
+		}) ?? null;
 
 	const unsubscribeSynthesisLock =
 		deps.bus?.on(BusChannels.LoopBlocked, (payload) => {
@@ -1088,7 +1096,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// 4. Preflight overflow check, before the user turn is committed.
 			// A blocked request must not leave a dangling user entry that the
 			// next replay would treat as an unanswered turn.
-			const compactionThreshold = deps.getSettings().compaction?.threshold ?? null;
+			const compactionThreshold = deps.getSettings().context.compaction?.threshold ?? null;
 			const captureTurnSnapshot = (turnId: string): ContextSnapshot =>
 				context.captureRuntimeContextSnapshot(agentRuntime, turnId, compactionThreshold, {
 					promptSegments: compiledPrompt
@@ -1179,7 +1187,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				runtimeId: agentRuntime.runtimeId,
 				runtimeKind: agentRuntime.runtimeResolution.runtimeKind,
 				wireModelId: agentRuntime.wireModelId,
-				autonomy: deps.getSettings().autonomy,
+				autonomy: deps.getSettings().safety.autonomy,
 				compiledPromptHash: promptHash,
 				staticCompositionHash: promptHash,
 				promptSignature: promptHash,
@@ -1417,6 +1425,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		dispose(): void {
 			unsubscribeConfigReload?.();
+			unsubscribeExtensionsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();

package/src/interactive/chat-panel.ts

@@ -384,7 +384,7 @@ export interface ChatPanel extends Component {
 
 export interface ChatPanelOptions {
 	/**
-	 * Resolves the user-visible key string for the `clio.tool.expand`
+	 * Resolves the user-visible key string for the `clio-coder.tool.expand`
 	 * action, which folds and unfolds the newest tool call or worker block.
 	 * Returning a non-empty string surfaces a dim ` (<key>)` hint on the one
 	 * surface the key would act on: the latest finished collapsed tool subline,
@@ -603,30 +603,53 @@ function hasStreamingText(entry: Extract<TranscriptEntry, { role: "assistant" }>
 }
 
 /**
- * Split a reply that opens with the skill-suggestion protocol line into that
- * line and the answer beneath it.
+ * Locate the skill-suggestion protocol line inside a reply.
  *
- * The prompt asks the model to *begin its reply* with the suggestion, so the
- * usual shape is one segment holding both. Classifying that whole segment as
- * advisory left the turn with no voice glyph at all: the suggestion did not
- * claim it and the answer never got the chance. Returns null when the segment
- * is only a suggestion, which stays advisory in full.
+ * The prompt asks the model to begin its reply with the line, but a model
+ * that narrates its work first puts the line at the end of the final message
+ * about half the time (round-4 skill batches: 1/2 and 0/2 opened, 2/2 fired).
+ * The line is recognized at the start of any line, provided it is complete
+ * (a newline follows it, or the segment is finalized), so a partially
+ * streamed line stays ordinary prose until it is whole. Returns the line's
+ * byte range or null.
+ */
+function findSkillSuggestionLine(seg: TextSegment): { start: number; end: number } | null {
+	const text = seg.text;
+	let at = text.startsWith(SKILL_SUGGESTION_PREFIX) ? 0 : text.indexOf(`\n${SKILL_SUGGESTION_PREFIX}`);
+	if (at < 0) return null;
+	if (at > 0) at += 1;
+	const lineEnd = text.indexOf("\n", at);
+	if (lineEnd < 0) return seg.finalized ? { start: at, end: text.length } : null;
+	return { start: at, end: lineEnd };
+}
+
+/**
+ * Split a reply that carries the skill-suggestion protocol line into that
+ * line and the answer around it.
+ *
+ * The usual shape is one segment holding both. Classifying that whole segment
+ * as advisory left the turn with no voice glyph at all: the suggestion did not
+ * claim it and the answer never got the chance. The suggestion renders first
+ * wherever the model put it, and the answer is the rest of the segment with
+ * that line removed. Returns null when the segment is only a suggestion,
+ * which stays advisory in full.
  */
 function skillSuggestionSplit(seg: TextSegment): { suggestion: string; answer: TextSegment } | null {
-	if (!seg.text.startsWith(SKILL_SUGGESTION_PREFIX)) return null;
-	const breakIndex = seg.text.indexOf("\n");
-	if (breakIndex < 0) return null;
+	const found = findSkillSuggestionLine(seg);
+	if (!found) return null;
+	const before = seg.text.slice(0, found.start).replace(/\n+$/, "");
+	const after = seg.text.slice(found.end + 1).replace(/^\n+/, "");
 	// A model that puts a blank line between the suggestion and the answer left
 	// the remainder opening with a newline, so the first rendered row was empty
 	// and took the glyph the answer's own text row was owed.
-	const answerText = seg.text.slice(breakIndex + 1).replace(/^\n+/, "");
+	const answerText = before.length > 0 && after.length > 0 ? `${before}\n${after}` : before + after;
 	if (answerText.trim().length === 0) return null;
 	const split = seg.suggestionSplit ?? {
 		suggestion: "",
 		answer: { kind: "text", text: answerText, finalized: seg.finalized } as TextSegment,
 	};
 	seg.suggestionSplit = split;
-	split.suggestion = seg.text.slice(0, breakIndex);
+	split.suggestion = seg.text.slice(found.start, found.end).replace(/\r$/, "");
 	const answer = split.answer;
 	if (answer.text === answerText && answer.finalized === seg.finalized) return split;
 	// The answer half follows the same cache rules as any other segment: the
@@ -1113,7 +1136,7 @@ function renderEntryLines(
 		const rendered =
 			seg.kind === "text" ? renderTextSegmentLines(seg, proseWidth) : renderErrorSegmentLines(seg, proseWidth);
 		if (rendered.length === 0) continue;
-		const isSkillSuggestion = seg.kind === "text" && seg.text.startsWith(SKILL_SUGGESTION_PREFIX);
+		const isSkillSuggestion = seg.kind === "text" && findSkillSuggestionLine(seg) !== null;
 		if (!labeled && !isSkillSuggestion) {
 			lines.push(...hangProseLines(rendered, clioPrefix));
 			labeled = true;

package/src/interactive/chat-renderer.ts

@@ -460,15 +460,73 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 	return message as unknown as AgentMessage;
 }
 
-function recordToolCallsFromMessage(message: AgentMessage, seen: Set<string>): void {
+function toolCallIdsFromMessage(message: AgentMessage): string[] {
 	const content = (message as { content?: unknown }).content;
-	if (!Array.isArray(content)) return;
+	if (!Array.isArray(content)) return [];
+	const ids: string[] = [];
 	for (const block of content) {
 		if (!block || typeof block !== "object") continue;
 		const b = block as Record<string, unknown>;
 		if (b.type !== "toolCall") continue;
-		if (typeof b.id === "string" && b.id.length > 0) seen.add(b.id);
+		if (typeof b.id === "string" && b.id.length > 0) ids.push(b.id);
 	}
+	return ids;
+}
+
+function recordToolCallsFromMessage(message: AgentMessage, seen: Set<string>): void {
+	for (const id of toolCallIdsFromMessage(message)) seen.add(id);
+}
+
+/**
+ * Replay sink that hands tool results to the model in the order the assistant
+ * issued the calls.
+ *
+ * The ledger appends a tool result when its tool finishes, while the live loop
+ * appends a parallel batch's results by call index (pi executes the batch and
+ * pushes results in the assistant's order). A two-call turn whose second call
+ * finished first is therefore recorded as [b, a] and was sent as [a, b]. A
+ * resume that replayed the ledger order sent different bytes from that point
+ * on, and the provider's prefix cache missed for the rest of the session.
+ * Results are staged until the next non-result message and released in call
+ * order; an id the staged assistant turn never issued keeps its ledger order
+ * after the known ones.
+ */
+function createOrderedReplaySink(): {
+	messages: AgentMessage[];
+	push(message: AgentMessage): void;
+	stageToolResult(message: AgentMessage): void;
+	flush(): void;
+} {
+	const messages: AgentMessage[] = [];
+	let callOrder: string[] = [];
+	let staged: AgentMessage[] = [];
+	const rank = (message: AgentMessage): number => {
+		const id = (message as { toolCallId?: unknown }).toolCallId;
+		const index = typeof id === "string" ? callOrder.indexOf(id) : -1;
+		return index < 0 ? Number.MAX_SAFE_INTEGER : index;
+	};
+	const flush = (): void => {
+		if (staged.length === 0) return;
+		staged.sort((a, b) => rank(a) - rank(b));
+		messages.push(...staged);
+		staged = [];
+		callOrder = [];
+	};
+	return {
+		messages,
+		flush,
+		push(message) {
+			flush();
+			messages.push(message);
+			// Consecutive assistant messages (one legacy standalone tool_call entry
+			// per call) share one batch; anything else starts a new one.
+			if (message.role === "assistant") callOrder.push(...toolCallIdsFromMessage(message));
+			else callOrder = [];
+		},
+		stageToolResult(message) {
+			staged.push(message);
+		},
+	};
 }
 
 function toolCallMessageFromEntry(entry: MessageEntry): AgentMessage {
@@ -998,7 +1056,12 @@ function bashContextText(entry: BashExecutionEntry): string {
 	return bashExecutionToText(message);
 }
 
-function appendContextMessage(out: AgentMessage[], role: "user" | "assistant", text: string, timestamp: string): void {
+function appendContextMessage(
+	out: { push(message: AgentMessage): void },
+	role: "user" | "assistant",
+	text: string,
+	timestamp: string,
+): void {
 	const trimmed = text.trim();
 	if (trimmed.length === 0) return;
 	out.push(makeTextMessage(role, truncateReplayText(trimmed), timestamp));
@@ -1014,7 +1077,7 @@ export function buildReplayAgentMessagesFromTurns(
 	turns: ReadonlyArray<SessionEntry>,
 	options: RehydrateChatPanelOptions = {},
 ): AgentMessage[] {
-	const out: AgentMessage[] = [];
+	const out = createOrderedReplaySink();
 	const seenToolCalls = new Set<string>();
 	for (const entry of selectReplayEntries(turns, options)) {
 		switch (entry.kind) {
@@ -1035,7 +1098,7 @@ export function buildReplayAgentMessagesFromTurns(
 						recordToolCallsFromMessage(message, seenToolCalls);
 					}
 				} else if (entry.role === "tool_result") {
-					out.push(toolResultMessageFromEntry(entry));
+					out.stageToolResult(toolResultMessageFromEntry(entry));
 				} else if (entry.role === "system") {
 					appendContextMessage(out, "user", `System note: ${text}`, entry.timestamp);
 				}
@@ -1082,7 +1145,8 @@ export function buildReplayAgentMessagesFromTurns(
 				break;
 		}
 	}
-	return out;
+	out.flush();
+	return out.messages;
 }
 
 /**

package/src/interactive/clio-editor.ts

@@ -1,4 +1,12 @@
-import { Editor, stripTerminalSequences, type TUI, truncateToWidth, visibleWidth } from "../engine/tui.js";
+import {
+	Editor,
+	getKeybindings,
+	stripTerminalSequences,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+} from "../engine/tui.js";
+import { guardPastedEditorOperator } from "./editor-bash.js";
 import { fitHintEntries } from "./overlay-frame.js";
 import { type PermissionInspectionHint, permissionHintEntries } from "./permission-hint.js";
 import type { ClioTheme } from "./theme/index.js";
@@ -154,7 +162,50 @@ function findBottomRail(lines: readonly string[], width: number): number {
 	return -1;
 }
 
+function cursorEndsDirectoryPath(editor: Editor): boolean {
+	const cursor = editor.getCursor();
+	const line = editor.getLines()[cursor.line] ?? "";
+	return line.slice(0, cursor.col).endsWith("/");
+}
+
+function remapPastedBangOffsets(
+	before: string,
+	after: string,
+	offsets: ReadonlySet<number>,
+	markInsertedAsPasted: boolean,
+): Set<number> {
+	let prefix = 0;
+	while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
+	let beforeEnd = before.length;
+	let afterEnd = after.length;
+	while (beforeEnd > prefix && afterEnd > prefix && before[beforeEnd - 1] === after[afterEnd - 1]) {
+		beforeEnd -= 1;
+		afterEnd -= 1;
+	}
+
+	const next = new Set<number>();
+	const shift = afterEnd - prefix - (beforeEnd - prefix);
+	for (const offset of offsets) {
+		if (offset < prefix) next.add(offset);
+		else if (offset >= beforeEnd) next.add(offset + shift);
+	}
+	if (markInsertedAsPasted) {
+		for (let offset = prefix; offset < afterEnd; offset += 1) {
+			if (after[offset] === "!") next.add(offset);
+		}
+	}
+	return next;
+}
+
+function startsWithPastedOperator(text: string, pastedBangOffsets: ReadonlySet<number>): boolean {
+	const first = text.search(/\S/u);
+	return first >= 0 && text[first] === "!" && pastedBangOffsets.has(first);
+}
+
 export class ClioEditor extends Editor {
+	private pastedBangOffsets = new Set<number>();
+	private bracketedPasteActive = false;
+
 	constructor(
 		tui: TUI,
 		private readonly chrome: EditorChrome,
@@ -213,6 +264,15 @@ export class ClioEditor extends Editor {
 		return lines;
 	}
 
+	/**
+	 * Preserve paste provenance for every immediate-send binding, including the
+	 * alternate paths that invoke the submit controller without an Editor Enter.
+	 */
+	getTextForSubmit(): string {
+		const text = this.getExpandedText();
+		return startsWithPastedOperator(this.getText(), this.pastedBangOffsets) ? guardPastedEditorOperator(text) : text;
+	}
+
 	/**
 	 * pi-tui's bracketed-paste handling inserts pasted text (including a
 	 * trailing newline the paste carried) without submitting: a pasted
@@ -222,8 +282,46 @@ export class ClioEditor extends Editor {
 	 * through the same handler the typed-Enter path uses.
 	 */
 	override handleInput(data: string): void {
+		const openedPaste = data.includes("\x1b[200~");
 		const closedPaste = data.includes("\x1b[201~");
+		const pasteMutation = this.bracketedPasteActive || openedPaste;
+		const textBeforeInput = this.getText();
+		const keybindings = getKeybindings();
+		// Pi expands and trims the buffer immediately before onSubmit. Envelope a
+		// pasted bang draft for that synchronous handoff so the Bash parser can
+		// distinguish it from a typed operator; the submit controller unwraps it
+		// before sending the literal prompt onward.
+		if (
+			startsWithPastedOperator(textBeforeInput, this.pastedBangOffsets) &&
+			keybindings.matches(data, "tui.input.submit")
+		) {
+			const pastedText = this.getTextForSubmit();
+			this.pastedBangOffsets.clear();
+			this.bracketedPasteActive = false;
+			super.setText(pastedText);
+			super.handleInput(data);
+			return;
+		}
+		const completingDirectory =
+			this.isShowingAutocomplete() &&
+			(keybindings.matches(data, "tui.input.tab") || keybindings.matches(data, "tui.select.confirm"));
+		const textBeforeCompletion = completingDirectory ? this.getText() : "";
 		super.handleInput(data);
+		if (completingDirectory && this.getText() !== textBeforeCompletion && cursorEndsDirectoryPath(this)) {
+			// Directory rows are submenus on the same provider. Re-open immediately
+			// after acceptance so ↑/↓ continues in the child tree without requiring
+			// a second Tab. Pi's provider request remains the only completion path.
+			super.handleInput("\t");
+		}
+		const textAfterInput = this.getText();
+		this.pastedBangOffsets = remapPastedBangOffsets(
+			textBeforeInput,
+			textAfterInput,
+			this.pastedBangOffsets,
+			pasteMutation,
+		);
+		if (openedPaste) this.bracketedPasteActive = true;
+		if (closedPaste) this.bracketedPasteActive = false;
 		if (!closedPaste) return;
 		const text = this.getText();
 		if (!text.endsWith("\n")) return;
@@ -232,4 +330,10 @@ export class ClioEditor extends Editor {
 		this.setText("");
 		this.onSubmit?.(command);
 	}
+
+	override setText(text: string): void {
+		this.pastedBangOffsets.clear();
+		this.bracketedPasteActive = false;
+		super.setText(text);
+	}
 }

package/src/interactive/context-activity.ts

@@ -6,6 +6,7 @@ import {
 	type ContextActivityStatus,
 } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { wrapTextWithAnsi } from "../engine/tui.js";
 import { type ClioTheme, clioTheme, formatCompactMs, frame, GLYPH, padAnsi, spinnerFrame } from "./theme/index.js";
 
 export interface ContextActivitySnapshot {
@@ -152,17 +153,18 @@ export function formatContextActivityIslandLines(
 	const percent = `${Math.round(activityProgress(activity) * 100)}%`.padStart(4);
 	const progressLine = `${progressBar(theme, activity, barWidth)} ${theme.fg("dim", percent)}`;
 	const message = theme.fg(activity.status === "failed" ? "error" : "muted", activity.message);
-	// Every row here can outrun a narrow island: at 40 columns the trail stopped
-	// at "sta" and the message at "refreshed pr", each reading as the whole
-	// value. padAnsi's default marker is empty, so the marker is passed
-	// explicitly. The progress bar is sized to fit and never cuts.
+	// The trail is compact navigation chrome and marks its cut. The message and
+	// detail are the only explanation of this operation, so they wrap in full.
+	// The progress bar is sized to fit and never cuts.
 	const body = [
 		padAnsi(topLine, bodyWidth, GLYPH.ellipsis),
 		padAnsi(progressLine, bodyWidth),
 		phaseTrail(theme, activity, bodyWidth),
-		padAnsi(message, bodyWidth, GLYPH.ellipsis),
+		...wrapTextWithAnsi(message, bodyWidth).map((line) => padAnsi(line, bodyWidth)),
 	];
-	if (activity.detail) body.push(padAnsi(theme.fg("dim", activity.detail), bodyWidth, GLYPH.ellipsis));
+	if (activity.detail) {
+		body.push(...wrapTextWithAnsi(theme.fg("dim", activity.detail), bodyWidth).map((line) => padAnsi(line, bodyWidth)));
+	}
 	return frame(theme, "Context", body, width);
 }
 

package/src/interactive/context-meter.ts

@@ -23,7 +23,7 @@ export const CONTEXT_CATEGORY_TOKEN: Readonly<Record<ContextLedgerCategory, Clio
 	streaming: "accent",
 };
 
-export function contextCategoryGlyph(category: ContextLedgerCategory): string {
+function contextCategoryGlyph(category: ContextLedgerCategory): string {
 	const filled = visibleSingle(GLYPH.contextFull) ? GLYPH.contextFull : GLYPH.barFull;
 	const free = visibleSingle(GLYPH.contextFree) ? GLYPH.contextFree : GLYPH.barEmpty;
 	// The autocompact reserve is held-back headroom, not consumed context; it
@@ -187,7 +187,7 @@ export type WorkerContextSeverity = "healthy" | "warn" | "critical";
 export const WORKER_CONTEXT_WARN_PCT = 80;
 export const WORKER_CONTEXT_CRITICAL_PCT = 95;
 
-export function workerContextSeverity(pct: number): WorkerContextSeverity {
+function workerContextSeverity(pct: number): WorkerContextSeverity {
 	if (pct >= WORKER_CONTEXT_CRITICAL_PCT) return "critical";
 	if (pct >= WORKER_CONTEXT_WARN_PCT) return "warn";
 	return "healthy";
@@ -211,10 +211,7 @@ export interface WorkerContextView {
  * usage has been observed yet. The percentage is capped at 100: a provider
  * report past the window is a full window, not a >100% claim.
  */
-export function workerContextView(
-	usedTokens: number,
-	contextWindow: number | undefined | null,
-): WorkerContextView | null {
+function workerContextView(usedTokens: number, contextWindow: number | undefined | null): WorkerContextView | null {
 	if (contextWindow === undefined || contextWindow === null || contextWindow <= 0) return null;
 	if (!Number.isFinite(usedTokens) || usedTokens <= 0) return null;
 	const pct = Math.min(100, Math.round((usedTokens / contextWindow) * 100));

package/src/interactive/context-overlay.ts

@@ -166,7 +166,7 @@ function renderWorkingSetLines(view: WorkingSetView, config: WorkingSetConfigVie
 	];
 }
 
-export function renderContextLedgerLines(
+function renderContextLedgerLines(
 	ledger: ContextLedger,
 	contentWidth: number,
 	workingSet?: WorkingSetView | null,

package/src/interactive/cost-overlay.ts

@@ -271,7 +271,7 @@ function modelBlock(row: CostRow): string[] {
 	]);
 }
 
-export function formatCostOverlayBodyLines(
+function formatCostOverlayBodyLines(
 	totalCost: CostAggregate,
 	totalTokens: number,
 	rows: ReadonlyArray<CostRow>,