u-foo 3.0.6 → 3.0.7

package/src/code/nativeRunner.js

@@ -33,9 +33,13 @@ const {
 const {
   drainAgentMailboxForTurn,
   shouldAutoContinueForTaskWake,
-  buildTaskRunWakeReminder,
   listTaskRunsAwaitingModel,
 } = require("./runtime/agentWakeup");
+const {
+  shouldIsolateTaskFocusTurn,
+  buildIsolatedTaskFocusTurn,
+  sanitizeToolResultForModel,
+} = require("./runtime/taskFocusContext");
 const {
   runAskUserTool,
   syncInteractionFromPlanGraph,
@@ -185,6 +189,7 @@ function createUsageTotals() {
     output: 0,
     cacheRead: 0,
     cacheCreation: 0,
+    lastContextTokens: 0,
   };
 }
 
@@ -889,6 +894,8 @@ function runCoreTool({
     return {
       ...result.modelPayload,
       ok: result.status === "accepted",
+      // Keep executionState for the runner only; sanitizeToolResultForModel
+      // strips it before the payload enters provider messages.
       executionState: result.executionState || state,
     };
   }
@@ -1694,7 +1701,7 @@ function shadowResolvePending(ledger, pending, toolResult) {
   const callId = pendingToolCallId(pending);
   if (!callId) return;
   resolveCall(ledger, callId, {
-    result: toolResult,
+    result: sanitizeToolResultForModel(toolResult),
     isError: Boolean(!toolResult || toolResult.ok === false),
   });
 }
@@ -1733,6 +1740,7 @@ async function runNativeLoop({
   onPhase = null,
   onToolEvent = null,
   onArtifactPersisted = null,
+  onContextUsage = null,
   sessionId = "",
   signal = null,
   guards,
@@ -1743,12 +1751,31 @@ async function runNativeLoop({
   if (!requestModel) {
     throw new Error("ucode model is not configured");
   }
+  const {
+    contextTokensFromUsage,
+    buildContextMeter,
+  } = require("./contextWindow");
+  function emitContextUsage(turnUsage = null) {
+    const contextTokens = contextTokensFromUsage(turnUsage);
+    usage.lastContextTokens = contextTokens;
+    if (typeof onContextUsage !== "function") return;
+    try {
+      onContextUsage(buildContextMeter({
+        usedTokens: contextTokens,
+        model: requestModel,
+      }));
+    } catch {
+      // ignore UI callback failures
+    }
+  }
 
   const requestUrl = transport.resolveUrl(baseUrl);
   if (!requestUrl) {
     throw new Error("ucode baseUrl is not configured");
   }
 
+  // Durable Agent Loop transcript (returned + synced to session). Provider
+  // turns that serve TaskFocus use a fresh providerMessages list instead.
   const messages = sanitizeModelMessages(cloneMessageList(historyMessages));
   if (!resume) {
     transport.prepareMessages({ messages, systemPrompt, prompt });
@@ -1772,6 +1799,9 @@ async function runNativeLoop({
   let planAutoContinues = 0;
   let lastAutoContinueWaitingId = "";
   let consecutiveEmptyAutoContinues = 0;
+  let providerMessages = messages;
+  let isolatedActive = false;
+  let isolatedPrefixLength = 0;
 
   if (resume) {
     await withFaultPoint("before_provider_resume", () => {});
@@ -1779,20 +1809,55 @@ async function runNativeLoop({
 
   function injectPendingUserReminders() {
     const nudges = drainUserPrompts(executionState);
-    if (nudges.length === 0) return;
+    if (nudges.length === 0) return "";
     const waiting = executionState.planGraph && executionState.planGraph.waitingFor
       ? executionState.planGraph.waitingFor
       : null;
-    const content = formatUserReminderMessage(nudges, { waitingFor: waiting });
-    if (!content) return;
-    messages.push({ role: "user", content });
+    return formatUserReminderMessage(nudges, { waitingFor: waiting }) || "";
   }
 
   /** Deliver mid-loop TaskRun runtime events before the next model call. */
-  function injectRuntimeMailboxEvents() {
+  function injectRuntimeMailboxEvents(targetMessages) {
     const drained = drainAgentMailboxForTurn(executionState);
     if (!drained.text) return false;
-    messages.push({ role: "user", content: drained.text });
+    targetMessages.push({ role: "user", content: drained.text });
+    return true;
+  }
+
+  /**
+   * Mirror provider-only TaskFocus deltas onto the durable transcript so
+   * session sync / ask_user resume still see tool_use pairs, without feeding
+   * the full Agent Loop history back into the next isolated provider turn.
+   */
+  function mirrorIsolatedDeltaToDurable() {
+    if (!isolatedActive || providerMessages === messages) return;
+    const delta = providerMessages.slice(isolatedPrefixLength);
+    for (const entry of delta) {
+      messages.push(cloneMessageList([entry])[0]);
+    }
+    isolatedPrefixLength = providerMessages.length;
+  }
+
+  /**
+   * Serve waiting TaskRun / plan-task turns on a fresh one-message context.
+   * Durable `messages` is left intact for transcript sync.
+   */
+  function applyIsolatedTaskFocusContext() {
+    if (!shouldIsolateTaskFocusTurn(executionState)) {
+      isolatedActive = false;
+      providerMessages = messages;
+      isolatedPrefixLength = 0;
+      return false;
+    }
+    const drained = drainAgentMailboxForTurn(executionState);
+    const userNudge = injectPendingUserReminders();
+    const isolated = buildIsolatedTaskFocusTurn(executionState, {
+      mailboxEvents: drained.events || [],
+      userNudge,
+    });
+    providerMessages = isolated.messages;
+    isolatedActive = true;
+    isolatedPrefixLength = providerMessages.length;
     return true;
   }
 
@@ -1820,26 +1885,24 @@ async function runNativeLoop({
       return false;
     }
 
-    // Prefer draining fresh runtime mail (task_started, etc.) before nudges.
-    if (injectRuntimeMailboxEvents()) {
+    // TaskFocus isolation rebuilds providerMessages at the top of the next
+    // loop iteration — just signal continue when a task/plan still needs service.
+    if (shouldIsolateTaskFocusTurn(executionState) || shouldAutoContinueForTaskWake(executionState)) {
       planAutoContinues += 1;
       lastAutoContinueWaitingId = continueKey;
       consecutiveEmptyAutoContinues += 1;
       return true;
     }
 
-    if (shouldAutoContinuePlan(executionState)) {
-      const reminder = buildPlanAutoContinueReminder(executionState);
-      if (!reminder) return false;
-      messages.push({ role: "user", content: reminder });
+    if (injectRuntimeMailboxEvents(messages)) {
       planAutoContinues += 1;
       lastAutoContinueWaitingId = continueKey;
       consecutiveEmptyAutoContinues += 1;
       return true;
     }
 
-    if (shouldAutoContinueForTaskWake(executionState)) {
-      const reminder = buildTaskRunWakeReminder(executionState);
+    if (shouldAutoContinuePlan(executionState)) {
+      const reminder = buildPlanAutoContinueReminder(executionState);
       if (!reminder) return false;
       messages.push({ role: "user", content: reminder });
       planAutoContinues += 1;
@@ -1854,8 +1917,11 @@ async function runNativeLoop({
   while (true) {
     guards.ensureActive();
 
-    injectPendingUserReminders();
-    injectRuntimeMailboxEvents();
+    if (!applyIsolatedTaskFocusContext()) {
+      const nudge = injectPendingUserReminders();
+      if (nudge) messages.push({ role: "user", content: nudge });
+      injectRuntimeMailboxEvents(messages);
+    }
 
     if (activeLedger) {
       runProviderTurnGate(activeLedger);
@@ -1868,7 +1934,7 @@ async function runNativeLoop({
       provider,
       systemPrompt,
       systemBlocks,
-      messages,
+      messages: providerMessages,
       signal,
       timeoutMs,
       onPhase,
@@ -1886,6 +1952,7 @@ async function runNativeLoop({
 
     usage.turns += 1;
     addUsageTotals(usage, turnResult && turnResult.usage);
+    emitContextUsage(turnResult && turnResult.usage);
 
     const toolCalls = transport.getToolCalls(turnResult);
 
@@ -1894,7 +1961,7 @@ async function runNativeLoop({
       const sideEffects = parseStructuredSideEffects(text);
       const planCommand = sideEffects ? normalizePlanGraphCommand(sideEffects) : null;
       if (planCommand) {
-          transport.appendFinalAssistantMessage({ messages, turnResult });
+          transport.appendFinalAssistantMessage({ messages: providerMessages, turnResult });
           const planResult = runCoreTool({
             tool: "plan_graph",
             args: planCommand,
@@ -1908,18 +1975,22 @@ async function runNativeLoop({
           if (planResult && planResult.executionState) {
             executionState = planResult.executionState;
           }
-          messages.push({
+          providerMessages.push({
             role: "user",
             content: JSON.stringify({
               type: "plan_graph_result",
-              ...((planResult && planResult.status)
-                ? planResult
-                : { status: "rejected", ok: false, error: "plan_graph failed" }),
+              ...sanitizeToolResultForModel(
+                (planResult && planResult.status)
+                  ? planResult
+                  : { status: "rejected", ok: false, error: "plan_graph failed" },
+              ),
             }),
           });
+          mirrorIsolatedDeltaToDurable();
           continue;
       }
-      transport.appendFinalAssistantMessage({ messages, turnResult });
+      transport.appendFinalAssistantMessage({ messages: providerMessages, turnResult });
+      mirrorIsolatedDeltaToDurable();
       if (!aggregated.trim() && text) {
         aggregated = text;
       }
@@ -1940,8 +2011,13 @@ async function runNativeLoop({
     // A tool-using turn resets the empty auto-continue streak (progress possible).
     consecutiveEmptyAutoContinues = 0;
 
-    const pendingCalls = transport.prepareToolCalls({ messages, turnResult, toolCalls });
+    const pendingCalls = transport.prepareToolCalls({
+      messages: providerMessages,
+      turnResult,
+      toolCalls,
+    });
     if (!pendingCalls) {
+      mirrorIsolatedDeltaToDurable();
       return {
         text: aggregated,
         streamed,
@@ -1977,7 +2053,8 @@ async function runNativeLoop({
         toolCallsExecuted += 1;
         toolErrors += 1;
       }
-      flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+      flushLedgerToolResults(activeLedger, transport, providerMessages, pendingCalls);
+      mirrorIsolatedDeltaToDurable();
       lastProtocolLedger = snapshotLedger(activeLedger);
       continue;
     }
@@ -1993,7 +2070,8 @@ async function runNativeLoop({
         toolCallsExecuted += 1;
         toolErrors += 1;
       }
-      flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+      flushLedgerToolResults(activeLedger, transport, providerMessages, pendingCalls);
+      mirrorIsolatedDeltaToDurable();
       lastProtocolLedger = snapshotLedger(activeLedger);
       continue;
     }
@@ -2114,7 +2192,8 @@ async function runNativeLoop({
       shadowResolvePending(activeLedger, pending, toolResult);
     }
 
-    flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+    flushLedgerToolResults(activeLedger, transport, providerMessages, pendingCalls);
+    mirrorIsolatedDeltaToDurable();
     lastProtocolLedger = snapshotLedger(activeLedger);
 
     if (deferredAskUser) {
@@ -2184,6 +2263,7 @@ async function runNativeAgentTask({
   onPhase = null,
   onToolEvent = null,
   onArtifactPersisted = null,
+  onContextUsage = null,
   signal = null,
   executionState = null,
   resume = false,
@@ -2258,6 +2338,7 @@ async function runNativeAgentTask({
       onPhase,
       onToolEvent,
       onArtifactPersisted,
+      onContextUsage,
       sessionId: nextSessionId,
       signal,
       guards,
@@ -2274,6 +2355,11 @@ async function runNativeAgentTask({
     const usage = runResult.usage && typeof runResult.usage === "object"
       ? runResult.usage
       : createUsageTotals();
+    const { buildContextMeter } = require("./contextWindow");
+    const contextMeter = buildContextMeter({
+      usedTokens: usage.lastContextTokens,
+      model: runtime.model,
+    });
     appendUsageRecord(workspaceRoot, {
       sessionId: nextSessionId,
       model: runtime.model,
@@ -2292,6 +2378,7 @@ async function runNativeAgentTask({
       messages: cloneMessageList(runResult.messages),
       sessionId: nextSessionId,
       usage,
+      contextMeter,
       executionState: runResult.executionState || executionState || null,
       // The loop marks streamed=true whenever it receives a stream callback;
       // only report it when the caller actually registered one.

package/src/code/runtime/index.js

@@ -12,4 +12,5 @@ module.exports = {
   ...require("./toolProvenance"),
   ...require("./graphYieldRouter"),
   ...require("./agentWakeup"),
+  ...require("./taskFocusContext"),
 };

package/src/code/runtime/taskFocusContext.js

@@ -0,0 +1,190 @@
+"use strict";
+
+/**
+ * Isolated TaskFocus turns for Agent Loop.
+ *
+ * TaskLoop steps must not inherit the full Agent Loop transcript. When a
+ * TaskRun is waiting_model (or the parent plan is waiting on a task node),
+ * rebuild a fresh one-message turn from TaskFocus + compact graph hints.
+ */
+
+const {
+  listTaskRunsAwaitingModel,
+  buildTaskRunWakeReminder,
+  formatAgentRuntimeEvents,
+} = require("./agentWakeup");
+const { buildTaskFocus, renderTaskFocusText, getExecutionKind } = require("./taskFocus");
+const { shouldAutoContinuePlan, buildPlanAutoContinueReminder } = require("../context/userNudge");
+
+function getChildGraph(executionState = null, graphId = "") {
+  const id = String(graphId || "").trim();
+  if (!id || !executionState || typeof executionState !== "object") return null;
+  if (executionState.graphs && executionState.graphs[id]) return executionState.graphs[id];
+  if (executionState.planGraph && executionState.planGraph.graphId === id) {
+    return executionState.planGraph;
+  }
+  return null;
+}
+
+function waitingPlanNode(executionState = null) {
+  const pg = executionState && executionState.planGraph;
+  const waiting = pg && pg.waitingFor;
+  if (!waiting || !waiting.id) return null;
+  if (String(waiting.type || "").trim().toLowerCase() !== "task") return null;
+  const nodes = Array.isArray(pg.nodes) ? pg.nodes : [];
+  return nodes.find((node) => node && node.id === waiting.id) || null;
+}
+
+/**
+ * True when the next model turn should use TaskFocus isolation instead of the
+ * accumulating Agent Loop transcript.
+ */
+function shouldIsolateTaskFocusTurn(executionState = null) {
+  if (!executionState || typeof executionState !== "object") return false;
+  if (executionState.pendingUserInteraction) return false;
+  // Active TaskRun waiting_model always gets a fresh TaskFocus turn.
+  if (listTaskRunsAwaitingModel(executionState).length > 0) return true;
+  // Parent-plan waits without a TaskRun only isolate when the Agent Loop
+  // would also auto-continue (skip approval_required / terminal yields).
+  if (!shouldAutoContinuePlan(executionState)) return false;
+  const node = waitingPlanNode(executionState);
+  if (!node) return false;
+  const kind = getExecutionKind(node);
+  return kind === "task_loop" || kind === "expand" || kind === "inline_llm" || kind === "llm";
+}
+
+function pickPrimaryAwaitingRun(executionState = null) {
+  const runs = listTaskRunsAwaitingModel(executionState);
+  return runs[0] || null;
+}
+
+function rebuildFocusText(executionState = null, run = null) {
+  if (run && String(run.lastFocusText || "").trim()) {
+    return String(run.lastFocusText).trim();
+  }
+  const parent = executionState && executionState.planGraph;
+  const nodes = parent && Array.isArray(parent.nodes) ? parent.nodes : [];
+  const nodeId = (run && run.parentNodeId)
+    || (waitingPlanNode(executionState) && waitingPlanNode(executionState).id)
+    || "";
+  const focus = buildTaskFocus({
+    nodes,
+    currentNodeId: nodeId,
+    taskRunsById: (executionState.taskRuns && executionState.taskRuns.byId) || {},
+    recentlyChangedFiles: executionState.modifiedFiles || [],
+    standaloneTask: run && !run.parentNodeId
+      ? {
+        id: run.id,
+        objective: run.objective || run.title || "",
+        title: run.title || run.objective || run.id,
+        status: run.status,
+      }
+      : null,
+  });
+  return renderTaskFocusText(focus);
+}
+
+function compactChildGraphHint(executionState = null, run = null) {
+  if (!run || !run.childGraphId) return "";
+  const child = getChildGraph(executionState, run.childGraphId);
+  if (!child) return `Child graph ${run.childGraphId}: (missing)`;
+  const waiting = child.waitingFor;
+  const nodes = Array.isArray(child.nodes) ? child.nodes : [];
+  const lines = [
+    `Child graph ${child.graphId}:`,
+    `  objective: ${String(child.objective || "").slice(0, 200)}`,
+    `  nodes: ${nodes.length}`,
+  ];
+  if (waiting && waiting.id) {
+    lines.push(`  waitingFor: ${waiting.type || "node"}:${waiting.id}`);
+  }
+  const pending = nodes
+    .filter((n) => n && (n.status === "pending" || n.status === "ready" || n.status === "waiting_llm"))
+    .slice(0, 6)
+    .map((n) => `${n.id}[${n.status || "pending"}]`);
+  if (pending.length) lines.push(`  open: ${pending.join(", ")}`);
+  return lines.join("\n");
+}
+
+function buildIsolationWakeText(executionState = null, mailboxEvents = []) {
+  const parts = [];
+  const mailText = formatAgentRuntimeEvents(mailboxEvents);
+  if (mailText) parts.push(mailText);
+  const taskWake = buildTaskRunWakeReminder(executionState);
+  if (taskWake) parts.push(taskWake);
+  else if (shouldAutoContinuePlan(executionState)) {
+    const planWake = buildPlanAutoContinueReminder(executionState);
+    if (planWake) parts.push(planWake);
+  }
+  return parts.join("\n\n").trim();
+}
+
+/**
+ * Build a fresh Agent Loop message list for one TaskFocus-scoped model turn.
+ */
+function buildIsolatedTaskFocusTurn(executionState = null, options = {}) {
+  const run = pickPrimaryAwaitingRun(executionState);
+  const focusText = rebuildFocusText(executionState, run);
+  const childHint = compactChildGraphHint(executionState, run);
+  const wakeText = String(options.wakeText || "").trim()
+    || buildIsolationWakeText(executionState, options.mailboxEvents || []);
+  const userNudge = String(options.userNudge || "").trim();
+
+  const content = [
+    "Isolated TaskFocus turn (no prior Agent Loop transcript).",
+    "Serve only the current task / child graph. Do not re-litigate finished plan nodes.",
+    focusText,
+    childHint,
+    wakeText,
+    userNudge,
+  ].filter(Boolean).join("\n\n");
+
+  return {
+    isolated: true,
+    taskRunId: run && run.id ? String(run.id) : "",
+    childGraphId: run && run.childGraphId ? String(run.childGraphId) : "",
+    parentNodeId: run && run.parentNodeId ? String(run.parentNodeId) : "",
+    messages: [{ role: "user", content }],
+  };
+}
+
+/**
+ * Drop runner-only fields before a tool result is serialized into model messages.
+ * executionState alone can be hundreds of KB and must never enter the prompt.
+ */
+function sanitizeToolResultForModel(toolResult = null) {
+  if (!toolResult || typeof toolResult !== "object" || Array.isArray(toolResult)) {
+    return toolResult;
+  }
+  const {
+    executionState,
+    compile,
+    taskLoopResume,
+    ...rest
+  } = toolResult;
+  if (rest.modelPayload && typeof rest.modelPayload === "object") {
+    const {
+      executionState: nestedState,
+      compile: nestedCompile,
+      ...payloadRest
+    } = rest.modelPayload;
+    rest.modelPayload = payloadRest;
+    void nestedState;
+    void nestedCompile;
+  }
+  void executionState;
+  void compile;
+  void taskLoopResume;
+  return rest;
+}
+
+module.exports = {
+  shouldIsolateTaskFocusTurn,
+  pickPrimaryAwaitingRun,
+  rebuildFocusText,
+  compactChildGraphHint,
+  buildIsolationWakeText,
+  buildIsolatedTaskFocusTurn,
+  sanitizeToolResultForModel,
+  waitingPlanNode,
+};

package/src/code/sessionStore.js

@@ -113,6 +113,15 @@ function buildSessionSnapshot(input = {}) {
       : 0,
     // In-memory compatibility for callers still reading nlMessages
     nlMessages: cloneMessages(source.nlMessages),
+    contextMeter: source.contextMeter && typeof source.contextMeter === "object"
+      ? {
+        usedTokens: Number(source.contextMeter.usedTokens) || 0,
+        limitTokens: Number(source.contextMeter.limitTokens) || 0,
+        model: String(source.contextMeter.model || source.model || "").trim(),
+        label: String(source.contextMeter.label || "").trim(),
+        updatedAt: String(source.contextMeter.updatedAt || "").trim(),
+      }
+      : null,
   };
 }
 

package/src/ui/format/index.js

@@ -16,22 +16,16 @@ const UCODE_BANNER_LINES = [
 
 const UCODE_VERSION = String((pkg && pkg.version) || "dev");
 
-// Flying-saucer patrol for busy/loading states: the 🛸 drifts left-right
-// inside a fixed 6-cell field (three emoji slots), so the status text after
-// it stays anchored instead of shifting with the saucer.
-const UFO_FIELD_CELLS = 6;
-const UFO_FRAMES = [];
-for (let i = 0; i <= UFO_FIELD_CELLS - 2; i += 1) {
-  UFO_FRAMES.push(`${" ".repeat(i)}🛸${" ".repeat(UFO_FIELD_CELLS - 2 - i)}`);
-}
-for (let i = UFO_FIELD_CELLS - 3; i > 0; i -= 1) {
-  UFO_FRAMES.push(`${" ".repeat(i)}🛸${" ".repeat(UFO_FIELD_CELLS - 2 - i)}`);
-}
+// Fixed-width ASCII spinner. The old 🛸 patrol used emoji + padding that many
+// terminals measure differently from Ink/Yoga, so long status lines left a
+// staircase of ghost glyphs (and dragged vN.N.N into the log area).
+const SPINNER_FRAMES = ["-", "\\", "|", "/"];
+const WAITING_FRAMES = [".  ", ".. ", "...", ".. ", ".  "];
 
 const STATUS_INDICATORS = {
-  thinking: UFO_FRAMES,
-  typing: UFO_FRAMES,
-  waiting: ["∙", "∙∙", "∙∙∙", "∙∙", "∙"],
+  thinking: SPINNER_FRAMES,
+  typing: SPINNER_FRAMES,
+  waiting: WAITING_FRAMES,
 };
 
 // Friendly labels for the tool-call events surfaced in the status line.

package/src/ui/ink/ChatApp.js

@@ -1187,7 +1187,7 @@ function createChatStatusLine({ React, ink }) {
   const { useEffect, useState } = React;
   const { Box, Text } = ink;
   const h = React.createElement;
-  return function ChatStatusLine({ status, version }) {
+  return function ChatStatusLine({ status, version, cols = 80 }) {
     const message = String((status && status.message) || "");
     const animated = Boolean(message)
       && isAnimatedStatusType(inferStatusType(message, status && status.type));
@@ -1197,10 +1197,16 @@ function createChatStatusLine({ React, ink }) {
       const timer = setInterval(() => setTick((t) => t + 1), 100);
       return () => clearInterval(timer);
     }, [animated]);
+    const versionText = `v${version || ""}`;
+    const raw = computeStatusText(status, animated ? tick : 0);
+    // Keep the version pinned on the right; truncate the live message so a
+    // long bus status cannot collide with it or leave redraw trails.
+    const leftBudget = Math.max(12, (Number(cols) || 80) - fmt.displayCellWidth(versionText) - 2);
+    const left = fitPlainLine(raw, leftBudget);
     return h(Box, { marginTop: 1, width: "100%" },
-      h(Text, { color: "gray" }, computeStatusText(status, animated ? tick : 0)),
+      h(Text, { color: "gray", wrap: "truncate" }, left),
       h(Box, { flexGrow: 1 }),
-      h(Text, { color: "gray" }, `v${version}`),
+      h(Text, { color: "gray" }, versionText),
     );
   };
 }
@@ -3605,7 +3611,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       }
       if (row.kind === "user") {
         const userBody = renderUserLogBody(row.bodyText);
-        return h(Box, { key, width: "100%", marginBottom: 1 },
+        return h(Box, { key, width: "100%", marginBottom: 1, alignItems: "flex-start" },
           h(Text, { color: "green", bold: true }, row.markerText || "› "),
           userBody.at
             ? h(Text, { color: "magenta", bold: true }, `@${userBody.at} `)
@@ -3621,7 +3627,9 @@ function createChatApp({ React, ink, props, interactive = true }) {
         wrap: "wrap",
       };
       if (colors.dim) bodyProps.dimColor = true;
-      return h(Box, { key, width: "100%" },
+      // Pin the gutter glyph to the first text line; default Yoga stretch/center
+      // floats markers above wrapped speaker · body rows.
+      return h(Box, { key, width: "100%", alignItems: "flex-start" },
         h(Text, {
           color: colors.marker,
           bold: row.kind === "error" || row.kind === "assistant",
@@ -3682,7 +3690,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       }
       if (row.kind === "user") {
         const userBody = renderUserLogBody(row.bodyText);
-        return h(Box, { key, width: "100%", marginTop, marginBottom: 1 },
+        return h(Box, { key, width: "100%", marginTop, marginBottom: 1, alignItems: "flex-start" },
           h(Text, { color: "green", bold: true }, row.markerText || "› "),
           userBody.at
             ? h(Text, { color: "magenta", bold: true }, `@${userBody.at} `)
@@ -3698,7 +3706,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
         wrap: "wrap",
       };
       if (colors.dim) bodyProps.dimColor = true;
-      return h(Box, { key, width: "100%", marginTop },
+      return h(Box, { key, width: "100%", marginTop, alignItems: "flex-start" },
         h(Text, {
           color: colors.marker,
           bold: row.kind === "error" || row.kind === "assistant",
@@ -3809,7 +3817,11 @@ function createChatApp({ React, ink, props, interactive = true }) {
       activeStreamGroups ? h(Box, { flexDirection: "column" },
         ...activeStreamGroups.map(renderChatLogGroup).filter(Boolean),
       ) : null,
-      h(ChatStatusLine, { status: state.status, version: fmt.UCODE_VERSION }),
+      h(ChatStatusLine, {
+        status: state.status,
+        version: fmt.UCODE_VERSION,
+        cols: size.cols || 80,
+      }),
       completionsOpen ? (() => {
         const start = Math.min(completionWindowStart, Math.max(0, completions.length - POPUP_PAGE_SIZE));
         const end = Math.min(completions.length, start + POPUP_PAGE_SIZE);