tinker-agent 1.9.0 → 1.11.0

package/src/tui/app.tsx

@@ -17,6 +17,7 @@ import {
 } from "../context/context-manager";
 import { ContextBudgetExceededError } from "../model/model-request-preflight";
 import { ModelRequestMediaAggregateError } from "../model/model-client";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import type { SessionId } from "../ids/runtime-id";
 import { readLastAssistantResponse } from "../session/session-last-response-reader";
 import type { PromptHistory } from "./prompt-history";
@@ -107,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();
@@ -136,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);
@@ -180,15 +197,43 @@ export function App(props: AppProps) {
     state.activeTurn === undefined &&
     props.profiles !== undefined &&
     props.profiles.profiles.size > 1;
+  const reasoningEffort = binding.reasoningEffort?.();
+  const hasReasoningEffort = reasoningEffort !== undefined;
   const activeResumePicker =
     resumePicker?.ownerSessionId === binding.sessionId ? resumePicker : undefined;
 
-  const builtInCommands = canSwitchModel
-    ? SLASH_COMMANDS
-    : SLASH_COMMANDS.filter((command) => command.name !== "model");
+  const builtInCommands = SLASH_COMMANDS.filter(
+    (command) =>
+      (command.name !== "model" || canSwitchModel) &&
+      (command.name !== "reasoning" || hasReasoningEffort),
+  );
   const availableCommands = [...builtInCommands, ...(props.projectSlashCommands ?? [])];
 
   const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
+  const cycleReasoningEffort = () => {
+    const current = binding.reasoningEffort?.();
+    if (current === undefined) {
+      return;
+    }
+    const currentIndex = current.supportedEfforts.indexOf(current.effort);
+    const nextIndex =
+      currentIndex < 0 ? 0 : (currentIndex + 1) % current.supportedEfforts.length;
+    const nextEffort = current.supportedEfforts[nextIndex];
+    if (nextEffort === undefined) {
+      return;
+    }
+    try {
+      const updated = binding.setReasoningEffort?.(nextEffort);
+      if (updated === undefined) {
+        throw new Error("Reasoning effort control is unavailable.");
+      }
+      setNotice(
+        `Reasoning effort cycled from ${JSON.stringify(current.effort)} to ${JSON.stringify(updated.effort)} (Ctrl+R).`,
+      );
+    } catch (error) {
+      setNotice(errorMessage(error));
+    }
+  };
 
   useEffect(() => {
     if (readGitBranch === undefined) {
@@ -230,7 +275,7 @@ export function App(props: AppProps) {
       setIsCancelling(true);
       setNotice("Cancelling current turn...");
     },
-    { isActive: isRunning },
+    { isActive: executionRunning },
   );
 
   const closeResumePicker = () => {
@@ -420,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);
@@ -528,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(
@@ -660,6 +735,42 @@ export function App(props: AppProps) {
           exit();
           return true;
         }
+        if (
+          command.type === "reasoning_status" ||
+          command.type === "reasoning_reset" ||
+          command.type === "reasoning_set"
+        ) {
+          const current = binding.reasoningEffort?.();
+          if (current === undefined) {
+            setNotice("Current model profile does not configure reasoning effort.");
+            return false;
+          }
+          try {
+            if (command.type === "reasoning_status") {
+              setNotice(formatReasoningEffortStatus(current));
+            } else if (command.type === "reasoning_reset") {
+              const reset = binding.resetReasoningEffort?.();
+              if (reset === undefined) {
+                throw new Error("Reasoning effort control is unavailable.");
+              }
+              setNotice(
+                `Reasoning effort reset to profile default ${JSON.stringify(reset.defaultEffort)}.`,
+              );
+            } else {
+              const updated = binding.setReasoningEffort?.(command.effort);
+              if (updated === undefined) {
+                throw new Error("Reasoning effort control is unavailable.");
+              }
+              setNotice(
+                `Reasoning effort set to ${JSON.stringify(updated.effort)} for this session runtime (profile default: ${JSON.stringify(updated.defaultEffort)}).`,
+              );
+            }
+          } catch (error) {
+            setNotice(errorMessage(error));
+            return false;
+          }
+          return true;
+        }
         if (command.type === "model" || command.type === "model_switch") {
           if (!canSwitchModel) {
             setNotice(
@@ -791,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}>
@@ -821,27 +939,43 @@ export function App(props: AppProps) {
               ) : (
                 <PromptInput
                   modelName={binding.modelName}
+                  reasoningEffort={reasoningEffort?.effort}
                   workspaceRoot={binding.workspaceRoot}
                   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 && 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>
         )}
@@ -850,6 +984,14 @@ export function App(props: AppProps) {
   );
 }
 
+function formatReasoningEffortStatus(snapshot: ReasoningEffortSnapshot): string {
+  const source =
+    snapshot.source === "profile_default"
+      ? "profile default"
+      : `session override; profile default: ${snapshot.defaultEffort}`;
+  return `Reasoning effort: ${snapshot.effort} (${source}). Available: ${snapshot.supportedEfforts.join(", ")}.`;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
@@ -947,7 +1089,7 @@ export function formatContextRetirementNotice(result: ContextRetirementResult):
   const before = result.guardedTokensBefore.toLocaleString("en-US");
   const after = result.guardedTokensAfter.toLocaleString("en-US");
   if (result.outcome === "retirement_floor") {
-    return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached. Run /compact first when retained tool output is still eligible. Older history remains available through Recall.`;
+    return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached. Run /compact first when retained tool output is still eligible. Older history remains available through RecallSearch and RecallGet.`;
   }
   const reduction =
     result.guardedTokensBefore === 0
@@ -957,7 +1099,7 @@ export function formatContextRetirementNotice(result: ContextRetirementResult):
             result.guardedTokensBefore) *
           100
         ).toFixed(1);
-  return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens (-${reduction}%). Older history remains available through Recall.`;
+  return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens (-${reduction}%). Older history remains available through RecallSearch and RecallGet.`;
 }
 
 export function formatContextRetirementFailureNotice(error: unknown): string {

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/components/prompt-input.tsx

@@ -60,6 +60,7 @@ export type PromptSubmissionOutcome =
 
 export type PromptInputProps = {
   modelName: string;
+  reasoningEffort?: string;
   workspaceRoot: string;
   gitBranch?: string;
   contextUsage?: ContextUsageSnapshot;
@@ -81,6 +82,7 @@ export type PromptInputProps = {
     assets: readonly ImageAssetRef[],
     signal: AbortSignal,
   ) => Promise<void>;
+  onCycleReasoningEffort?: () => void;
   onSubmit: (
     submission: PromptSubmission,
     signal: AbortSignal,
@@ -605,6 +607,10 @@ export function PromptInput(props: PromptInputProps) {
         }
         return;
       }
+      if (key.ctrl && input === "r") {
+        props.onCycleReasoningEffort?.();
+        return;
+      }
       const selectedFile = fileMatches[selectedIndex];
       const selectedCommand = suggestions[selectedIndex];
       if (key.return) {
@@ -736,7 +742,9 @@ export function PromptInput(props: PromptInputProps) {
       {showSuggestions ? null : (
         <Box>
           <Text dimColor>
-            {props.modelName} · {formatWorkspacePath(props.workspaceRoot)}
+            {props.modelName}
+            {props.reasoningEffort === undefined ? null : ` ${props.reasoningEffort}`} ·{" "}
+            {formatWorkspacePath(props.workspaceRoot)}
             {props.gitBranch === undefined ? null : ` · ${props.gitBranch}`}
             {state.phase.kind === "idle" ? null : ` · ${phaseLabel(state.phase)}`}
           </Text>

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/slash-commands.ts

@@ -65,6 +65,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/model [profile-name]",
     description: "Switch model profile (new session)",
   },
+  {
+    name: "reasoning",
+    usage: "/reasoning [effort|reset]",
+    description: "Show or change reasoning effort for this session runtime",
+  },
   {
     name: "resume",
     usage: "/resume [session-id]",
@@ -95,6 +100,9 @@ export type ParsedSlashCommand =
   | { type: "quit" }
   | { type: "model" }
   | { type: "model_switch"; profileName: string }
+  | { type: "reasoning_status" }
+  | { type: "reasoning_reset" }
+  | { type: "reasoning_set"; effort: string }
   | { type: "resume_list" }
   | { type: "resume"; sessionId: SessionId }
   | { type: "session_delete"; sessionId: SessionId };
@@ -193,6 +201,18 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
     }
     throw slashCommandUsageError("model");
   }
+  if (command === "/reasoning") {
+    if (tokens.length === 1) {
+      return { type: "reasoning_status" };
+    }
+    if (tokens.length === 2 && tokens[1] === "reset") {
+      return { type: "reasoning_reset" };
+    }
+    if (tokens.length === 2) {
+      return { type: "reasoning_set", effort: tokens[1] };
+    }
+    throw slashCommandUsageError("reasoning");
+  }
   if (command === "/resume") {
     if (tokens.length === 1) {
       return { type: "resume_list" };

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

@@ -18,6 +18,7 @@ import type { SessionId } from "../ids/runtime-id";
 import { createUuidV7 } from "../ids/uuid-v7";
 import type { ModelProfile } from "../cli/model-profiles";
 import type { McpInventorySnapshot } from "../mcp/mcp-manager";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import { SessionCatalog, type SessionSummary } from "../session/session-catalog";
 import type { TuiProjectionStore } from "./tui-projection-store";
 
@@ -29,6 +30,9 @@ export type TuiSessionBinding = {
   projectionStore: TuiProjectionStore;
   skills(): RuntimeSkillsSnapshot;
   mcp(): McpInventorySnapshot;
+  reasoningEffort?: () => ReasoningEffortSnapshot | undefined;
+  setReasoningEffort?: (effort: string) => ReasoningEffortSnapshot;
+  resetReasoningEffort?: () => ReasoningEffortSnapshot;
   supportsImageInput?: () => boolean;
   importImage?: (
     sourcePath: string,
@@ -41,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;
@@ -227,6 +234,9 @@ export function managedTuiBinding(input: {
     runtimeSession: input.runtimeSession,
     skills: () => input.runtimeSession.skills(),
     mcp: () => input.runtimeSession.mcp(),
+    reasoningEffort: () => input.runtimeSession.reasoningEffort(),
+    setReasoningEffort: (effort) => input.runtimeSession.setReasoningEffort(effort),
+    resetReasoningEffort: () => input.runtimeSession.resetReasoningEffort(),
     supportsImageInput: () => input.runtimeSession.supportsImageInput(),
     importImage: (sourcePath, signal, prospectiveMessageImageCount) =>
       input.runtimeSession.importImage(
@@ -243,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),