mini-coder 0.5.6 → 0.5.7

package/bun.lock

@@ -5,9 +5,9 @@
     "": {
       "name": "mini-coder",
       "dependencies": {
-        "@cel-tui/components": "0.7.2",
-        "@cel-tui/core": "0.7.2",
-        "@cel-tui/types": "0.7.2",
+        "@cel-tui/components": "^0.7.2",
+        "@cel-tui/core": "^0.7.2",
+        "@cel-tui/types": "^0.7.2",
         "@mariozechner/pi-ai": "^0.66.1",
       },
       "devDependencies": {
@@ -90,23 +90,23 @@
 
     "@babel/runtime": ["@babel/runtime@7.29.2", "", {}, "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g=="],
 
-    "@biomejs/biome": ["@biomejs/biome@2.4.11", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.4.11", "@biomejs/cli-darwin-x64": "2.4.11", "@biomejs/cli-linux-arm64": "2.4.11", "@biomejs/cli-linux-arm64-musl": "2.4.11", "@biomejs/cli-linux-x64": "2.4.11", "@biomejs/cli-linux-x64-musl": "2.4.11", "@biomejs/cli-win32-arm64": "2.4.11", "@biomejs/cli-win32-x64": "2.4.11" }, "bin": { "biome": "bin/biome" } }, "sha512-nWxHX8tf3Opb/qRgZpBbsTOqOodkbrkJ7S+JxJAruxOReaDPPmPuLBAGQ8vigyUgo0QBB+oQltNEAvalLcjggA=="],
+    "@biomejs/biome": ["@biomejs/biome@2.4.12", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.4.12", "@biomejs/cli-darwin-x64": "2.4.12", "@biomejs/cli-linux-arm64": "2.4.12", "@biomejs/cli-linux-arm64-musl": "2.4.12", "@biomejs/cli-linux-x64": "2.4.12", "@biomejs/cli-linux-x64-musl": "2.4.12", "@biomejs/cli-win32-arm64": "2.4.12", "@biomejs/cli-win32-x64": "2.4.12" }, "bin": { "biome": "bin/biome" } }, "sha512-Rro7adQl3NLq/zJCIL98eElXKI8eEiBtoeu5TbXF/U3qbjuSc7Jb5rjUbeHHcquDWeSf3HnGP7XI5qGrlRk/pA=="],
 
-    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.4.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wOt+ed+L2dgZanWyL6i29qlXMc088N11optzpo10peayObBaAshbTcxKUchzEMp9QSY8rh5h6VfAFE3WTS1rqg=="],
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.4.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-BnMU4Pc3ciEVteVpZ0BK33MLr7X57F5w1dwDLDn+/iy/yTrA4Q/N2yftidFtsA4vrDh0FMXDpacNV/Tl3fbmng=="],
 
-    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.4.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-gZ6zR8XmZlExfi/Pz/PffmdpWOQ8Qhy7oBztgkR8/ylSRyLwfRPSadmiVCV8WQ8PoJ2MWUy2fgID9zmtgUUJmw=="],
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.4.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-x9uJ0bI1rJsWICp3VH8w/5PnAVD3A7SqzDpbrfoUQX1QyWrK5jSU4fRLo/wSgGeplCivbxBRKmt5Xq4/nWvq8A=="],
 
-    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.4.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-avdJaEElXrKceK0va9FkJ4P5ci3N01TGkc6ni3P8l3BElqbOz42Wg2IyX3gbh0ZLEd4HVKEIrmuVu/AMuSeFFA=="],
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.4.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-tOwuCuZZtKi1jVzbk/5nXmIsziOB6yqN8c9r9QM0EJYPU6DpQWf11uBOSCfFKKM4H3d9ZoarvlgMfbcuD051Pw=="],
 
-    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.4.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-+Sbo1OAmlegtdwqFE8iOxFIWLh1B3OEgsuZfBpyyN/kWuqZ8dx9ZEes6zVnDMo+zRHF2wLynRVhoQmV7ohxl2Q=="],
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.4.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-FhfpkAAlKL6kwvcVap0Hgp4AhZmtd3YImg0kK1jd7C/aSoh4SfsB2f++yG1rU0lr8Y5MCFJrcSkmssiL9Xnnig=="],
 
-    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.4.11", "", { "os": "linux", "cpu": "x64" }, "sha512-TagWV0iomp5LnEnxWFg4nQO+e52Fow349vaX0Q/PIcX6Zhk4GGBgp3qqZ8PVkpC+cuehRctMf3+6+FgQ8jCEFQ=="],
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.4.12", "", { "os": "linux", "cpu": "x64" }, "sha512-8pFeAnLU9QdW9jCIslB/v82bI0lhBmz2ZAKc8pVMFPO0t0wAHsoEkrUQUbMkIorTRIjbqyNZHA3lEXavsPWYSw=="],
 
-    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.4.11", "", { "os": "linux", "cpu": "x64" }, "sha512-bexd2IklK7ZgPhrz6jXzpIL6dEAH9MlJU1xGTrypx+FICxrXUp4CqtwfiuoDKse+UlgAlWtzML3jrMqeEAHEhA=="],
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.4.12", "", { "os": "linux", "cpu": "x64" }, "sha512-dwTIgZrGutzhkQCuvHynCkyW6hJxUuyZqKKO0YNfaS2GUoRO+tOvxXZqZB6SkWAOdfZTzwaw8IEdUnIkHKHoew=="],
 
-    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.4.11", "", { "os": "win32", "cpu": "arm64" }, "sha512-RJhaTnY8byzxDt4bDVb7AFPHkPcjOPK3xBip4ZRTrN3TEfyhjLRm3r3mqknqydgVTB74XG8l4jMLwEACEeihVg=="],
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.4.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-B0DLnx0vA9ya/3v7XyCaP+/lCpnbWbMOfUFFve+xb5OxyYvdHaS55YsSddr228Y+JAFk58agCuZTsqNiw2a6ig=="],
 
-    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.4.11", "", { "os": "win32", "cpu": "x64" }, "sha512-A8D3JM/00C2KQgUV3oj8Ba15EHEYwebAGCy5Sf9GAjr5Y3+kJIYOiESoqRDeuRZueuMdCsbLZIUqmPhpYXJE9A=="],
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.4.12", "", { "os": "win32", "cpu": "x64" }, "sha512-yMckRzTyZ83hkk8iDFWswqSdU8tvZxspJKnYNh7JZr/zhZNOlzH13k4ecboU6MurKExCe2HUkH75pGI/O2JwGA=="],
 
     "@cel-tui/components": ["@cel-tui/components@0.7.2", "", { "dependencies": { "@cel-tui/core": "0.7.2", "@cel-tui/types": "0.7.2", "lextide": "^0.2.1", "yoctomarkdown": "^0.1.0" }, "peerDependencies": { "typescript": ">=5.0.0" } }, "sha512-RHq7G/lS6A733l534cSStQp+cJECkxZZWrLghbPHwGBsSeDdJ2MkrQm+02roh6EH/N40ZAYjQqplq8acRrnFFQ=="],
 
@@ -368,7 +368,7 @@
 
     "path-expression-matcher": ["path-expression-matcher@1.2.1", "", {}, "sha512-d7gQQmLvAKXKXE2GeP9apIGbMYKz88zWdsn/BN2HRWVQsDFdUY36WSLTY0Jvd4HWi7Fb30gQ62oAOzdgJA6fZw=="],
 
-    "prettier": ["prettier@3.8.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-8c3mgTe0ASwWAJK+78dpviD+A8EqhndQPUBpNUIPt6+xWlIigCwfN01lWr9MAede4uqXGTEKeQWTvzb3vjia0Q=="],
+    "prettier": ["prettier@3.8.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-7igPTM53cGHMW8xWuVTydi2KO233VFiTNyF5hLJqpilHfmn8C8gPf+PS7dUT64YcXFbiMGZxS9pCSxL/Dxm/Jw=="],
 
     "protobufjs": ["protobufjs@7.5.4", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.4", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.0", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.0", "@types/node": ">=13.7.0", "long": "^5.0.0" } }, "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "A small, fast CLI coding agent",
   "module": "src/index.ts",
   "type": "module",
@@ -24,10 +24,10 @@
     "@mariozechner/pi-ai": "^0.66.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.11",
+    "@biomejs/biome": "^2.4.12",
     "@types/bun": "^1.3.12",
     "lefthook": "^2.1.5",
-    "prettier": "^3.8.2",
+    "prettier": "^3.8.3",
     "typescript": "^6.0.2"
   },
   "license": "MIT"

package/src/agent.ts

@@ -18,6 +18,7 @@ import type {
   Tool,
   ToolCall,
   ToolResultMessage,
+  UserMessage,
 } from "@mariozechner/pi-ai";
 import { streamSimple } from "@mariozechner/pi-ai";
 import { appendMessage } from "./session.ts";
@@ -79,6 +80,7 @@ export type AgentEvent =
       args: Record<string, unknown>;
       content: AssistantMessage["content"];
     }
+  | { type: "user_message"; message: UserMessage }
   | { type: "assistant_message"; message: AssistantMessage }
   | {
       type: "tool_start";
@@ -131,6 +133,8 @@ interface RunAgentOpts {
   signal?: AbortSignal;
   /** Callback for UI events. */
   onEvent?: (event: AgentEvent) => void;
+  /** Dequeue the next queued steering message, if one is waiting. */
+  takeQueuedUserMessage?: () => UserMessage | null;
 }
 
 /** Result of the agent loop. */
@@ -462,6 +466,19 @@ async function streamAssistantMessage(
   return mergeAssistantMessage(partialAssistantMessage, finalAssistantMessage);
 }
 
+function appendUserMessage(
+  db: Database,
+  sessionId: string,
+  messages: Message[],
+  userMessage: UserMessage,
+  onEvent: RunAgentOpts["onEvent"],
+): number {
+  messages.push(userMessage);
+  const turn = appendMessage(db, sessionId, userMessage);
+  onEvent?.({ type: "user_message", message: userMessage });
+  return turn;
+}
+
 function appendAssistantMessage(
   db: Database,
   sessionId: string,
@@ -490,15 +507,22 @@ function resolveLoopStopReason(
     return { messages, stopReason: assistantMessage.stopReason };
   }
 
-  if (
-    assistantMessage.stopReason === "stop" ||
-    assistantMessage.stopReason === "length"
-  ) {
-    onEvent?.({ type: "done", message: assistantMessage });
-    return { messages, stopReason: assistantMessage.stopReason };
+  return null;
+}
+
+function consumeQueuedUserMessage(
+  db: Database,
+  sessionId: string,
+  messages: Message[],
+  takeQueuedUserMessage: RunAgentOpts["takeQueuedUserMessage"],
+  onEvent: RunAgentOpts["onEvent"],
+): number | null {
+  const queuedUserMessage = takeQueuedUserMessage?.();
+  if (!queuedUserMessage) {
+    return null;
   }
 
-  return null;
+  return appendUserMessage(db, sessionId, messages, queuedUserMessage, onEvent);
 }
 
 function getAssistantToolCalls(message: AssistantMessage): ToolCall[] {
@@ -581,6 +605,72 @@ function appendToolResultMessage(
   onEvent?.({ type: "tool_result", message: toolResultMessage });
 }
 
+function finalizeStoppedAssistantMessage(
+  db: Database,
+  sessionId: string,
+  messages: Message[],
+  assistantMessage: AssistantMessage,
+  stopReason: "stop" | "length",
+  takeQueuedUserMessage: RunAgentOpts["takeQueuedUserMessage"],
+  onEvent: RunAgentOpts["onEvent"],
+): AgentLoopResult | number {
+  const queuedTurn = consumeQueuedUserMessage(
+    db,
+    sessionId,
+    messages,
+    takeQueuedUserMessage,
+    onEvent,
+  );
+  if (queuedTurn !== null) {
+    return queuedTurn;
+  }
+
+  onEvent?.({ type: "done", message: assistantMessage });
+  return { messages, stopReason };
+}
+
+async function executeAssistantToolCalls(
+  assistantMessage: AssistantMessage,
+  opts: Pick<
+    RunAgentOpts,
+    | "db"
+    | "sessionId"
+    | "messages"
+    | "toolHandlers"
+    | "cwd"
+    | "signal"
+    | "onEvent"
+    | "model"
+  >,
+  turn: number,
+): Promise<AgentLoopResult | null> {
+  for (const toolCall of getAssistantToolCalls(assistantMessage)) {
+    const result = await executeToolCall(toolCall, opts);
+    appendToolResultMessage(
+      opts.db,
+      opts.sessionId,
+      opts.messages,
+      toolCall,
+      result,
+      turn,
+      opts.onEvent,
+    );
+
+    if (opts.signal?.aborted) {
+      opts.onEvent?.({
+        type: "aborted",
+        message: buildIncompleteAssistantMessage(
+          { model: opts.model, signal: opts.signal },
+          assistantMessage,
+        ),
+      });
+      return { messages: opts.messages, stopReason: "aborted" };
+    }
+  }
+
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Agent loop
 // ---------------------------------------------------------------------------
@@ -609,7 +699,9 @@ export async function runAgentLoop(
     onEvent,
     toolHandlers,
     cwd,
+    takeQueuedUserMessage,
   } = opts;
+  let currentTurn = turn;
 
   while (true) {
     const assistantMessage = await streamAssistantMessage(opts);
@@ -618,7 +710,7 @@ export async function runAgentLoop(
       sessionId,
       messages,
       assistantMessage,
-      turn,
+      currentTurn,
       onEvent,
     );
 
@@ -631,33 +723,53 @@ export async function runAgentLoop(
       return stopResult;
     }
 
-    for (const toolCall of getAssistantToolCalls(assistantMessage)) {
-      const result = await executeToolCall(toolCall, {
-        toolHandlers,
-        cwd,
-        signal,
-        onEvent,
-      });
-      appendToolResultMessage(
+    if (
+      assistantMessage.stopReason === "stop" ||
+      assistantMessage.stopReason === "length"
+    ) {
+      const finalResult = finalizeStoppedAssistantMessage(
         db,
         sessionId,
         messages,
-        toolCall,
-        result,
-        turn,
+        assistantMessage,
+        assistantMessage.stopReason,
+        takeQueuedUserMessage,
         onEvent,
       );
-
-      if (signal?.aborted) {
-        onEvent?.({
-          type: "aborted",
-          message: buildIncompleteAssistantMessage(
-            { model, signal },
-            assistantMessage,
-          ),
-        });
-        return { messages, stopReason: "aborted" };
+      if (typeof finalResult === "number") {
+        currentTurn = finalResult;
+        continue;
       }
+      return finalResult;
+    }
+
+    const toolStopResult = await executeAssistantToolCalls(
+      assistantMessage,
+      {
+        db,
+        sessionId,
+        messages,
+        toolHandlers,
+        cwd,
+        signal,
+        onEvent,
+        model,
+      },
+      currentTurn,
+    );
+    if (toolStopResult) {
+      return toolStopResult;
+    }
+
+    const queuedTurn = consumeQueuedUserMessage(
+      db,
+      sessionId,
+      messages,
+      takeQueuedUserMessage,
+      onEvent,
+    );
+    if (queuedTurn !== null) {
+      currentTurn = queuedTurn;
     }
   }
 }

package/src/index.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import type {
   KnownProvider,
@@ -19,6 +19,7 @@ import type {
   OAuthCredentials,
   ThinkingLevel,
   Tool,
+  UserMessage,
 } from "@mariozechner/pi-ai";
 import { getEnvApiKey, getModels, getProviders } from "@mariozechner/pi-ai";
 import { getOAuthApiKey, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
@@ -561,6 +562,8 @@ export interface AppState {
   abortController: AbortController | null;
   /** Promise for the active conversational turn, used to serialize cleanup like `/undo`. */
   activeTurnPromise: Promise<void> | null;
+  /** Resolved user messages queued while the current run is still active. */
+  queuedUserMessages: UserMessage[];
   /** Whether to show thinking content. */
   showReasoning: boolean;
   /** Whether to show full (un-truncated) tool output. */
@@ -641,6 +644,7 @@ export async function init(): Promise<AppState> {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: startup.showReasoning,
     verbose: startup.verbose,
     customModels: customResult.models,
@@ -648,6 +652,22 @@ export async function init(): Promise<AppState> {
   };
 }
 
+/** Resolve the shell label shown in the system prompt. */
+function resolvePromptShell(): string {
+  return basename(process.env.SHELL || "/bin/sh");
+}
+
+/** Resolve the normalized OS label shown in the system prompt. */
+function resolvePromptOs(): "linux" | "mac" | "docker" {
+  if (process.platform === "darwin") {
+    return "mac";
+  }
+  if (existsSync("/.dockerenv") || existsSync("/run/.containerenv")) {
+    return "docker";
+  }
+  return "linux";
+}
+
 /**
  * Build the system prompt for the current state.
  *
@@ -657,7 +677,12 @@ export async function init(): Promise<AppState> {
 export function buildPrompt(state: AppState): string {
   return buildSystemPrompt({
     cwd: state.cwd,
-    date: new Date().toISOString().slice(0, 10),
+    modelLabel: state.model
+      ? `${state.model.provider}/${state.model.id}`
+      : "unknown",
+    os: resolvePromptOs(),
+    shell: resolvePromptShell(),
+    supportsImages: state.model?.input.includes("image") ?? false,
     git: state.git,
     agentsMd: state.agentsMd,
     skills: state.skills,

package/src/prompt.ts

@@ -1,9 +1,9 @@
 /**
  * System prompt construction.
  *
- * Assembles the full system prompt from static base instructions and
+ * Assembles the full system prompt from the core prompt template plus
  * dynamic context: AGENTS.md files, skill catalog, plugin suffixes,
- * and a session footer with date, CWD, and git state.
+ * and the current environment block.
  *
  * @module
  */
@@ -30,8 +30,14 @@ export interface AgentsMdFile {
 interface BuildSystemPromptOpts {
   /** Current working directory. */
   cwd: string;
-  /** Current date string (YYYY-MM-DD). */
-  date: string;
+  /** Active provider/model identifier. */
+  modelLabel: string;
+  /** Normalized host OS label (`linux`, `mac`, or `docker`). */
+  os: string;
+  /** Active shell name (for example `bash` or `zsh`). */
+  shell: string;
+  /** Whether the active model supports image input. */
+  supportsImages?: boolean;
   /** Git repository state, or `null`/`undefined` if not in a repo. */
   git?: GitState | null;
   /** Discovered AGENTS.md files, ordered root-to-leaf. */
@@ -153,7 +159,7 @@ export function discoverAgentsMd(
 // ---------------------------------------------------------------------------
 
 /**
- * Format a git state snapshot into a single-line string for the session footer.
+ * Format a git state snapshot into a single-line string for the environment block.
  *
  * Fields are omitted when their values are zero. The git line format:
  * `Git: branch main | 3 staged, 1 modified, 2 untracked | +5 −2 vs origin/main`
@@ -185,67 +191,79 @@ export function formatGitLine(state: GitState): string {
 }
 
 // ---------------------------------------------------------------------------
-// Base instructions
+// Core prompt template
 // ---------------------------------------------------------------------------
 
-const BASE_INSTRUCTIONS = `You are mini-coder, a coding agent running in the user's terminal.
+function buildCorePrompt(opts: BuildSystemPromptOpts): string {
+  const lines = [
+    "You are mini-coder, the best software engineering assistant in the world.",
+    "",
+    "The current environment is:",
+    `- LLM in use: ${opts.modelLabel}`,
+    `- OS: ${opts.os}`,
+    `- Current working directory: ${opts.cwd}`,
+  ];
 
-# Role
-
-You are an autonomous, senior-level coding assistant. When the user gives a direction, proactively gather context, plan with the user, implement, and verify. Bias toward action: plan briefly when needed to clear important assumptions, then continue into implementation. First identify the task contract: required files, names, interfaces, output format, and checks for success. Treat those details as part of correctness, not as polish. Deliver working code, unless you are genuinely blocked.
-
-# Tools
-
-You have these core tools:
-
-- \`shell\` — run commands in the user's shell. Use this to explore the codebase, read tests/verifiers/examples, inspect required outputs, and run targeted checks, builds, or git commands. Prefer \`rg\` over \`grep\` for speed.
-- \`edit\` — make exact-text replacements in files. Provide the file path, the exact text to find, and the replacement text. The old text must match exactly one location in the file. To create a new file, use an empty old text and the full file content as new text. Use this to write the exact final file content the task requires.
-
-You may also have additional tools provided by plugins. Use them when they match the task.
-
-Workflow: **inspect with shell → mutate with edit → verify with shell**.
-
-# Code quality
-
-- Conform to the codebase's existing conventions: patterns, naming, formatting, language idioms.
-- Write correct, clear, minimal code. Prefer the simplest solution that satisfies the task's checks exactly. Don't over-engineer, don't add abstractions for hypothetical futures.
-- Reuse before creating. Search for existing helpers before writing new ones.
-- Tight error handling: no broad try/catch, no silent failures, no swallowed errors.
-- Keep type safety. Avoid \`any\` casts. Use proper types and guards.
-- Only add comments where the logic isn't self-evident.
-
-# Editing discipline
-
-- Read enough context before editing. Batch logical changes together rather than making many small edits.
-- Never revert changes you didn't make unless explicitly asked.
-- Never use destructive git commands (reset --hard, checkout --, clean -fd) unless the user requests it.
-- Default to ASCII. Only use non-ASCII characters when the file already uses them or there's clear justification.
-
-# Exploring the codebase
-
-- Think first: before any tool call, decide all files and information you need.
-- Early in the task, look for acceptance criteria in tests, verifier scripts, eval scripts, examples, and expected-output files. Do not rely on the task text alone when machine-checkable criteria are available.
-- Before relying on a binary, interpreter, or CLI helper you have not yet confirmed, probe availability with focused checks such as \`command -v <tool>\`, \`<tool> --version\`, or \`python3 -m pip --version\`, then adapt to what is actually installed.
-- Batch reads: if you need multiple files, read them together in parallel rather than one at a time.
-- Only make sequential calls when a later call genuinely depends on an earlier result.
+  if (opts.git) {
+    lines.push(`- ${formatGitLine(opts.git)}`);
+  }
 
-# Communication
+  lines.push(
+    `- Shell: ${opts.shell}. Use \`command -v <name>\` to check what is available to you; do not assume environment support.`,
+    "- Edit: Safe exact-text replacement in a single file.",
+  );
 
-- Be concise. Friendly coding teammate tone.
-- After making changes: lead with a quick explanation of what changed and why, then suggest logical next steps if any.
-- Don't dump large file contents you've written — reference file paths.
-- When discussing multiple options, use numbered lists so the user can reply with a number without turning it into a questionnaire.
-- If asked for a review, focus on bugs, risks, regressions, and missing tests. Findings first, ordered by severity.
+  if (opts.supportsImages) {
+    lines.push("- Read Image: Read an image from disk.");
+  }
 
-# Persistence
+  lines.push(
+    "",
+    "## Core working style:",
+    "",
+    "- Be concise, direct, and useful.",
+    "- Use a casual, solution-oriented technical tone. Avoid fluff and performative apologies.",
+    "- When the user gives a clear command, do it without adding extra work they did not ask for.",
+    "- Prefer the minimal implementation that satisfies the request exactly.",
+    "- Use YAGNI. Avoid speculative abstractions, future-proofing, and unnecessary compatibility shims.",
+    "- Preserve working behavior where possible. Prefer targeted fixes over rewrites.",
+    "- Be thorough, use fresh eyes and internal analysis before taking action.",
+    "- Make informed decisions based on the available information and best practices.",
+    "- Always verify the result of your actions.",
+    "",
+    "### Using the shell tool:",
+    "",
+    "- Always execute shell commands in non-interactive mode.",
+    "- Use the appropriate commands and package managers for the specified operating system.",
+    "- Don't assume the environment supports all commands; check before using them.",
+    "- Avoid destructive commands that can discard changes or override edits.",
+    "",
+    "### Working with code:",
+    "",
+    "- Describe changes before implementing them",
+    "- Prefer boring dependable solutions over clever ones",
+    "- Avoid creating extra files, systems or documentation outside of what was asked.",
+    "- Check requirements, and plan your changes before editing code.",
+    "- Implement the necessary changes, following good practices and proper error handling.",
+    "- Always verify your changes using compilation, testing, and manual verification when possible.",
+    "- Do not leave helpers, tests, or any other form of temporary files; clean up after yourself and leave no trace.",
+    "- Ensure you match the requested output exactly. This applies to file names, directory structure, number of files, output formats, and all other details.",
+    '- "Polish" is not optional; it counts just as much as solving the task.',
+    "",
+    "### Task management",
+    "",
+    "- Use the /tmp or equivalent temp directory to make a To-do list for your task.",
+    "- This to-do list is **extremely** helpful for breaking down your task into smaller, less complex steps.",
+    "- Not using a to-do list may cause you to forget important steps, or lose focus on the user's request; that would be unacceptable.",
+    "- Keep the to-do list up-to-date above all, mark your completions as soon as you verify them.",
+    "- A to-do item is only complete if verification was successful and thorough.",
+    '- You have the option to delegate tasks to copies of yourself with `mc -p "subtask prompt"` in the shell.',
+    "- Delegate when you are orchestrating a large to-do/plan execution.",
+    "",
+  );
 
-- Carry work through to completion within the current turn. Don't stop at analysis or partial fixes.
-- Once the contract is clear, create the required artifact early, then iterate and improve it. Do not spend most of the turn exploring.
-- Run the narrowest verifier or test as soon as there is a plausible first implementation or artifact. Do not delay the first verification run until the end.
-- When verification is down to a small number of failures, stop broad exploration and focus only on the remaining failing assertions or exact contract gaps until the last detail passes.
-- If you encounter an error, diagnose and fix it rather than reporting it and stopping.
-- Before concluding, run the smallest targeted verification that checks the exact contract: required files exist, names and signatures match, outputs are in the required format, and no forbidden extra artifacts were left behind.
-- Avoid excessive looping: if you're re-reading or re-editing the same files without progress, stop and ask the user.`;
+  return lines.join("\n");
+}
 
 // ---------------------------------------------------------------------------
 // System prompt assembly
@@ -255,30 +273,27 @@ Workflow: **inspect with shell → mutate with edit → verify with shell**.
  * Build the full system prompt.
  *
  * Assembly order:
- * 1. Base instructions (static)
+ * 1. Core prompt template (including the current environment block)
  * 2. AGENTS.md content (project-specific)
  * 3. Skills catalog (XML)
  * 4. Plugin suffixes
- * 5. Session footer (date, CWD, git)
  *
  * @param opts - Prompt construction options.
  * @returns The assembled system prompt string.
  */
 export function buildSystemPrompt(opts: BuildSystemPromptOpts): string {
-  const sections: string[] = [BASE_INSTRUCTIONS];
+  const sections: string[] = [buildCorePrompt(opts)];
 
   // 2. AGENTS.md content
   if (opts.agentsMd && opts.agentsMd.length > 0) {
-    const agentsSection = [
-      "\n# Project Context\n",
-      "Project-specific instructions and guidelines:\n",
-    ];
+    const agentsSection = [];
     for (const file of opts.agentsMd) {
-      agentsSection.push(`## ${file.path}\n`);
+      agentsSection.push(`## ${file.path}`);
+      agentsSection.push("");
       agentsSection.push(file.content);
       agentsSection.push("");
     }
-    sections.push(agentsSection.join("\n"));
+    sections.push(agentsSection.join("\n").trimEnd());
   }
 
   // 3. Skills catalog
@@ -294,14 +309,5 @@ export function buildSystemPrompt(opts: BuildSystemPromptOpts): string {
     }
   }
 
-  // 5. Session footer
-  const footer: string[] = [];
-  footer.push(`Current date: ${opts.date}`);
-  footer.push(`Current working directory: ${opts.cwd}`);
-  if (opts.git) {
-    footer.push(formatGitLine(opts.git));
-  }
-  sections.push(footer.join("\n"));
-
-  return sections.join("\n");
+  return sections.join("\n\n");
 }

package/src/submit.ts

@@ -204,12 +204,63 @@ export function resolveRawInput(
   }
 }
 
+function recordRawPromptHistory(
+  rawInput: string,
+  state: Pick<AppState, "db" | "cwd">,
+  sessionId: string,
+): void {
+  appendPromptHistory(state.db, {
+    text: rawInput,
+    cwd: state.cwd,
+    sessionId,
+  });
+  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+}
+
+/**
+ * Queue resolved user content for the next model-request boundary of an active run.
+ *
+ * The raw prompt is recorded immediately in prompt history, but the model-visible
+ * `UserMessage` is only appended to session history when the agent loop consumes it.
+ *
+ * @param rawInput - Exact raw submitted prompt text.
+ * @param content - Resolved model-visible user content.
+ * @param state - Mutable application state.
+ */
+export function queueResolvedInput(
+  rawInput: string,
+  content: UserMessage["content"],
+  state: AppState,
+): void {
+  if (!state.running) {
+    throw new Error("Cannot queue input while no turn is running.");
+  }
+  if (isEmptyUserContent(content)) {
+    throw new Error("Cannot queue empty input.");
+  }
+
+  const session = ensureSession(state);
+  recordRawPromptHistory(rawInput, state, session.id);
+  state.queuedUserMessages.push({
+    role: "user",
+    content,
+    timestamp: Date.now(),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Turn submission
 // ---------------------------------------------------------------------------
 
 function handleAgentEvent(event: AgentEvent, state: AppState): void {
   switch (event.type) {
+    case "user_message":
+      state.messages.push(event.message);
+      state.contextTokens = addMessageToContextTokens(
+        state.contextTokens,
+        event.message,
+      );
+      break;
     case "assistant_message":
       state.messages.push(event.message);
       state.stats = addMessageToStats(state.stats, event.message);
@@ -270,12 +321,7 @@ export async function submitResolvedInput(
   }
 
   const session = ensureSession(state);
-  appendPromptHistory(state.db, {
-    text: rawInput,
-    cwd: state.cwd,
-    sessionId: session.id,
-  });
-  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+  recordRawPromptHistory(rawInput, state, session.id);
 
   const userMessage = {
     role: "user",
@@ -318,6 +364,7 @@ export async function submitResolvedInput(
       apiKey: state.providers.get(state.model.provider),
       effort: state.effort,
       signal: state.abortController.signal,
+      takeQueuedUserMessage: () => state.queuedUserMessages.shift() ?? null,
       onEvent: (event) => {
         handleAgentEvent(event, state);
         hooks?.onEvent?.(event, state);

package/src/tools.ts

@@ -490,9 +490,12 @@ interface ShellOpts {
   onUpdate?: ToolUpdateCallback;
 }
 
+type ShellProcess = ReturnType<typeof Bun.spawn>;
+
 const DEFAULT_MAX_LINES = 1000;
 const DEFAULT_MAX_BYTES = 50_000;
 const SHELL_UPDATE_INTERVAL_MS = 75;
+const SHELL_STREAM_DRAIN_TIMEOUT_MS = 25;
 
 /** Format combined stdout/stderr for display in tool results. */
 function formatShellOutput(stdout: string, stderr: string): string {
@@ -837,26 +840,132 @@ function normalizeShellCommand(command: string): string {
   }
 }
 
-/** Read a spawned shell stream into a string, reporting progressive updates. */
-async function consumeShellStream(
+interface ShellStreamCapture {
+  done: Promise<void>;
+  getOutput: () => string;
+  isFinished: () => boolean;
+  close: () => Promise<void>;
+}
+
+function startShellStreamCapture(
   stream: ReadableStream<Uint8Array>,
   onChunk: (chunk: string) => void,
-): Promise<string> {
+): ShellStreamCapture {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let output = "";
+  let closed = false;
+  let finished = false;
+
+  const done = (async (): Promise<void> => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+
+        const chunk = decoder.decode(value, { stream: true });
+        output += chunk;
+        onChunk(chunk);
+      }
+    } catch (error) {
+      if (!closed) {
+        throw error;
+      }
+    } finally {
+      const trailing = decoder.decode();
+      output += trailing;
+      onChunk(trailing);
+      finished = true;
+    }
+  })();
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      output += decoder.decode();
-      return output;
+  return {
+    done,
+    getOutput: () => output,
+    isFinished: () => finished,
+    close: async (): Promise<void> => {
+      if (!finished) {
+        closed = true;
+        try {
+          await reader.cancel();
+        } catch {
+          // Ignore cancellation errors while closing the pipe after exit/abort.
+        }
+      }
+      await done;
+    },
+  };
+}
+
+async function finalizeShellStreamCaptures(
+  captures: readonly ShellStreamCapture[],
+): Promise<void> {
+  const pending = captures
+    .filter((capture) => !capture.isFinished())
+    .map((capture) => capture.done);
+
+  if (pending.length > 0) {
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, SHELL_STREAM_DRAIN_TIMEOUT_MS);
+      void Promise.allSettled(pending).then(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+
+  await Promise.all(captures.map((capture) => capture.close()));
+}
+
+function buildShellSpawnOptions(cwd: string): Parameters<typeof Bun.spawn>[1] {
+  return {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    ...(process.platform === "win32" ? {} : { detached: true }),
+  };
+}
+
+function abortShellProcess(proc: ShellProcess): void {
+  if (proc.killed || proc.exitCode !== null) {
+    return;
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+      return;
+    } catch {
+      // Fall through to a direct kill when the process group is unavailable.
     }
+  }
+
+  proc.kill("SIGTERM");
+}
+
+function registerShellAbort(
+  signal: AbortSignal | undefined,
+  proc: ShellProcess,
+): (() => void) | null {
+  if (!signal) {
+    return null;
+  }
+
+  const abortListener = (): void => {
+    abortShellProcess(proc);
+  };
 
-    const chunk = decoder.decode(value, { stream: true });
-    output += chunk;
-    onChunk(chunk);
+  if (signal.aborted) {
+    abortShellProcess(proc);
+    return null;
   }
+
+  signal.addEventListener("abort", abortListener, { once: true });
+  return () => {
+    signal.removeEventListener("abort", abortListener);
+  };
 }
 
 /**
@@ -880,22 +989,13 @@ export async function executeShell(
   const maxLines = opts?.maxLines ?? DEFAULT_MAX_LINES;
   const maxBytes = opts?.maxBytes ?? DEFAULT_MAX_BYTES;
   let updateTimer: ReturnType<typeof setTimeout> | null = null;
+  let cleanupAbort: (() => void) | null = null;
+  let lastReportedOutput = "";
+  let lastReportAt = 0;
+  let stdoutCapture: ShellStreamCapture | null = null;
+  let stderrCapture: ShellStreamCapture | null = null;
 
   try {
-    const spawnOpts: Parameters<typeof Bun.spawn>[1] = {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    };
-    if (opts?.signal) spawnOpts.signal = opts.signal;
-    const command = normalizeShellCommand(args.command);
-    const proc = Bun.spawn([shell, "-c", command], spawnOpts);
-
-    let stdoutBuf = "";
-    let stderrBuf = "";
-    let lastReportedOutput = "";
-    let lastReportAt = 0;
-
     const clearPendingUpdate = (): void => {
       if (updateTimer) {
         clearTimeout(updateTimer);
@@ -903,9 +1003,14 @@ export async function executeShell(
       }
     };
 
-    const buildProgressOutput = (): string => {
+    const buildOutput = (trimEnd: boolean): string => {
+      const stdout = stdoutCapture?.getOutput() ?? "";
+      const stderr = stderrCapture?.getOutput() ?? "";
       return truncateOutput(
-        formatShellOutput(stdoutBuf, stderrBuf),
+        formatShellOutput(
+          trimEnd ? stdout.trimEnd() : stdout,
+          trimEnd ? stderr.trimEnd() : stderr,
+        ),
         maxLines,
         maxBytes,
       );
@@ -917,7 +1022,7 @@ export async function executeShell(
         return;
       }
 
-      const output = buildProgressOutput();
+      const output = buildOutput(false);
       if (!output || output === lastReportedOutput) {
         return;
       }
@@ -946,24 +1051,29 @@ export async function executeShell(
       }, SHELL_UPDATE_INTERVAL_MS - elapsed);
     };
 
-    const [stdout, stderr, exitCode] = await Promise.all([
-      consumeShellStream(proc.stdout as ReadableStream<Uint8Array>, (chunk) => {
-        stdoutBuf += chunk;
+    const command = normalizeShellCommand(args.command);
+    const proc = Bun.spawn([shell, "-c", command], buildShellSpawnOptions(cwd));
+    cleanupAbort = registerShellAbort(opts?.signal, proc);
+    stdoutCapture = startShellStreamCapture(
+      proc.stdout as ReadableStream<Uint8Array>,
+      () => {
         scheduleUpdate();
-      }),
-      consumeShellStream(proc.stderr as ReadableStream<Uint8Array>, (chunk) => {
-        stderrBuf += chunk;
+      },
+    );
+    stderrCapture = startShellStreamCapture(
+      proc.stderr as ReadableStream<Uint8Array>,
+      () => {
         scheduleUpdate();
-      }),
-      proc.exited,
-    ]);
+      },
+    );
+
+    const exitCode = await proc.exited;
+    cleanupAbort?.();
+    cleanupAbort = null;
 
+    await finalizeShellStreamCaptures([stdoutCapture, stderrCapture]);
     clearPendingUpdate();
-    const output = truncateOutput(
-      formatShellOutput(stdout.trimEnd(), stderr.trimEnd()),
-      maxLines,
-      maxBytes,
-    );
+    const output = buildOutput(true);
     if (opts?.onUpdate && output && output !== lastReportedOutput) {
       lastReportedOutput = output;
       opts.onUpdate(textResult(output, false));
@@ -973,6 +1083,14 @@ export async function executeShell(
     const body = output || "(no output)";
     return textResult(`Exit code: ${exitCode}\n${body}`, isError);
   } catch (err) {
+    cleanupAbort?.();
+    cleanupAbort = null;
+    const captures = [stdoutCapture, stderrCapture].filter(
+      (capture): capture is ShellStreamCapture => capture !== null,
+    );
+    if (captures.length > 0) {
+      await Promise.allSettled(captures.map((capture) => capture.close()));
+    }
     if (updateTimer) {
       clearTimeout(updateTimer);
       updateTimer = null;

package/src/ui/agent.ts

@@ -13,7 +13,11 @@ import type { AssistantMessage } from "@mariozechner/pi-ai";
 import type { AgentEvent } from "../agent.ts";
 import { getErrorMessage } from "../errors.ts";
 import type { AppState } from "../index.ts";
-import { resolveRawInput, submitResolvedInput } from "../submit.ts";
+import {
+  queueResolvedInput,
+  resolveRawInput,
+  submitResolvedInput,
+} from "../submit.ts";
 import type {
   PendingToolResult,
   StreamingConversationState,
@@ -103,7 +107,12 @@ export function createUiAgentController(
         break;
     }
 
-    if (!state.model || state.running) {
+    if (state.running) {
+      queueResolvedInput(rawInput, resolved.content, state);
+      return;
+    }
+
+    if (!state.model) {
       return;
     }
 
@@ -154,6 +163,11 @@ export function createUiAgentController(
         runtime.render();
         break;
 
+      case "user_message":
+        runtime.scrollConversationToBottom();
+        runtime.render();
+        break;
+
       case "assistant_message":
         streamingContent = [];
         runtime.render();

package/src/ui/commands.test.ts

@@ -91,6 +91,7 @@ function createTestState(): AppState {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: true,
     verbose: false,
     versionLabel: "dev",

package/src/ui/input.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { DEFAULT_THEME } from "../theme.ts";
 import {
   autocompleteInputPath,
+  findInputPathMatches,
   type InputController,
   renderInputArea,
 } from "./input.ts";
@@ -60,7 +61,7 @@ describe("ui/input", () => {
     expect(placeholder.props.italic).toBe(true);
   });
 
-  test("autocompleteInputPath completes the last file path token", () => {
+  test("autocompleteInputPath completes the last file path token when exactly one match is available", () => {
     const cwd = createTempDir();
     mkdirSync(join(cwd, "src"), { recursive: true });
     writeFileSync(join(cwd, "src", "ui.ts"), "", "utf-8");
@@ -70,6 +71,33 @@ describe("ui/input", () => {
     );
   });
 
+  test("autocompleteInputPath returns null when multiple matches are available", () => {
+    const cwd = createTempDir();
+    mkdirSync(join(cwd, "src"), { recursive: true });
+    writeFileSync(join(cwd, "src", "ui.ts"), "", "utf-8");
+    writeFileSync(join(cwd, "src", "utils.ts"), "", "utf-8");
+
+    expect(autocompleteInputPath("inspect src/u", cwd)).toBeNull();
+  });
+
+  test("findInputPathMatches returns sorted selectable matches for the last file path token", () => {
+    const cwd = createTempDir();
+    mkdirSync(join(cwd, "src"), { recursive: true });
+    writeFileSync(join(cwd, "src", "alpine.ts"), "", "utf-8");
+    writeFileSync(join(cwd, "src", "alpha.ts"), "", "utf-8");
+
+    expect(findInputPathMatches("inspect src/al", cwd)).toEqual([
+      {
+        label: "src/alpha.ts",
+        value: "inspect src/alpha.ts",
+      },
+      {
+        label: "src/alpine.ts",
+        value: "inspect src/alpine.ts",
+      },
+    ]);
+  });
+
   test("autocompleteInputPath returns null when no completion is available", () => {
     const cwd = createTempDir();
 

package/src/ui/input.ts

@@ -25,39 +25,18 @@ export interface InputController {
   onKeyPress: (key: string) => boolean | undefined;
 }
 
-/** Find the longest common prefix across a list of strings. */
-function getLongestCommonPrefix(values: readonly string[]): string {
-  if (values.length === 0) {
-    return "";
-  }
-
-  let prefix = values[0]!;
-  for (let i = 1; i < values.length && prefix.length > 0; i++) {
-    const value = values[i]!;
-    let j = 0;
-    while (j < prefix.length && j < value.length && prefix[j] === value[j]) {
-      j++;
-    }
-    prefix = prefix.slice(0, j);
-  }
-
-  return prefix;
+/** A selectable path-autocomplete match for the current input draft. */
+export interface InputPathMatch {
+  /** Path label shown in the overlay. */
+  label: string;
+  /** Full draft value to apply when this match is selected. */
+  value: string;
 }
 
-/**
- * Attempt to autocomplete the final path token in the current draft.
- *
- * @param value - Current input draft.
- * @param cwd - Working directory used to resolve relative paths.
- * @returns The completed input value, or `null` when no completion is available.
- */
-export function autocompleteInputPath(
-  value: string,
-  cwd: string,
-): string | null {
+function listInputPathMatches(value: string, cwd: string): InputPathMatch[] {
   const tokenMatch = /(^|\s)(\S+)$/.exec(value);
   if (!tokenMatch?.[2]) {
-    return null;
+    return [];
   }
 
   const token = tokenMatch[2];
@@ -80,35 +59,50 @@ export function autocompleteInputPath(
     }
   })();
   if (!entries) {
-    return null;
+    return [];
   }
 
   const showHidden = partial.startsWith(".");
-  const matches = entries
+  return entries
     .filter((entry) => (showHidden ? true : !entry.name.startsWith(".")))
     .filter((entry) => entry.name.startsWith(partial))
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-  if (matches.length === 0) {
-    return null;
-  }
-
-  let completedName: string | null = null;
-  if (matches.length === 1) {
-    const match = matches[0]!;
-    completedName = `${match.name}${match.isDirectory() ? "/" : ""}`;
-  } else {
-    const prefix = getLongestCommonPrefix(matches.map((entry) => entry.name));
-    if (prefix.length > partial.length) {
-      completedName = prefix;
-    }
-  }
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map((entry) => {
+      const completedPath = `${dirToken}${entry.name}${entry.isDirectory() ? "/" : ""}`;
+      return {
+        label: completedPath,
+        value: `${value.slice(0, tokenStart)}${completedPath}`,
+      };
+    });
+}
 
-  if (!completedName) {
-    return null;
-  }
+/**
+ * Find selectable path matches for the final path token in the current draft.
+ *
+ * @param value - Current input draft.
+ * @param cwd - Working directory used to resolve relative paths.
+ * @returns Matching path completions with their applied draft values.
+ */
+export function findInputPathMatches(
+  value: string,
+  cwd: string,
+): InputPathMatch[] {
+  return listInputPathMatches(value, cwd);
+}
 
-  return `${value.slice(0, tokenStart)}${dirToken}${completedName}`;
+/**
+ * Attempt to autocomplete the final path token in the current draft.
+ *
+ * @param value - Current input draft.
+ * @param cwd - Working directory used to resolve relative paths.
+ * @returns The completed input value, or `null` when direct completion is unavailable.
+ */
+export function autocompleteInputPath(
+  value: string,
+  cwd: string,
+): string | null {
+  const matches = listInputPathMatches(value, cwd);
+  return matches.length === 1 ? matches[0]!.value : null;
 }
 
 /**

package/src/ui/render-performance.test.ts

@@ -94,6 +94,7 @@ function createTestState(): AppState {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: DEFAULT_SHOW_REASONING,
     verbose: DEFAULT_VERBOSE,
     versionLabel: "dev",

package/src/ui/status.test.ts

@@ -106,6 +106,7 @@ function createTestState(): AppState {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: DEFAULT_SHOW_REASONING,
     verbose: DEFAULT_VERBOSE,
     versionLabel: "dev",

package/src/ui.ts

@@ -10,6 +10,7 @@
 
 import { spawn } from "node:child_process";
 import { platform } from "node:os";
+import { Select } from "@cel-tui/components";
 import {
   cel,
   HStack,
@@ -37,9 +38,14 @@ import {
 import type { InputController } from "./ui/input.ts";
 import {
   autocompleteInputPath,
+  findInputPathMatches,
   renderInputArea as renderInputAreaNode,
 } from "./ui/input.ts";
-import { type ActiveOverlay, renderOverlay } from "./ui/overlay.ts";
+import {
+  type ActiveOverlay,
+  OVERLAY_MAX_VISIBLE,
+  renderOverlay,
+} from "./ui/overlay.ts";
 import { renderStatusBar } from "./ui/status.ts";
 
 export type { InputController } from "./ui/input.ts";
@@ -286,6 +292,48 @@ function dismissOverlay(): void {
   cel.render();
 }
 
+function openPathAutocompleteOverlay(state: AppState): void {
+  const matches = findInputPathMatches(inputValue, state.cwd);
+  if (matches.length <= 1) {
+    return;
+  }
+
+  const select = Select({
+    items: matches.map((match) => ({
+      label: match.label,
+      value: match.value,
+      filterText: match.label,
+    })),
+    maxVisible: OVERLAY_MAX_VISIBLE,
+    placeholder: "type to filter paths...",
+    focused: true,
+    highlightColor: state.theme.accentText,
+    onSelect: (value) => {
+      inputValue = value;
+      dismissOverlay();
+    },
+    onBlur: dismissOverlay,
+  });
+
+  openOverlay({ select, title: "Path matches" });
+}
+
+function handleTabKeyPress(state: AppState): void {
+  if (inputValue.startsWith("/")) {
+    commandController.showCommandAutocomplete(state);
+    return;
+  }
+
+  const completedInput = autocompleteInputPath(inputValue, state.cwd);
+  if (completedInput) {
+    inputValue = completedInput;
+    cel.render();
+    return;
+  }
+
+  openPathAutocompleteOverlay(state);
+}
+
 /**
  * Render the active overlay when one is open.
  *
@@ -344,15 +392,7 @@ export function createInputController(state: AppState): InputController {
         return false;
       }
       if (key === "tab") {
-        if (inputValue.startsWith("/")) {
-          commandController.showCommandAutocomplete(state);
-        } else {
-          const completedInput = autocompleteInputPath(inputValue, state.cwd);
-          if (completedInput) {
-            inputValue = completedInput;
-            cel.render();
-          }
-        }
+        handleTabKeyPress(state);
         return false;
       }
     },