tinker-agent 1.10.1 → 1.11.0

package/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable user-facing changes to Tinker are documented here. The project follo
 
 ## [Unreleased]
 
+## [1.11.0] - 2026-08-15
+
+### Added
+
+- Allow text follow-up prompts to be queued while a turn is running. Follow-ups
+  are applied safely after a complete tool batch or handed off to a new turn
+  after a final response, while preserving canonical session history and TUI
+  continuity.
+
 ## [1.10.1] - 2026-08-15
 
 ### Added
@@ -199,7 +208,8 @@ All notable user-facing changes to Tinker are documented here. The project follo
 - First formal npm release under the `tinker-agent` package name with the `tinker`
   executable.
 
-[Unreleased]: https://github.com/ishowshao/tinker/compare/v1.10.1...HEAD
+[Unreleased]: https://github.com/ishowshao/tinker/compare/v1.11.0...HEAD
+[1.11.0]: https://github.com/ishowshao/tinker/releases/tag/v1.11.0
 [1.10.1]: https://github.com/ishowshao/tinker/releases/tag/v1.10.1
 [1.9.0]: https://github.com/ishowshao/tinker/releases/tag/v1.9.0
 [1.8.0]: https://github.com/ishowshao/tinker/releases/tag/v1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinker-agent",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "A personal coding agent with an interactive TUI and one-shot CLI.",
   "license": "Apache-2.0",
   "type": "module",

package/src/agent/loop.ts

@@ -498,6 +498,10 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       }
     }
 
+    await input.runtimeSession.applyQueuedSteering?.({
+      turn: input.turn,
+      ledger: input.ledger,
+    });
     await input.runtimeSession.append({
       type: "agent.iteration.finished",
       ...iteration,

package/src/agent/runtime-session.ts

@@ -139,6 +139,18 @@ export type AcceptedTurn = {
   readonly completion: Promise<RunAgentResult>;
 };
 
+export type PromptSchedulerSnapshot = {
+  readonly state: "idle" | "running";
+  readonly activeTurnId?: TurnIdentity["turnId"];
+  readonly pendingCount: number;
+};
+
+export type QueueFollowUpResult = {
+  readonly kind: "queued";
+  readonly pendingCount: number;
+  readonly activeTurnId?: TurnIdentity["turnId"];
+};
+
 export type SessionDisposeReason =
   | { type: "oneshot_complete" }
   | { type: "tui_exit" }
@@ -167,6 +179,9 @@ export type RuntimeSession = {
   ): Promise<void>;
   admitTurn(input: ExecuteTurnInput): Promise<AcceptedTurn>;
   executeTurn(input: ExecuteTurnInput): Promise<RunAgentResult>;
+  promptScheduler(): PromptSchedulerSnapshot;
+  subscribePromptScheduler(listener: () => void): () => void;
+  queueFollowUp(userMessage: UserMessage): QueueFollowUpResult;
   compactContext(): Promise<ContextCompactionResult>;
   retireContext(): Promise<ContextRetirementResult>;
   undoLatestFileMutationTurn(): Promise<TurnUndoResult>;
@@ -227,6 +242,10 @@ export type RuntimeSessionContext = {
     consumedThroughOrdinal: number;
     ledger: AgentTurnLedger;
   }): Promise<void>;
+  applyQueuedSteering?(input: {
+    turn: TurnIdentity;
+    ledger: AgentTurnLedger;
+  }): Promise<number>;
 };
 
 export type ContextSurfaceRefreshSummary = {
@@ -354,10 +373,18 @@ type RuntimeSessionState =
   | "disposed";
 
 type ActiveTurn = {
+  turn: TurnIdentity;
   controller: AbortController;
   completion: Promise<RunAgentResult>;
 };
 
+type QueuedPrompt = {
+  readonly userMessage: UserMessage;
+};
+
+const MAX_QUEUED_PROMPTS = 8;
+const MAX_QUEUED_PROMPT_TEXT_BYTES = 64 * 1024;
+
 type ActiveAdmission = {
   controller: AbortController;
   settled: Promise<void>;
@@ -415,6 +442,13 @@ class DefaultRuntimeSession implements RuntimeSession {
   private ledger?: SessionLedger;
   private activeAdmission?: ActiveAdmission;
   private activeTurn?: ActiveTurn;
+  private executionChainRunning = false;
+  private readonly queuedPrompts: QueuedPrompt[] = [];
+  private promptSchedulerSnapshot: PromptSchedulerSnapshot = Object.freeze({
+    state: "idle",
+    pendingCount: 0,
+  });
+  private readonly promptSchedulerListeners = new Set<() => void>();
   private activeContextRevision?: Promise<
     ContextCompactionResult | ContextRetirementResult
   >;
@@ -494,6 +528,7 @@ class DefaultRuntimeSession implements RuntimeSession {
       prepareModelDispatch: (dispatch) => this.prepareModelDispatch(dispatch),
       maintainContextAfterIteration: (maintenance) =>
         this.performActiveTurnContextMaintenance(maintenance),
+      applyQueuedSteering: (steering) => this.applyQueuedSteering(steering),
     };
   }
 
@@ -1509,11 +1544,71 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  promptScheduler(): PromptSchedulerSnapshot {
+    return this.promptSchedulerSnapshot;
+  }
+
+  subscribePromptScheduler(listener: () => void): () => void {
+    this.promptSchedulerListeners.add(listener);
+    return () => this.promptSchedulerListeners.delete(listener);
+  }
+
+  queueFollowUp(userMessage: UserMessage): QueueFollowUpResult {
+    if (!this.executionChainRunning) {
+      throw new Error("Cannot queue a follow-up while no execution chain is running.");
+    }
+    validateUserMessage(userMessage);
+    if (userMessage.attachments !== undefined) {
+      throw new Error("Active-turn follow-ups do not support image attachments.");
+    }
+    if (this.queuedPrompts.length >= MAX_QUEUED_PROMPTS) {
+      throw new Error(`At most ${MAX_QUEUED_PROMPTS} follow-ups may be queued.`);
+    }
+    const queuedBytes = this.queuedPrompts.reduce(
+      (total, entry) => total + Buffer.byteLength(entry.userMessage.content, "utf8"),
+      0,
+    );
+    const nextBytes = Buffer.byteLength(userMessage.content, "utf8");
+    if (queuedBytes + nextBytes > MAX_QUEUED_PROMPT_TEXT_BYTES) {
+      throw new Error("Queued follow-ups exceed the 64 KiB text limit.");
+    }
+    this.queuedPrompts.push({
+      userMessage: Object.freeze({ ...userMessage }),
+    });
+    this.notifyPromptScheduler();
+    return Object.freeze({
+      kind: "queued",
+      pendingCount: this.queuedPrompts.length,
+      ...(this.activeTurn === undefined
+        ? {}
+        : { activeTurnId: this.activeTurn.turn.turnId }),
+    });
+  }
+
   async executeTurn(input: ExecuteTurnInput): Promise<RunAgentResult> {
     return (await this.admitTurn(input)).completion;
   }
 
   async admitTurn(input: ExecuteTurnInput): Promise<AcceptedTurn> {
+    if (this.executionChainRunning) {
+      throw new Error(
+        `Cannot execute a turn while RuntimeSession is ${this.state}; a prompt chain is already executing.`,
+      );
+    }
+    this.executionChainRunning = true;
+    this.notifyPromptScheduler();
+    try {
+      const accepted = await this.admitSingleTurn(input);
+      const completion = this.continueExecutionChain(accepted.completion, input.signal);
+      return Object.freeze({ ...accepted, completion });
+    } catch (error) {
+      this.executionChainRunning = false;
+      this.notifyPromptScheduler();
+      throw error;
+    }
+  }
+
+  private async admitSingleTurn(input: ExecuteTurnInput): Promise<AcceptedTurn> {
     if (this.state !== "ready") {
       throw new Error(`Cannot execute a turn while RuntimeSession is ${this.state}.`);
     }
@@ -1586,7 +1681,8 @@ class DefaultRuntimeSession implements RuntimeSession {
           usage: admissionSnapshot,
         },
       });
-      this.activeTurn = { controller, completion };
+      this.activeTurn = { turn, controller, completion };
+      this.notifyPromptScheduler();
       return Object.freeze({
         turnId: turn.turnId,
         userMessage: input.userMessage,
@@ -1608,6 +1704,79 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  private async continueExecutionChain(
+    initialCompletion: Promise<RunAgentResult>,
+    signal: AbortSignal,
+  ): Promise<RunAgentResult> {
+    let completion = initialCompletion;
+    let finalResult: RunAgentResult;
+    try {
+      for (;;) {
+        finalResult = await completion;
+        if (finalResult.status !== "completed" || this.queuedPrompts.length === 0) {
+          return finalResult;
+        }
+        const next = this.queuedPrompts[0];
+        if (next === undefined) {
+          return finalResult;
+        }
+        const accepted = await this.admitSingleTurn({
+          userMessage: next.userMessage,
+          signal,
+        });
+        this.queuedPrompts.shift();
+        this.notifyPromptScheduler();
+        completion = accepted.completion;
+      }
+    } finally {
+      this.queuedPrompts.splice(0);
+      this.executionChainRunning = false;
+      this.notifyPromptScheduler();
+    }
+  }
+
+  private notifyPromptScheduler(): void {
+    this.promptSchedulerSnapshot = Object.freeze({
+      state: this.executionChainRunning ? "running" : "idle",
+      ...(this.activeTurn === undefined
+        ? {}
+        : { activeTurnId: this.activeTurn.turn.turnId }),
+      pendingCount: this.queuedPrompts.length,
+    });
+    for (const listener of this.promptSchedulerListeners) listener();
+  }
+
+  private async applyQueuedSteering(input: {
+    turn: TurnIdentity;
+    ledger: AgentTurnLedger;
+  }): Promise<number> {
+    if (this.activeTurn?.turn.turnId !== input.turn.turnId) {
+      throw new Error("Cannot apply steering outside the active turn.");
+    }
+    if (this.queuedPrompts.length === 0) return 0;
+    const drained = this.queuedPrompts.splice(0);
+    const records = input.ledger.appendSteeringUserMessages(
+      drained.map((entry) => entry.userMessage),
+    );
+    this.notifyPromptScheduler();
+    for (let index = 0; index < records.length; index += 1) {
+      const record = records[index];
+      const queued = drained[index];
+      if (record === undefined || queued === undefined) {
+        throw new Error("Steering ledger result did not match the drained queue.");
+      }
+      await this.append({
+        type: "turn.steering.applied",
+        ...input.turn,
+        data: {
+          userPrompt: projectUserMessage(queued.userMessage),
+          ordinal: record.ordinal,
+        },
+      });
+    }
+    return records.length;
+  }
+
   private settleAdmission(admission: ActiveAdmission): void {
     if (this.activeAdmission !== admission) {
       throw new Error("Runtime admission ownership was lost.");
@@ -1838,6 +2007,8 @@ class DefaultRuntimeSession implements RuntimeSession {
   canSwitchSession(): boolean {
     return (
       this.state === "ready" &&
+      !this.executionChainRunning &&
+      this.queuedPrompts.length === 0 &&
       this.activeTurn === undefined &&
       (this.tooling?.taskManager
         .listBackgroundTasks()
@@ -2025,6 +2196,7 @@ class DefaultRuntimeSession implements RuntimeSession {
     } finally {
       removeExternalAbortListener();
       this.activeTurn = undefined;
+      this.notifyPromptScheduler();
       this.pendingAutomaticContextMaintenance = false;
       if (this.state === "executing") {
         this.state = "ready";
@@ -2398,6 +2570,9 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
 
     this.state = "disposing";
+    this.queuedPrompts.splice(0);
+    this.executionChainRunning = false;
+    this.notifyPromptScheduler();
     const errors: unknown[] = this.faultCause === undefined ? [] : [this.faultCause];
     const activeAdmission = this.activeAdmission;
     if (activeAdmission !== undefined) {

package/src/agent/session-ledger.ts

@@ -100,6 +100,9 @@ export type PendingLedgerTurn = {
 };
 
 export type AgentTurnLedger = {
+  appendSteeringUserMessages(
+    messages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[];
   appendAssistant(input: {
     iteration: IterationIdentity;
     message: AssistantMessage;
@@ -129,6 +132,13 @@ export type LedgerMutation =
       admissionBase?: AdmissionBaseToken;
       next: ProtocolContextView;
     }
+  | {
+      kind: "append_steering_users";
+      turn: TurnIdentity;
+      frames: readonly ProtocolFrame[];
+      messages: readonly CanonicalMessageRecord[];
+      next: ProtocolContextView;
+    }
   | {
       kind: "append_assistant";
       iteration: IterationIdentity;
@@ -396,6 +406,74 @@ export class InMemorySessionLedger implements SessionLedger {
     this.pending = undefined;
   }
 
+  appendSteeringUserMessages(
+    pending: InMemoryPendingLedgerTurn,
+    userMessages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[] {
+    this.requirePending(pending, "append steering user messages");
+    this.assertNoOpenFrame();
+    if (userMessages.length === 0) {
+      return Object.freeze([]);
+    }
+    for (const userMessage of userMessages) {
+      validateUserMessage(userMessage);
+    }
+
+    const frames: ProtocolFrame[] = [];
+    const messages: CanonicalMessageRecord[] = [];
+    for (const userMessage of userMessages) {
+      const createdAt = this.clock();
+      const ordinal = this.view.messages.length + messages.length + 1;
+      const frameId = this.input.idFactory.createProtocolFrameId();
+      messages.push(
+        immutableRecord<CanonicalMessageRecord>({
+          messageId: this.input.idFactory.createMessageId(),
+          sessionId: this.input.sessionId,
+          frameId,
+          ordinal,
+          contentSha256: userMessageHash(userMessage),
+          createdAt,
+          role: "user",
+          turnId: pending.turn.turnId,
+          content: userMessage.content,
+          ...(userMessage.attachments === undefined
+            ? {}
+            : {
+                attachments: Object.freeze(
+                  immutableCanonicalClone(userMessage.attachments),
+                ),
+              }),
+          origin: "user",
+        }),
+      );
+      frames.push(
+        immutableRecord<ProtocolFrame>({
+          frameId,
+          sessionId: this.input.sessionId,
+          turnId: pending.turn.turnId,
+          kind: "user",
+          state: "closed",
+          firstOrdinal: ordinal,
+          lastOrdinal: ordinal,
+          createdAt,
+          closedAt: createdAt,
+        }),
+      );
+    }
+    const immutableFrames = Object.freeze(frames);
+    const immutableMessages = Object.freeze(messages);
+    const next = appendView(this.view, immutableFrames, immutableMessages, []);
+    this.validator.validate(next, { fullIntegrity: true });
+    this.commit({
+      kind: "append_steering_users",
+      turn: pending.turn,
+      frames: immutableFrames,
+      messages: immutableMessages,
+      next,
+    });
+    return immutableMessages;
+  }
+
   appendAssistant(
     pending: InMemoryPendingLedgerTurn,
     input: {
@@ -776,6 +854,8 @@ class InMemoryPendingLedgerTurn implements PendingLedgerTurn {
     readonly turn: TurnIdentity,
   ) {
     this.agent = {
+      appendSteeringUserMessages: (messages) =>
+        this.ledger.appendSteeringUserMessages(this, messages),
       appendAssistant: (input) => this.ledger.appendAssistant(this, input),
       assertCanExecuteTool: (call) => this.ledger.assertCanExecuteTool(this, call),
       commitToolCompletions: (completions) =>

package/src/events/observation-text-log.ts

@@ -35,6 +35,10 @@ export function renderObservationLogEvent(event: AgentEvent): string | undefined
       ].join("\n");
     case "turn.started":
       return renderTurnStarted(event);
+    case "turn.steering.applied":
+      return ["## User follow-up", "", event.data.userPrompt.text, "", "---", ""].join(
+        "\n",
+      );
     case "assistant.progress":
       return renderAssistantProgress(event);
     case "tool.observation":

package/src/events/stdout-event-printer.ts

@@ -37,6 +37,11 @@ export class StdoutEventPrinter implements EventSink {
           `turn.started turn=${event.turnNumber} turnId=${event.turnId}\n`,
         );
         break;
+      case "turn.steering.applied":
+        this.stdout.write(
+          `turn.steering.applied turn=${event.turnNumber} ordinal=${event.data.ordinal}\n`,
+        );
+        break;
       case "agent.iteration.started":
         this.stdout.write(
           `agent.iteration.started iteration=${event.iterationNumber} iterationId=${event.iterationId}\n`,

package/src/events/types.ts

@@ -307,6 +307,10 @@ export type AgentEventDataMap = {
   "session.interrupted_frame_recovered": InterruptedFrameRecoveredData;
   "session.finished": SessionFinishedData;
   "turn.started": { userPrompt: UserPromptProjection };
+  "turn.steering.applied": {
+    userPrompt: UserPromptProjection;
+    ordinal: number;
+  };
   "turn.finished": TurnFinishedData;
   "turn.failed": { error: string };
   "turn.cancelled": { cancellation: TurnCancellation };
@@ -411,7 +415,7 @@ export type AgentEventInput =
     >
   | SessionEventInput<"mcp.server.connected" | "mcp.server.failed">
   | SessionEventInput<"diagnostic.sink_failed">
-  | TurnEventInput<"turn.started" | "turn.finished">
+  | TurnEventInput<"turn.started" | "turn.steering.applied" | "turn.finished">
   | (
       | TurnEventInput<"turn.failed" | "turn.cancelled">
       | IterationEventInput<"turn.failed" | "turn.cancelled">

package/src/model/fake-model-client.ts

@@ -241,6 +241,9 @@ export class FakeModelClient implements ModelClient {
     if (this.mode === "pty-incremental-output") {
       return this.ptyIncrementalOutput(input, prepared, options);
     }
+    if (this.mode === "pty-steering-notice") {
+      return this.ptySteeringNotice(input, prepared, options);
+    }
     if (this.mode === "pty-resume-layout") {
       return this.ptyResumeLayout(input, prepared, options);
     }
@@ -412,6 +415,32 @@ export class FakeModelClient implements ModelClient {
     return textOutput(prepared, chunks.join(""));
   }
 
+  private async ptySteeringNotice(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): Promise<ModelRequestOutput> {
+    requireTools(input, ["Bash"]);
+    const prompt = lastUserMessage(input.messages);
+    if (prompt === "PTY_STEERING_START") {
+      await Bun.sleep(600);
+      options.signal.throwIfAborted();
+      return toolCallOutput(prepared, options, "Bash", {
+        command: "printf 'PTY_STEERING_TOOL_DONE\\n'",
+        description: "Create steering boundary",
+      });
+    }
+    if (prompt === "PTY_STEERING_FOLLOWUP") {
+      requireToolMessage(input.messages, "Bash", "PTY_STEERING_TOOL_DONE");
+      await Bun.sleep(1_500);
+      options.signal.throwIfAborted();
+      return textOutput(prepared, "PTY_STEERING_FINAL");
+    }
+    throw new Error(
+      `Unexpected pty-steering-notice prompt: ${JSON.stringify(prompt)}.`,
+    );
+  }
+
   private ptyResumeLayout(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,

package/src/session/session-store.ts

@@ -660,6 +660,9 @@ export class SessionStore implements SessionLedgerCommitter {
           case "begin_turn":
             this.commitBeginTurn(mutation, now);
             break;
+          case "append_steering_users":
+            this.commitSteeringUsers(mutation, now);
+            break;
           case "append_assistant":
             this.commitAssistant(mutation, now);
             break;
@@ -2848,6 +2851,32 @@ export class SessionStore implements SessionLedgerCommitter {
     requireSingleChange(this.database, updated.changes, "advance turn counter");
   }
 
+  private commitSteeringUsers(
+    mutation: Extract<LedgerMutation, { kind: "append_steering_users" }>,
+    now: string,
+  ): void {
+    const turn = this.requireTurnRow(mutation.turn.turnId);
+    if (turn.status !== "open") {
+      throw new Error(`Turn ${mutation.turn.turnId} is not open.`);
+    }
+    if (
+      mutation.frames.length === 0 ||
+      mutation.frames.length !== mutation.messages.length
+    ) {
+      throw new Error(
+        "Steering user mutation must contain matching frames and messages.",
+      );
+    }
+    for (let index = 0; index < mutation.frames.length; index += 1) {
+      insertFrame(this.database, requireItem(mutation.frames, index, "steering frame"));
+      insertMessage(
+        this.database,
+        requireItem(mutation.messages, index, "steering message"),
+      );
+    }
+    this.touch(now);
+  }
+
   private commitAssistant(
     mutation: Extract<LedgerMutation, { kind: "append_assistant" }>,
     now: string,

package/src/tui/app.tsx

@@ -108,6 +108,10 @@ const STATIC_HEADER = Symbol("tui-static-header");
 const LIVE_TIMELINE_MAX_ROWS = 8;
 const LIVE_TIMELINE_WITH_TASKS_MAX_ROWS = 3;
 const BACKGROUND_TASKS_MAX_ROWS = 12;
+const IDLE_PROMPT_SCHEDULER = Object.freeze({
+  state: "idle" as const,
+  pendingCount: 0,
+});
 
 export function App(props: AppProps) {
   const { exit } = useApp();
@@ -137,11 +141,23 @@ export function App(props: AppProps) {
     () => binding.bashGuard(),
     () => binding.bashGuard(),
   );
+  const promptScheduler = useSyncExternalStore(
+    (listener) => binding.subscribePromptScheduler?.(listener) ?? (() => undefined),
+    () => binding.promptScheduler?.() ?? IDLE_PROMPT_SCHEDULER,
+    () => binding.promptScheduler?.() ?? IDLE_PROMPT_SCHEDULER,
+  );
   const [isRunning, setIsRunning] = useState(false);
+  const executionRunning = isRunning || promptScheduler.state === "running";
   const [isSessionOperation, setIsSessionOperation] = useState(false);
   const [isCopying, setIsCopying] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
   const [notice, setNotice] = useState<string | undefined>(props.initialNotice);
+  const currentQueuedFollowUpNotice = `Follow-up queued for the active turn (${promptScheduler.pendingCount} pending).`;
+  const visibleNotice =
+    notice?.startsWith("Follow-up queued for the active turn (") === true &&
+    notice !== currentQueuedFollowUpNotice
+      ? undefined
+      : notice;
   const [showStatus, setShowStatus] = useState(false);
   const [showSkills, setShowSkills] = useState(false);
   const [showMcp, setShowMcp] = useState(false);
@@ -259,7 +275,7 @@ export function App(props: AppProps) {
       setIsCancelling(true);
       setNotice("Cancelling current turn...");
     },
-    { isActive: isRunning },
+    { isActive: executionRunning },
   );
 
   const closeResumePicker = () => {
@@ -449,6 +465,32 @@ export function App(props: AppProps) {
     submission: PromptSubmission,
     admissionSignal: AbortSignal,
   ): Promise<PromptSubmissionOutcome> => {
+    if (promptScheduler.state === "running") {
+      if (submission.userMessage.attachments !== undefined) {
+        setNotice("Active-turn follow-ups do not support image attachments.");
+        return false;
+      }
+      if (submission.userMessage.content.trimStart().startsWith("/")) {
+        setNotice("Slash commands cannot be queued while a turn is running.");
+        return false;
+      }
+      try {
+        const queued = binding.queueFollowUp?.(submission.userMessage);
+        if (queued === undefined) {
+          throw new Error("TUI session binding does not support follow-up queuing.");
+        }
+        void props.history?.append(submission.draft).catch((error: unknown) => {
+          setNotice(`Prompt history write failed: ${errorMessage(error)}`);
+        });
+        setNotice(
+          `Follow-up queued for the active turn (${queued.pendingCount} pending).`,
+        );
+        return true;
+      } catch (error) {
+        setNotice(`Follow-up was not queued: ${errorMessage(error)}`);
+        return false;
+      }
+    }
     if (isRunning) return false;
     setNotice(undefined);
     setIsCancelling(false);
@@ -557,6 +599,10 @@ export function App(props: AppProps) {
       restoreStaticViewport();
     }
 
+    if (promptScheduler.state === "running") {
+      return submitAgentPrompt(submission, signal);
+    }
+
     if (userMessage.attachments === undefined && trimmed.startsWith("/")) {
       try {
         const projectCommand = resolveProjectSlashCommand(
@@ -856,9 +902,16 @@ export function App(props: AppProps) {
             </Box>
             <Box marginTop={1} flexShrink={0}>
               <Footer
-                status={isCancelling ? "cancelling" : state.status}
+                status={
+                  isCancelling
+                    ? "cancelling"
+                    : executionRunning
+                      ? "running"
+                      : state.status
+                }
                 workedForMs={state.workedForMs}
                 yolo={bashGuard.mode === "yolo"}
+                pendingFollowUps={promptScheduler.pendingCount}
               />
             </Box>
             <Box marginTop={1} flexDirection="column" flexShrink={0}>
@@ -891,26 +944,38 @@ export function App(props: AppProps) {
                   gitBranch={gitBranch}
                   contextUsage={state.contextUsage}
                   isDisabled={
-                    isRunning ||
                     isSessionOperation ||
                     isCopying ||
+                    isCancelling ||
                     bashGuard.pending !== undefined
                   }
                   history={props.history}
                   commands={availableCommands}
                   fileLister={props.fileLister}
-                  importImage={binding.importImage}
+                  importImage={
+                    promptScheduler.state === "running"
+                      ? undefined
+                      : binding.importImage
+                  }
                   verifyImageAssets={binding.verifyImageAssets}
                   onCycleReasoningEffort={
-                    hasReasoningEffort ? cycleReasoningEffort : undefined
+                    hasReasoningEffort && promptScheduler.state !== "running"
+                      ? cycleReasoningEffort
+                      : undefined
                   }
                   onSubmit={onSubmit}
                   onMaintenance={onMaintenance}
-                  placeholder='Enter a coding request, or "/" for commands'
+                  placeholder={
+                    promptScheduler.state === "running"
+                      ? "Send a follow-up for the active turn…"
+                      : 'Enter a coding request, or "/" for commands'
+                  }
                 />
               )}
               {viewError === undefined ? null : <Text color="red">{viewError}</Text>}
-              {notice === undefined ? null : <Text color="yellow">{notice}</Text>}
+              {visibleNotice === undefined ? null : (
+                <Text color="yellow">{visibleNotice}</Text>
+              )}
             </Box>
           </Box>
         )}

package/src/tui/components/footer.tsx

@@ -4,6 +4,7 @@ export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
   yolo?: boolean;
+  pendingFollowUps?: number;
 };
 
 export function Footer(props: FooterProps) {
@@ -26,7 +27,11 @@ export function Footer(props: FooterProps) {
   }
 
   if (props.status === "running") {
-    return <Spinner label={`Running${suffix}`} />;
+    const queued =
+      props.pendingFollowUps === undefined || props.pendingFollowUps === 0
+        ? ""
+        : ` · ${props.pendingFollowUps} follow-up${props.pendingFollowUps === 1 ? "" : "s"} queued`;
+    return <Spinner label={`Running${queued}${suffix}`} />;
   }
 
   if (props.status === "cancelling") {

package/src/tui/event-store.ts

@@ -155,6 +155,21 @@ export function reduceTuiProjection(
         },
       };
     }
+    case "turn.steering.applied": {
+      const userPrompt = truncateUserPromptProjection(
+        event.data.userPrompt,
+        MAX_TIMELINE_PROMPT_CODE_POINTS,
+      );
+      return updateActiveTurn(state, event, policy, (turn) =>
+        appendTurnItem(turn, {
+          id: `turn-${event.turnId}-steering-${event.eventSequence}`,
+          label: "follow-up",
+          text: userPrompt.text,
+          userPrompt,
+          status: "text",
+        }),
+      );
+    }
     case "model.request.started":
       return updateActiveTurn(state, event, policy, (turn) =>
         event.data.attemptNumber === 1

package/src/tui/tui-session-controller.ts

@@ -45,6 +45,9 @@ export type TuiSessionBinding = {
   ) => Promise<void>;
   admitTurn?: (userMessage: UserMessage, signal: AbortSignal) => Promise<AcceptedTurn>;
   executeTurn(userMessage: UserMessage, signal: AbortSignal): Promise<RunAgentResult>;
+  promptScheduler?: RuntimeSession["promptScheduler"];
+  subscribePromptScheduler?: RuntimeSession["subscribePromptScheduler"];
+  queueFollowUp?: RuntimeSession["queueFollowUp"];
   bashGuard(): BashGuardSnapshot;
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
@@ -250,6 +253,10 @@ export function managedTuiBinding(input: {
         userMessage,
         signal,
       } satisfies ExecuteTurnInput),
+    promptScheduler: () => input.runtimeSession.promptScheduler(),
+    subscribePromptScheduler: (listener) =>
+      input.runtimeSession.subscribePromptScheduler(listener),
+    queueFollowUp: (userMessage) => input.runtimeSession.queueFollowUp(userMessage),
     bashGuard: () => input.runtimeSession.bashGuard(),
     subscribeBashGuard: (listener) => input.runtimeSession.subscribeBashGuard(listener),
     setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),