jeo-code 0.6.27 → 0.6.29

package/src/ai/providers/openai-responses.ts

@@ -13,7 +13,7 @@
 import type { Credential } from "../../auth";
 import type { CallOptions, Message } from "../types";
 import { readSse } from "../sse";
-import { providerHttpError } from "./errors";
+import { providerHttpError, fetchWithArtifactFailSafe } from "./errors";
 import { serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 
 export const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
@@ -35,28 +35,64 @@ export function extractChatgptAccountId(token: string): string | undefined {
   }
 }
 
+
+type ResponsesInputItem = Record<string, unknown>;
+
+/** True when an assistant turn can replay stateless reasoning: it has structured toolUse AND
+ *  a same-model OpenAI reasoning item (id + encrypted_content) captured this session. */
+export function responsesNativizable(m: Message, modelKey: string): boolean {
+  return !!m.toolUse?.length
+    && !!m.reasoningArtifacts?.some(a => a.provider === "openai" && a.model === modelKey && !!a.itemId && !!a.encrypted);
+}
+
+/** Build the Responses `input` array, reconstructing native reasoning + function_call +
+ *  function_call_output items for same-model OpenAI turns (stateless reasoning replay).
+ *  stripArtifacts (fail-safe) or a non-matching model ⇒ the plain output_text/input_text shape. */
+export function buildResponsesInput(messages: Message[], modelKey: string, stripArtifacts = false): ResponsesInputItem[] {
+  const nonSystem = messages.filter(m => m.role !== "system");
+  const items: ResponsesInputItem[] = [];
+  const plain = (m: Message): ResponsesInputItem => ({
+    role: m.role,
+    content: [
+      { type: m.role === "assistant" ? "output_text" : "input_text", text: m.content },
+      ...(m.role !== "assistant" && m.images?.length
+        ? m.images.map(img => ({ type: "input_image", image_url: `data:${img.mediaType};base64,${img.data}` }))
+        : []),
+    ],
+  });
+  nonSystem.forEach((m, i) => {
+    if (!stripArtifacts && m.role === "assistant" && responsesNativizable(m, modelKey)) {
+      for (const a of m.reasoningArtifacts!) {
+        if (a.provider === "openai" && a.model === modelKey && a.itemId && a.encrypted) {
+          items.push({ type: "reasoning", id: a.itemId, encrypted_content: a.encrypted, summary: [] });
+        }
+      }
+      for (const tu of m.toolUse!) {
+        items.push({ type: "function_call", call_id: tu.id, name: tu.tool, arguments: JSON.stringify(tu.arguments) });
+      }
+      return;
+    }
+    if (!stripArtifacts && m.role === "user" && m.toolResults?.length && i > 0
+        && nonSystem[i - 1].role === "assistant" && responsesNativizable(nonSystem[i - 1], modelKey)) {
+      for (const tr of m.toolResults) items.push({ type: "function_call_output", call_id: tr.id, output: tr.output });
+      if (m.toolResultExtra) items.push({ role: "user", content: [{ type: "input_text", text: m.toolResultExtra }] });
+      return;
+    }
+    items.push(plain(m));
+  });
+  return items;
+}
 /** Build the Codex Responses request (url + headers + body) for an OAuth credential. */
 export function codexResponsesRequest(
   messages: Message[],
   options: CallOptions,
   credential: Credential,
+  stripArtifacts = false,
 ): { url: string; headers: Record<string, string>; body: string } {
   const model = options.model.startsWith("openai/") ? options.model.slice(7) : options.model;
   const token = credential.kind === "none" ? "" : credential.token;
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
-  const input = messages
-    .filter(m => m.role !== "system")
-    .map(m => ({
-      role: m.role,
-      content: [
-        { type: m.role === "assistant" ? "output_text" : "input_text", text: m.content },
-        // Clipboard-pasted images ride along as input_image data URLs (user turns only —
-        // assistant history is always text in jeo).
-        ...(m.role !== "assistant" && m.images?.length
-          ? m.images.map(img => ({ type: "input_image", image_url: `data:${img.mediaType};base64,${img.data}` }))
-          : []),
-      ],
-    }));
+  const input = buildResponsesInput(messages, options.model, stripArtifacts);
   const payload: Record<string, unknown> = {
     model,
     instructions: systemPrompt ?? "You are a helpful coding assistant.",
@@ -81,6 +117,9 @@ export function codexResponsesRequest(
   // Both speak the same Responses schema (the body above), so only url+headers differ.
   if (credential.kind === "api_key") {
     const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    // Stateless reasoning replay (public Responses API): ask for encrypted reasoning content
+    // so it can be captured and threaded back into a later `input` (store stays false).
+    payload.include = ["reasoning.encrypted_content"];
     return {
       url: `${base}/responses`,
       headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream" },
@@ -113,6 +152,8 @@ export interface ResponsesEvent {
   toolCallName?: string;
   toolCallArgsDelta?: string;
   toolCallIndex?: number;
+  /** A completed reasoning item carrying its id + encrypted_content (stateless replay capture). */
+  reasoningItem?: { id: string; encrypted: string };
 }
 
 /** Parse one Responses SSE `data:` payload into a delta / usage / error. */
@@ -120,7 +161,7 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
   let o: {
     type?: string;
     delta?: unknown;
-    item?: { type?: string; name?: string };
+    item?: { type?: string; name?: string; id?: string; encrypted_content?: string };
     output_index?: number;
     response?: {
       usage?: { input_tokens?: number; output_tokens?: number };
@@ -137,6 +178,11 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
   if (o.type === "response.output_item.added" && o.item?.type === "function_call") {
     return { toolCallName: o.item.name, toolCallIndex: o.output_index };
   }
+  // A completed reasoning item carries the encrypted_content we replay later (needs the
+  // request's `include: ["reasoning.encrypted_content"]`). Captured on output_item.done.
+  if (o.type === "response.output_item.done" && o.item?.type === "reasoning" && o.item.id && o.item.encrypted_content) {
+    return { reasoningItem: { id: o.item.id, encrypted: o.item.encrypted_content } };
+  }
   if (o.type === "response.function_call_arguments.delta" && typeof o.delta === "string") {
     return { toolCallArgsDelta: o.delta, toolCallIndex: o.output_index };
   }
@@ -185,10 +231,20 @@ function emptyCompletionError(reason: string | undefined): Error {
   return new Error(`OpenAI Codex returned no content${reason ? ` (${reason})` : ""}${hint}.`);
 }
 
+/** Fetch the Responses endpoint with a reasoning-artifact fail-safe (see fetchWithArtifactFailSafe). */
+function fetchResponses(messages: Message[], options: CallOptions, credential: Credential): Promise<Response> {
+  return fetchWithArtifactFailSafe(
+    strip => {
+      const { url, headers, body } = codexResponsesRequest(messages, options, credential, strip);
+      return fetch(url, { method: "POST", headers, body, signal: options.signal });
+    },
+    (status, body) => status === 400 && /reasoning|encrypted_content/i.test(body),
+  );
+}
+
 /** Non-streaming call over the Codex backend (collects the streamed output). */
 export async function codexResponsesCall(messages: Message[], options: CallOptions, credential: Credential): Promise<string> {
-  const { url, headers, body } = codexResponsesRequest(messages, options, credential);
-  const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+  const response = await fetchResponses(messages, options, credential);
   if (!response.ok) throw await providerHttpError("OpenAI", response);
   if (!response.body) return "";
   let out = "";
@@ -198,6 +254,7 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
     const ev = parseResponsesEvent(data);
     if (ev.delta) out += ev.delta;
     if (ev.reasoningDelta) options.onReasoning?.(ev.reasoningDelta);
+    if (ev.reasoningItem) options.onReasoningArtifact?.({ provider: "openai", model: options.model, itemId: ev.reasoningItem.id, encrypted: ev.reasoningItem.encrypted });
     accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
@@ -216,8 +273,7 @@ export async function* codexResponsesStream(
   options: CallOptions,
   credential: Credential,
 ): AsyncGenerator<string> {
-  const { url, headers, body } = codexResponsesRequest(messages, options, credential);
-  const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+  const response = await fetchResponses(messages, options, credential);
   if (!response.ok) throw await providerHttpError("OpenAI", response, "(stream)");
   if (!response.body) return;
   let yieldedAny = false;
@@ -226,6 +282,7 @@ export async function* codexResponsesStream(
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
     if (ev.reasoningDelta) options.onReasoning?.(ev.reasoningDelta);
+    if (ev.reasoningItem) options.onReasoningArtifact?.({ provider: "openai", model: options.model, itemId: ev.reasoningItem.id, encrypted: ev.reasoningItem.encrypted });
     if (ev.delta) {
       yieldedAny = true;
       yield ev.delta;

package/src/ai/types.ts

@@ -19,9 +19,58 @@ export interface Message {
   images?: ImageAttachment[];
   /** Persisted reasoning/thinking text for an assistant turn (the thought before the
    *  answer). Survives /resume + export so the durable record shows "think → answer".
-   *  Display-only: NOT replayed to providers (anthropic/gemini thinking replay needs
-   *  the original signed block, which the streaming path does not capture). */
+   *  Display channel; the REPLAY channel is `reasoningArtifacts`. */
   reasoning?: string;
+  /** Provider-native, opaque reasoning artifacts captured during streaming (Anthropic
+   *  thinking signature, Gemini thoughtSignature, OpenAI Responses reasoning items).
+   *  Replayed to the SAME provider+model to preserve multi-step reasoning continuity;
+   *  dropped on cross-model replay. Display-agnostic, not written to markdown export. */
+  reasoningArtifacts?: ReasoningArtifact[];
+  /** Structured native tool calls this assistant turn made (with stable ids). `content`
+   *  keeps the canonical JSON envelope for display/compaction/fallback adapters; capable
+   *  adapters replay these as native tool_use / functionCall / function_call blocks. */
+  toolUse?: ToolUseRecord[];
+  /** Structured native tool results for a tool-feedback user turn (ids match the prior
+   *  assistant's `toolUse`). Capable adapters replay these as native tool_result /
+   *  functionResponse / function_call_output blocks. */
+  toolResults?: ToolResultRecord[];
+  /** Non-tool trailing text on a tool-feedback user turn (e.g. post-turn hook
+   *  diagnostics) — replayed as a trailing text block after the native tool results. */
+  toolResultExtra?: string;
+}
+
+/** A provider-native opaque reasoning artifact. Only replayed when `provider` AND
+ *  `model` match the active call (the adapter stamps the exact wire model id). */
+export interface ReasoningArtifact {
+  provider: ProviderName;
+  model: string;
+  /** Thought text (display is covered by Message.reasoning; kept here for fidelity). */
+  text?: string;
+  /** Anthropic: thinking block signature. */
+  signature?: string;
+  /** Anthropic: redacted_thinking opaque data. */
+  redacted?: string;
+  /** Gemini: per-part thoughtSignature (binds to the matching functionCall part). */
+  thoughtSignature?: string;
+  /** OpenAI Responses: reasoning item id. */
+  itemId?: string;
+  /** OpenAI Responses: reasoning item encrypted_content. */
+  encrypted?: string;
+}
+
+/** A structured native tool call (assistant turn). `id` is a stable synthetic id the
+ *  engine assigns so tool_use ↔ tool_result correlation survives replay. */
+export interface ToolUseRecord {
+  id: string;
+  tool: string;
+  arguments: Record<string, unknown>;
+}
+
+/** A structured native tool result (user turn). `id` matches a prior `ToolUseRecord`. */
+export interface ToolResultRecord {
+  id: string;
+  output: string;
+  isError: boolean;
 }
 
 export interface Usage {
@@ -67,6 +116,10 @@ export interface CallOptions {
    *  answer text). Surfaced as a transient dimmed view; absent for models that emit no
    *  thought text. */
   onReasoning?: (delta: string) => void;
+  /** Sink for provider-native reasoning ARTIFACTS captured during streaming (signature /
+   *  thoughtSignature / reasoning item id+encrypted). Separate from `onReasoning` (display
+   *  text) because these arrive on different SSE events and are opaque replay data. */
+  onReasoningArtifact?: (artifact: ReasoningArtifact) => void;
   /** NATIVE tool-calling: function declarations the model may call. Present only on the
    *  main agent step (never the prose wrap-up). Adapters with `supportsNativeTools` send
    *  these on the wire and re-serialize the structured tool call back into the engine's

package/src/commands/launch.ts

@@ -250,12 +250,25 @@ export function providerPickEntries(live: ProviderModelsResult[], want: Provider
   if (catalog.length) {
     return catalog.map((m, i) => ({ index: i + 1, provider: want, model: qualifyModelId(m.providerModel, want) }));
   }
+  // Offline fallback for catalog-less (OpenAI-compatible) providers: the def's
+  // defaultModel first, then its knownModels list, so the per-role provider picker
+  // shows several pickable ids instead of one. De-duped + provider-qualified.
+  const def = openaiCompatDef(want);
+  if (def) {
+    const ids = [def.defaultModel, ...(def.knownModels ?? [])].map(m => qualifyModelId(m, want));
+    const seen = new Set<string>();
+    const entries: PickEntry[] = [];
+    for (const model of ids) {
+      if (seen.has(model)) continue;
+      seen.add(model);
+      entries.push({ index: entries.length + 1, provider: want, model });
+    }
+    if (entries.length) return entries;
+  }
   const fallback = providerDefaultModel(want);
   return fallback ? [{ index: 1, provider: want, model: qualifyModelId(fallback, want) }] : [];
 }
 
-
-
 export function formatResumeHint(sessionId: string): string {
   return `Resume with: jeo launch --resume ${sessionId}`;
 }
@@ -510,6 +523,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // answer). Captured from the reasoning stream and persisted on the assistant message so
   // it survives /resume + export (gjc "think → answer" record). Reset at each turn start.
   let lastTurnReasoning = "";
+  // Native reasoning artifacts for the FINAL (done) step — the engine attaches intermediate
+  // steps' artifacts to their own pushed messages, but the done turn is built here. Reset on
+  // each step boundary so only the last step's artifacts ride the final reply (no duplication).
+  let lastTurnArtifacts: import("../ai/types").ReasoningArtifact[] = [];
   /** Wrap turn events so EVERY sink (TUI or plain stream) records the last full
    *  tool output for the Ctrl+O detail view. */
   const withToolDetailCapture = (base: ReturnType<LaunchTui["events"]>): ReturnType<LaunchTui["events"]> => ({
@@ -518,12 +535,22 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       lastToolDetail = { tool, output };
       base.onToolResult?.(tool, success, output);
     },
+    onStep: (step: number) => {
+      // New step: drop the prior step's final-reply artifacts so only the LAST step's ride
+      // the done reply (intermediate steps are persisted by the engine on their own turns).
+      lastTurnArtifacts = [];
+      base.onStep?.(step);
+    },
     onReasoningStream: (textSoFar: string) => {
       // textSoFar is the cumulative thought for the current step; keep the latest
       // non-empty value (the thought immediately preceding the turn's answer).
       if (textSoFar.trim()) lastTurnReasoning = textSoFar;
       base.onReasoningStream?.(textSoFar);
     },
+    onReasoningArtifactStream: (artifact) => {
+      lastTurnArtifacts.push(artifact);
+      base.onReasoningArtifactStream?.(artifact);
+    },
   });
   /** Compose a session-persistence flush into onStep so each completed step is
    *  written as it lands (durability across mid-turn interruption) without
@@ -626,6 +653,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // persistence block below.
     let beforeLen = history.length;
     lastTurnReasoning = ""; // fresh turn: capture this turn's thinking from scratch
+    lastTurnArtifacts = [];
     // Incremental session persistence (durability across mid-turn interruption):
     // persistTurnTail() flushes history messages added since the last flush — called
     // right after the user prompt, on every onStep boundary, and once post-turn — so
@@ -929,9 +957,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // this only covers the tail — net content is the full turn either way.
     try {
       await persistTurnTail();
-      const assistantMsg: Message = lastTurnReasoning.trim()
-        ? { role: "assistant", content: reply, reasoning: lastTurnReasoning }
-        : { role: "assistant", content: reply };
+      const assistantMsg: Message = { role: "assistant", content: reply };
+      if (lastTurnReasoning.trim()) assistantMsg.reasoning = lastTurnReasoning;
+      if (lastTurnArtifacts.length) assistantMsg.reasoningArtifacts = lastTurnArtifacts;
       history.push(assistantMsg);
       if (sessionId) await appendMessage(sessionId, assistantMsg, cwd);
       if (tui) tui.finish(reply);
@@ -1616,7 +1644,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     jeoEnv("NO_SLASH_PREVIEW") !== "1";
   // Footer height reserved by the CURRENTLY armed region; disarm/draw must use the
   // same value the arm computed, even if the terminal was resized in between.
+  // `footerRows` is the MAX reservation height (the budget previewLines/historyPreview
+  // may fill). The PHYSICAL reservation (`footerRendered`) is now dynamic: compact at
+  // idle (no dropdown) so a finished/idle prompt leaves NO reserved blank rows, and
+  // grown on demand when a slash/arg preview needs more. `footerWantRows` is the height
+  // the latest previewLines/historyPreview wants; drawFooter re-pins to it in place.
   let footerRows = MAX_PREVIEW_ROWS;
+  // Compact idle reservation: status bar (1) + spacer (1) + input box (3 rows).
+  const COMPACT_FOOTER_ROWS = 5;
+  let footerWantRows = COMPACT_FOOTER_ROWS;
   const out = process.stdout;
   // Arrow-key selection over the slash preview list.
   let navMatches: string[] = []; // command names matching the typed keyword (display order)
@@ -1666,24 +1702,42 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // line painted at an older, wider geometry reflows onto extra rows after a width shrink.
   let lastDrawnLines: string[] = [];
   const padToFooter = (lines: string[]): string[] => {
-    if (lines.length >= footerRows) return lines.slice(0, footerRows);
-    return [...lines, ...new Array(footerRows - lines.length).fill("")];
+    if (lines.length >= footerRendered) return lines.slice(0, footerRendered);
+    return [...lines, ...new Array(footerRendered - lines.length).fill("")];
   };
   const armPreview = () => {
     if (!previewEnabled || previewArmed) return;
     footerRows = previewRowsFor(process.stdout.rows ?? 24);
-    // Reserve `footerRows` bottom rows: write blank newlines (the terminal scrolls
-    // ONCE here, not on every keystroke), then park the cursor at the top of the
-    // reservation. Every subsequent drawFooter call stays inside this region.
-    if (footerRows > 1) {
-      out.write("\n".repeat(footerRows - 1) + cursorUp(footerRows - 1));
+    // Reserve a COMPACT region (idle prompt height) right after the current output —
+    // not the full `footerRows` budget — so a finished/idle prompt leaves no blank rows
+    // below it. drawFooter grows the reservation in place when a dropdown needs more.
+    const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+    if (initial > 1) {
+      out.write("\n".repeat(initial - 1) + cursorUp(initial - 1));
     }
     out.write(toColumn(1));
-    footerRendered = footerRows;
+    footerRendered = initial;
+    footerWantRows = initial;
     footerParkedRow = 0;
     previewArmed = true;
     lastFooterKey = "";
   };
+  // Re-pin the reservation to `n` rows IN PLACE (right after the existing output, never
+  // bottom-pinned): clear the old region from its top, then reserve `n` rows there. Used
+  // by drawFooter to grow for a dropdown and shrink back to the compact idle height, so
+  // the prompt never carries a trailing/floating blank block.
+  const setFooterRows = (n: number) => {
+    n = Math.max(1, Math.min(n, footerRows));
+    if (!previewArmed || n === footerRendered) return;
+    let s = footerParkedRow > 0 ? cursorUp(footerParkedRow) : "";
+    s += toColumn(1) + clearToEnd(); // wipe old region; cursor now at its top (after output)
+    if (n > 1) s += "\n".repeat(n - 1) + cursorUp(n - 1);
+    s += toColumn(1);
+    out.write(s);
+    footerRendered = n;
+    footerParkedRow = 0;
+    lastFooterKey = ""; // force a full repaint into the resized region
+  };
   // Clear the reserved region and park the cursor at its top row so subsequent
   // command output starts where the box was (and inherits the existing scrollback).
   const disarmPreview = () => {
@@ -1800,7 +1854,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const slash = budget > 0 ? formatSlashPreview(line, budget, selected, skillSlashDetails, resolvedSkills) : [];
     const args = !slash.length && budget > 0 ? formatCompletionPreview(line, completionContext(), budget) : [];
     const preview = (slash.length ? slash : args).map(l => chalk.gray(truncateAnsi(l, cols)));
-    return [statusBarLine(cols), "", ...input, ...preview].slice(0, footerRows);
+    const result = [statusBarLine(cols), "", ...input, ...preview].slice(0, footerRows);
+    // Want only the input box + status bar at idle (no dropdown) → compact reservation;
+    // grow to fit the dropdown when a preview is present.
+    footerWantRows = preview.length > 0 ? result.length : Math.min(footerRows, 2 + input.length);
+    return result;
   };
   // Render the reversible Ctrl+O detail panel into the footer reservation: a status
   // bar, a title (with scroll hint when needed), then a windowed slice of the detail
@@ -1838,10 +1896,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       if (below > 0) body.push(chalk.dim(`↓ ${below} more below`));
     }
     footerCursor = { row: Math.min(1, footerRows - 1), col: 1 };
-    return [statusBarLine(cols), title, ...body].slice(0, footerRows);
+    const result = [statusBarLine(cols), title, ...body].slice(0, footerRows);
+    footerWantRows = result.length; // the Ctrl+O panel sizes the reservation to its content
+    return result;
   };
   const drawFooter = (lines: string[]) => {
     if (!previewArmed || footerRendered === 0) return;
+    // Re-pin the reservation to the height the latest preview/panel wants (compact at
+    // idle, grown for a dropdown) BEFORE painting, so no reserved blank trails the prompt.
+    setFooterRows(footerWantRows);
     // ALWAYS paint exactly footerRendered rows so the reservation is fully covered
     // and no row can spill past it — the bug fix that kept `@folder<more text>`
     // typing from scrolling the input box (and prior output) off the top.
@@ -2558,9 +2621,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           out.write(clearScreen());
           out.write(renderWelcome({ ...welcomeData, cols }).join("\n") + "\n");
           footerRows = previewRowsFor(rows);
-          if (footerRows > 1) out.write("\n".repeat(footerRows - 1) + cursorUp(footerRows - 1));
+          const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+          if (initial > 1) out.write("\n".repeat(initial - 1) + cursorUp(initial - 1));
           out.write(toColumn(1));
-          footerRendered = footerRows;
+          footerRendered = initial;
+          footerWantRows = initial;
           drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
           return;
         }
@@ -2591,14 +2656,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const caretSubRow = Math.floor(Math.max(0, footerCursor.col - 1) / c);
         const hopUp = abovePhysical + caretSubRow;
         let s = (hopUp > 0 ? cursorUp(hopUp) : "") + toColumn(1) + clearToEnd();
-        // Re-pin a clean reservation to the screen bottom and repaint. ED already blanked
-        // from the frame top down to the bottom, so just position at the bottom region.
+        // Re-pin a COMPACT reservation right where the frame top was (just below the
+        // static content) — NOT bottom-pinned. ED already blanked from the frame top
+        // down, so reserve the idle height here; drawFooter grows it for a dropdown.
+        // Bottom-pinning left a tall blank gap above the bar when the content was short.
         footerRows = previewRowsFor(rows);
-        s += `\x1b[${Math.max(1, rows)};1H`;
-        if (footerRows > 1) s += cursorUp(footerRows - 1);
+        const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+        if (initial > 1) s += "\n".repeat(initial - 1) + cursorUp(initial - 1);
         s += toColumn(1);
         out.write(s);
-        footerRendered = footerRows;
+        footerRendered = initial;
+        footerWantRows = initial;
         footerParkedRow = 0;
         lastFooterKey = "";
         drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));

package/src/tui/app.ts

@@ -68,6 +68,9 @@ export interface AgentEventsLike {
   onUsage?(usage: { inputTokens: number; outputTokens: number }): void;
   onModelStream?(textSoFar: string): void;
   onReasoningStream?(textSoFar: string): void;
+  /** Per-artifact native reasoning replay records (signature / thoughtSignature / reasoning
+   *  item). The TUI ignores these; launch.ts uses them to persist the final reply's artifacts. */
+  onReasoningArtifactStream?(artifact: import("../ai/types").ReasoningArtifact): void;
   onBudget?(limit: number, reason: string): void;
 
 }
@@ -112,6 +115,27 @@ export function tailForWrap(text: string, maxChars = FRAME_WRAP_TAIL_CHARS): str
   return text.length > maxChars ? text.slice(text.length - maxChars) : text;
 }
 
+/** Max lines of a committed reasoning block kept in scrollback (gjc-style collapse): a
+ *  long chain-of-thought is clipped with a "+N more" hint so it never floods the ledger. */
+export const THINKING_COMMIT_MAX_LINES = 12;
+
+/** Collapse a committed reasoning block to a line cap, appending a "… (+N more lines)"
+ *  hint when clipped (gjc collapsed-by-default parity). Returns the input verbatim when
+ *  it already fits. */
+export function clipReasoningLines(text: string, cap = THINKING_COMMIT_MAX_LINES): string {
+  const rows = text.replace(/\r/g, "").split("\n");
+  if (rows.length <= cap) return rows.join("\n");
+  return [...rows.slice(0, cap), `… (+${rows.length - cap} more lines)`].join("\n");
+}
+
+/** gjc-style "thought for Ns" header for a committed/streaming Thinking block. Omits the
+ *  duration when no step start is known (e.g. resumed/exported records). */
+export function thinkingHeader(elapsedMs: number | undefined, unicode: boolean): string {
+  const diamond = unicode ? "◇" : "*";
+  const secs = elapsedMs !== undefined && elapsedMs >= 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : null;
+  return `${diamond} thinking${secs ? ` · ${secs}` : ""}`;
+}
+
 /** Status animation palette while a tool/process runs (background verification): an
  *  amber→yellow gradient, distinct from the cool thinking gradient, so "the agent is
  *  running a process / verifying" reads at a glance (gjc parity: `theme.fg("warning")`
@@ -444,13 +468,17 @@ export class LaunchTui {
             : (s: string) => s;
           const style = (prose: string) => prose.split("\n").map(styleThought).join("\n");
           const parts: string[] = [this.agentLabel()];
+          // gjc "thought for Ns" header: step-start → commit ≈ the model's think+gen time.
+          const elapsedMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
+          const header = thinkingHeader(elapsedMs, this.unicode);
+          parts.push(this.theme.color ? chalk.dim(header) : header);
           if (willFlushThought) {
             this.flushedThought = this.streamingThought;
-            parts.push(style(this.streamingThought));
+            parts.push(style(clipReasoningLines(this.streamingThought)));
           }
           if (willFlushReasoning) {
             this.flushedReasoning = this.streamingReasoning;
-            parts.push(style(this.streamingReasoning));
+            parts.push(style(clipReasoningLines(this.streamingReasoning)));
           }
           this.appendLedger(`${parts.join("\n")}\n`, "reasoning");
         }
@@ -1206,7 +1234,7 @@ export class LaunchTui {
    *  block shows only the most-recent lines, capped at ~30% of the screen height (a
    *  ceiling guards a tall terminal), so it grows with the stream and shrinks with the
    *  viewport. Returns [] when there is nothing to show. */
-  private renderLiveBlock(label: string, text: string, cols: number, rows: number, ceiling: number): string[] {
+  private renderLiveBlock(label: string, text: string, cols: number, rows: number, ceiling: number, cacheKey = label): string[] {
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
     if (!text.trim()) return [];
     const wrapW = Math.max(8, cols - 2);
@@ -1214,8 +1242,8 @@ export class LaunchTui {
     // this (up to 16KB) tail every frame just re-segments graphemes for no visible change.
     // Per-label slot (Thinking / Output) keyed by wrap width + text — a real delta misses
     // once and recomputes; an idle tick hits the cache. `rows` only gates the post-slice.
-    let cache = this.liveBlockWrapCaches.get(label);
-    if (!cache) { cache = lastValueCache<string[]>(); this.liveBlockWrapCaches.set(label, cache); }
+    let cache = this.liveBlockWrapCaches.get(cacheKey);
+    if (!cache) { cache = lastValueCache<string[]>(); this.liveBlockWrapCaches.set(cacheKey, cache); }
     const wrapped = cache(`${wrapW}\u0000${text}`, () =>
       tailForWrap(text)
         .split("\n")
@@ -1349,7 +1377,11 @@ export class LaunchTui {
     // rectangle, so a short trace leaves no padded "hole" and a short terminal is spared.
     const liveThink = this.streamingThought.trim() || this.streamingReasoning.trim();
     if (isThinking && liveThink) {
-      tail.push(...this.renderLiveBlock("Thinking", liveThink, cols, rows, 6));
+      // gjc-parity: the Thinking block label carries a running timer ("Thinking · Ns").
+      // Cache key stays the constant "Thinking" so the per-frame wrap memo is unaffected.
+      const liveMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
+      const liveLabel = liveMs !== undefined ? `Thinking · ${(liveMs / 1000).toFixed(1)}s` : "Thinking";
+      tail.push(...this.renderLiveBlock(liveLabel, liveThink, cols, rows, 6, "Thinking"));
     }
 
     // Live tool output (gjc-style streaming bash stdout): while a tool runs, its