@visual-z/xeno 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # xeno changelog
 
+## 0.8.1 — 2026-10-11
+
+The sidebar now follows your goal:
+- The Goal block appears only for `/goal`. It lists every accepted check — ✓ passed, ✗ failed with its exit code, ○ not yet — with `guard` or `/accept <id>` beside it, then the evidence ladder and what the goal has used: requests, and tokens in this run.
+  - The heading reads working, needs you, met or stopped, with how long the goal has been running.
+  - A met goal stays as one line until your next message.
+- A request without a goal shows nothing, or one `Checks` line once it has changed files: not run since the last edit, or the latest check with ✓ or ✗ and its exit code. A declared acceptance contract shows how many of its criteria hold.
+- While a goal's criteria are being drafted the sidebar shows `Goal · drafting` and your objective, not the drafting instructions.
+- Without a sidebar (narrower than 110 columns) the goal sits on the input box's lower edge: `goal 2/3 · needs you · 4m 12s`.
+- Context and Usage fit in five rows instead of up to eight. Both budgets keep their names and shares. The node number, the observation and retry counts, the tool count when nothing failed and the `/control` hint moved out; they remain in `/control` and `/state`.
+- Generation speed: Usage and the input box show tokens per second for the current turn, measured as OpenCode does: output over the time its model requests took. Reasoning that a provider does not stream is never left out of the time, so the figure does not overstate. Requests shorter than 250 ms are not counted.
+- Running time reads `59s`, `1m 05s`, `1h 02m 05s` instead of `3725s`, and so does an update's progress against its limit.
+
+Fixes:
+- A gateway that answers "about to call a tool" with no tool call no longer ends the request silently. The response is retried automatically; once retries run out it is reported as a provider error.
+- The Anthropic SDK path now sends `xeno/<version>` as its User-Agent, as the other paths do, so gateways attribute its traffic to xeno instead of a custom client.
+
 ## 0.8.0 — 2026-10-10
 
 xeno now proves completion with receipts, and proves the receipts test the change. Two changes need attention when upgrading:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visual-z/xeno",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "UNLICENSED",
   "type": "module",
   "description": "Segmented append-only agent log with pure context and handoff projections",

package/src/apps/ui/app.ts

@@ -55,6 +55,8 @@ import { sessionsDir } from "../../store/sessions.ts";
 import { readGitStatus } from "../../store/git-status.ts";
 import type { GitStatus } from "../../core/git-status.ts";
 import { activityStatus } from "../../core/activity-status.ts";
+import { goalStatus } from "../../core/goal-view.ts";
+import { generationSpeed } from "../../runtime/usage.ts";
 import { executionOutcome, type ExecutionOutcome } from "../../core/outcome.ts";
 import { projectTrust } from "../../store/trust.ts";
 import { discoverResources, setResourceOverride } from "../../store/resource-index.ts";
@@ -161,6 +163,14 @@ export class InteractiveApp implements Ui {
   private gitRun: Promise<void> | undefined;
   private gitAgain = false;
   private attention: ControlSnapshot["waiting"] = null;
+  /** The objective of a /goal whose criteria are being drafted. */
+  private drafting: string | undefined;
+  /** Index of this turn's first usage sample; generation speed reads from here. */
+  private turnUsageStart = 0;
+  /** Where this process began counting a goal's tokens: usage samples are kept per process, not in the log. */
+  private goalUsage: { goal: string; start: number } | undefined;
+  /** The last goal view and what it was derived from; see goalAndChecks. */
+  private goalCache: { key: string; view: import("../../core/goal-view.ts").GoalStatus | null; goal?: string } | undefined;
   private lastOutcome: ExecutionOutcome | undefined;
   private paintTimer: ReturnType<typeof setTimeout> | undefined;
   /** Handoff-derived status (sidebar / top bar), refreshed single-flight and debounced (DoD 9). */
@@ -594,21 +604,61 @@ export class InteractiveApp implements Ui {
       ...(budget ? { context: { used: budget.used, trigger: budget.trigger, estimated: budget.estimated, segment: app.session.state.node, ...(spec.contextWindow ? { window: spec.contextWindow } : {}) } } : {}),
       ...(t.requests ? { usage: { input: t.prompt_tokens, output: t.output_tokens, cacheRate: t.cache_hit_rate,
         // Under half a cent reads as $0.00, which says nothing (OpenCode #15903; Grok's status line hides it the same way).
-        cost: cost.kind === "usd" && cost.amount >= 0.005 ? `~$${cost.amount.toFixed(2)}` : cost.kind === "partial" && cost.known >= 0.005 ? `≥$${cost.known.toFixed(2)}` : null } } : {}),
+        cost: cost.kind === "usd" && cost.amount >= 0.005 ? `~$${cost.amount.toFixed(2)}` : cost.kind === "partial" && cost.known >= 0.005 ? `≥$${cost.known.toFixed(2)}` : null,
+        ...speedOf(app.session.state.usage.slice(this.turnUsageStart)) } } : {}),
       tools: { running: tools.filter(tool => tool.status === "pending").length, done: tools.filter(tool => tool.status === "ok").length, failed: tools.filter(tool => tool.status === "error").length },
       ...(this.derived ?? {}),
-      ...(this.controlSnapshot?.goal ? { goal: { text: this.controlSnapshot.goal.text,
-        status: this.controlSnapshot.goal.state.status,
-        execution: this.inflight ? "running" : this.controlSnapshot.goal.state.execution?.reason ?? "idle",
-        observations: this.controlSnapshot.goal.state.progress.observations.length,
-        ...ladderView(this.controlSnapshot.goal.state),
-        retries: this.controlSnapshot.goal.state.progress.unchanged_retries.length } } : {}),
+      ...this.goalAndChecks(),
       files: this.files,
       resources: { contextFiles: app.loadedContext.agents.map(file => basename(file.path)), skills: app.slash?.skills.size ?? 0, extensions: app.extensions?.loaded.length ?? 0 },
       ...(extension ? { extension } : {}),
     };
   }
 
+  /**
+   * The sidebar's evidence: an explicit goal's block, or -- without one -- a
+   * Checks line for a request that changed files or declared a contract
+   * (feat-sidebar-goal-and-speed). Both read the request ledger the control
+   * snapshot already derived. The goal view is a scan of the whole log, so it
+   * is cached per log length; only its clock is read on every paint.
+   */
+  private goalAndChecks(): Pick<StatusModel, "goal" | "checks"> {
+    const state = this.controlSnapshot?.goal?.state, session = this.app.session;
+    const key = `${this.app.logDir}:${session.state.node}:${this.ancestors.length}:${session.state.events.length}:${this.inflight}:${this.drafting ?? ""}:${state?.request.event ?? ""}:${state?.status ?? ""}`;
+    if (this.goalCache?.key !== key) {
+      const events = [...this.ancestors, ...session.state.events];
+      const set = events.findLast(event => event.t === "goal" && event.action === "set");
+      this.goalCache = { key, view: goalStatus(events, state, { running: this.inflight, ...(this.drafting !== undefined ? { drafting: this.drafting } : {}) }),
+        ...(set ? { goal: set.id } : {}) };
+    }
+    const view = this.goalCache.view;
+    if (view) {
+      // The session's own clock stamps the log, so a running goal's time is read on it too.
+      const now = Date.parse(session.clock.now());
+      const since = this.goalCache.goal ? session.state.usage.slice(this.goalUsageStart(this.goalCache.goal)) : [];
+      const tokens = since.reduce((total, sample) => total + sample.input_tokens + sample.cache_creation_input_tokens + sample.cache_read_input_tokens + sample.output_tokens, 0);
+      return { goal: { phase: view.phase, objective: view.objective, checks: view.checks, requests: view.requests,
+        elapsedMs: view.phase === "drafting" ? 0 : Math.max(0, (view.endedAt ?? now) - view.startedAt),
+        ...(state && view.phase !== "drafting" ? ladderView(state) : {}), ...(tokens ? { tokens } : {}) } };
+    }
+    if (state?.acceptance) {
+      // A declared contract without /goal: how many of its criteria hold; /acceptance lists them.
+      const items = state.acceptance.criteria, passed = items.filter(item => item.status === "pass" || item.status === "accepted").length;
+      return { checks: { status: passed === items.length ? "pass" : "partial", command: `${passed}/${items.length} passed · /acceptance` } };
+    }
+    if (!state?.changed) return {};
+    const fresh = state.criteria.find(item => item.kind === "fresh_check");
+    const run = fresh?.command ? state.commands.findLast(command => command.command === fresh.command) : state.commands.at(-1);
+    if (!fresh || fresh.status === "not_run" || !run) return { checks: { status: "unchecked" } };
+    return { checks: { status: fresh.status === "pass" ? "pass" : fresh.status === "stale" ? "stale" : "fail", command: run.command, exit: run.exit } };
+  }
+
+  /** Usage samples belong to this process; a goal's spend counts those recorded after this process first saw it. */
+  private goalUsageStart(goal: string): number {
+    if (this.goalUsage?.goal !== goal) this.goalUsage = { goal, start: this.app.session.state.usage.length };
+    return this.goalUsage.start;
+  }
+
   private writeTitle(title: string): void {
     if (title === this.writtenTitle || this.disposed) return;
     this.writtenTitle = title;
@@ -865,11 +915,13 @@ export class InteractiveApp implements Ui {
    */
   startGoal(objective: string): void {
     this.track(async () => {
+      // The draft request's own text is an instruction to the model, not the goal; the sidebar shows the objective.
+      this.drafting = objective;
       const pending = await draftGoal(this.app, objective, async (prompt, options) => {
         await this.runPromptTurn(prompt, [], undefined, options);
         // A cancelled draft is not a draft to accept, nor one to send back.
         return this.lastOutcome?.status !== "cancelled";
-      });
+      }).finally(() => { this.drafting = undefined; this.paint(); });
       if (!pending) return;
       this.push({ kind: "list", title: `Accept the checks for: ${objective}`, multi: true, checked: pending.criteria.map(item => item.id), search: false,
         items: pending.criteria.map(item => ({ value: item.id, label: item.id, description: criterionSummary(item) })),
@@ -886,6 +938,8 @@ export class InteractiveApp implements Ui {
     this.abort = new AbortController();
     this.inflight = true;
     this.lastOutcome = undefined;
+    // Speed is per turn: only this turn's model requests count (feat-sidebar-goal-and-speed).
+    this.turnUsageStart = this.app.session.state.usage.length;
     this.programResult = false;
     this.program?.update(programStatus({ running: true }));
     this.executionKind = text.startsWith("!") ? "bash" : "model";
@@ -1140,7 +1194,7 @@ export class InteractiveApp implements Ui {
     const detachInput = control.attachInput(phase => this.pullQueued(phase));
     const unsubscribe = control.subscribe(notice => {
       if (this.disposed) return;
-      if (notice.method === "turn/started") { this.lastOutcome = undefined; this.program?.update(programStatus({ running: true })); }
+      if (notice.method === "turn/started") { this.lastOutcome = undefined; this.turnUsageStart = this.app.session.state.usage.length; this.program?.update(programStatus({ running: true })); }
       if (notice.method === "turn/error") {
         this.lastOutcome = executionOutcome("execution_error");
         this.programResult = true; this.program?.update({ state: "error", msg: "Turn failed; inspect the session" });
@@ -1623,6 +1677,12 @@ function projectWithStart(items: ReturnType<typeof projectItems>, clock: string
 }
 
 /** "~/Projects/workspace/xeno-tui" → "~/P/w/xeno-tui": every directory but the last cut to its first letter. */
+/** The turn's speed when one can be measured; nothing otherwise, so the row never shows a made-up figure. */
+function speedOf(samples: readonly import("../../runtime/usage.ts").UsageSample[]): { speed?: number } {
+  const speed = generationSpeed(samples);
+  return speed === undefined ? {} : { speed };
+}
+
 export function shortPath(path: string): string {
   const parts = path.split("/");
   return parts.map((part, i) => i === parts.length - 1 || part === "~" || part === "" ? part : part.startsWith(".") ? part.slice(0, 2) : part.slice(0, 1)).join("/");

package/src/core/goal-view.ts

@@ -0,0 +1,64 @@
+/**
+ * What the sidebar shows about an explicit goal (feat-sidebar-goal-and-speed),
+ * derived from the log alone so it reads the same after a restart.
+ *
+ * The block exists only while a /goal is set, and for one message after it is
+ * met. Its verdicts are the request ledger's (D11); this only chooses words:
+ * the phase answers "do I need to act, and is it still running", and each
+ * accepted check says what it needs from the user.
+ */
+import type { LogEvent } from "./events.ts";
+import type { RequestCriterion, RequestState } from "./request-state.ts";
+
+export type GoalPhase = "drafting" | "working" | "needs_you" | "met" | "stopped";
+export type GoalCheck = { id: string; kind: RequestCriterion["kind"]; status: RequestCriterion["status"]; guard?: true; exit?: number };
+/**
+ * `startedAt` is when the goal was set; `endedAt` when it was met, absent while
+ * it runs. Times, not a duration, so a caller can cache this per log length and
+ * read the clock only when it paints.
+ */
+export type GoalStatus = { phase: GoalPhase; objective: string; checks: GoalCheck[]; startedAt: number; endedAt?: number; requests: number };
+
+/**
+ * The goal block for the end of an ancestry, or null when no goal applies.
+ * `running` is whether a request is in flight now; `drafting` is the objective
+ * of a /goal whose criteria are still being drafted.
+ */
+export function goalStatus(events: readonly LogEvent[], state: RequestState | undefined,
+  live: { running: boolean; drafting?: string }): GoalStatus | null {
+  if (live.drafting !== undefined) return { phase: "drafting", objective: live.drafting, checks: [], startedAt: 0, requests: 0 };
+  const lastSet = events.findLastIndex(event => event.t === "goal" && event.action === "set");
+  if (lastSet < 0) return null;
+  const set = events[lastSet]!;
+  if (set.t !== "goal" || set.action !== "set") return null;
+  const after = events.slice(lastSet + 1);
+  // The last clear decides: a met goal the user then cleared is gone like any other cleared goal.
+  const clear = after.findLastIndex(event => event.t === "goal" && event.action === "clear");
+  const cleared = clear < 0 ? undefined : after[clear];
+  // A goal the user cleared is gone; a met goal stays for one summary, until the next message opens a new request.
+  if (cleared?.t === "goal" && cleared.action === "clear" && cleared.reason !== "met") return null;
+  const recorded = cleared !== undefined;
+  if (recorded && after.slice(clear + 1).some(event => event.t === "user" && event.request === undefined)) return null;
+  // Only the goal's own request carries its contract; the ledger of any other request says nothing about it.
+  const own = state?.acceptance?.contract_id === set.contract.id && state.acceptance.contract_event !== undefined
+    && events.some((event, index) => index > lastSet && event.id === state.acceptance!.contract_event) ? state : undefined;
+  // The ledger is the verdict (D11): verified is met even before the clear is recorded -- an /accept outside a
+  // request, a log written before /accept recorded it -- and its clock stops at the last recorded fact.
+  const met = recorded || own?.status === "verified";
+  const end = recorded ? Date.parse(cleared.at) : met ? Date.parse(after.at(-1)?.at ?? set.at) : undefined;
+  const checks: GoalCheck[] = set.contract.criteria.map(item => {
+    const entry = own?.criteria.find(criterion => criterion.id === item.id);
+    const run = item.kind === "command" ? own?.commands.findLast(command => command.command === item.command) : undefined;
+    return { id: item.id, kind: item.kind, status: entry?.status ?? (item.kind === "human" ? "awaiting_human" : "not_run"),
+      ...(item.kind === "command" && item.guard ? { guard: true as const } : {}),
+      ...(entry?.status === "fail" && run ? { exit: run.exit } : {}) };
+  });
+  return { phase: met ? "met" : live.running ? "working" : own?.status === "awaiting_human" ? "needs_you" : "stopped",
+    objective: set.objective, checks, startedAt: Date.parse(set.at), ...(end === undefined ? {} : { endedAt: end }),
+    requests: (recorded ? after.slice(0, clear) : after).filter(event => event.t === "assistant").length };
+}
+
+/** The words the sidebar and the input edge use for a phase. */
+export function goalPhaseLabel(phase: GoalPhase): string {
+  return phase === "needs_you" ? "needs you" : phase;
+}

package/src/core/response-recovery.ts

@@ -1,5 +1,5 @@
 /** N.12: a returned response is durable evidence, not necessarily a completed action. */
-import type { GuidanceEvent, LogEvent } from "./events.ts";
+import type { AssistantBlock, GuidanceEvent, LogEvent } from "./events.ts";
 import { currentRequestEvents } from "./request-state.ts";
 
 // One appended attempt is an operational assumption, not a measured optimum.
@@ -15,6 +15,18 @@ export function isCompleteResponse(reason: string | null | undefined): boolean {
   return reason !== undefined && reason !== null && ["stop", "end_turn", "stop_sequence", "tool_calls", "tool_use"].includes(reason);
 }
 
+/**
+ * A stop that asks for tool execution must carry a tool call. One that does not
+ * is a malformed provider response, not the model's answer: taken as a final
+ * reply it ends the request with outcome unknown and nothing on screen
+ * (session mv28chr8-oc3x, an Anthropic-compatible gateway returning
+ * `stop_reason: tool_use` with no content). Adapters reject it inside their
+ * retry so the loop only sees a coherent turn or a definite failure.
+ */
+export function isToolStopWithoutCall(stopReason: string | null | undefined, blocks: readonly AssistantBlock[]): boolean {
+  return (stopReason === "tool_use" || stopReason === "tool_calls") && !blocks.some(block => block.type === "tool_use");
+}
+
 export function isOutputLimit(reason: string | null | undefined): boolean {
   return reason === "length" || reason === "max_tokens";
 }

package/src/runtime/openai.ts

@@ -23,7 +23,7 @@ import type { Message, ContentBlock, FrozenPrefix } from "../core/project.ts";
 import { imageData } from "./images.ts";
 import type { AssistantBlock } from "../core/events.ts";
 import { assertNever } from "../core/exhaustive.ts";
-import type { Provider, ProviderConfig, Turn, ToolSchema, OnDelta } from "./provider.ts";
+import { coherentTurn, type Provider, type ProviderConfig, type Turn, type ToolSchema, type OnDelta } from "./provider.ts";
 import { DEFAULT_COMPAT, type Compat, type Effort, type ModelSpec } from "./model.ts";
 import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
 import type { ProviderSendOptions } from "./provider-tool-policy.ts";
@@ -502,7 +502,7 @@ export class OpenAICompletionsProvider implements Provider {
     }
 
     const assembled = await readCompletionsSse(response.body, onDelta);
-    return parseResponse(assembled, node, Date.now() - started);
+    return coherentTurn(parseResponse(assembled, node, Date.now() - started), assembled.usage !== undefined);
   }
 }
 

package/src/runtime/pi-provider.ts

@@ -20,7 +20,7 @@ import { providerRequest } from "./provider-request.ts";
 import { grokVersionHint } from "./oauth.ts";
 import type { ResolveEffects } from "./auth.ts";
 import { imageData } from "./images.ts";
-import { FailedResponseError, type OnDelta, type Provider, type ProviderConfig, type ToolSchema, type Turn } from "./provider.ts";
+import { coherentTurn, FailedResponseError, type OnDelta, type Provider, type ProviderConfig, type ToolSchema, type Turn } from "./provider.ts";
 import { DEFAULT_RETRY, withRetry, type RetryPolicy } from "./retry.ts";
 import { HttpError, StreamError } from "./openai.ts";
 import type { UsageSample } from "./usage.ts";
@@ -392,7 +392,7 @@ export class PiProvider implements Provider {
     if (identityErrors.length) throw new ProviderIntegrityError(identityErrors, hasKnownUsage ? usage : undefined);
     // The SDK has already classified native STOP/end_turn/toolUse/length values. The loop consumes
     // xeno's closed completion vocabulary, never a raw native spelling that could skip tool execution.
-    return { blocks: piBlocks(completed, originalArguments.values), stopReason: completed.stopReason === "length" ? "max_tokens" : completed.stopReason === "toolUse" ? "tool_use" : "end_turn",
-      usage };
+    return coherentTurn({ blocks: piBlocks(completed, originalArguments.values), stopReason: completed.stopReason === "length" ? "max_tokens" : completed.stopReason === "toolUse" ? "tool_use" : "end_turn",
+      usage }, hasKnownUsage);
   }
 }

package/src/runtime/provider.ts

@@ -35,10 +35,12 @@ import type { Message, ContentBlock, FrozenPrefix } from "../core/project.ts";
 import { imageData } from "./images.ts";
 import type { AssistantBlock } from "../core/events.ts";
 import { assertNever } from "../core/exhaustive.ts";
+import { isToolStopWithoutCall } from "../core/response-recovery.ts";
 import type { UsageSample } from "./usage.ts";
 import { type Effort, type ModelSpec, CLAUDE_OPUS_5 } from "./model.ts";
 import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
 import { anthropicOAuthHeaders } from "./oauth.ts";
+import { XENO_VERSION } from "./version.ts";
 import type { ProviderSendOptions } from "./provider-tool-policy.ts";
 
 export interface ToolSchema {
@@ -159,6 +161,27 @@ export class FailedResponseError extends Error {
   }
 }
 
+/**
+ * A 200 response that contradicts itself, such as a tool stop with no tool
+ * call. retry.ts treats it like a transient stream failure: a fresh sample is
+ * the remedy, and exhausting retries must surface as a provider error rather
+ * than reach the loop as a silent final answer. The output token count tells
+ * "generated but lost in transit" apart from "nothing generated".
+ */
+export class MalformedResponseError extends FailedResponseError {
+  constructor(detail: string, usage?: UsageSample) {
+    super(`malformed provider response: ${detail}${usage ? ` (${usage.output_tokens} output tokens)` : ""}`, usage);
+    this.name = "MalformedResponseError";
+  }
+}
+
+/** Every adapter returns through this, so no dialect can hand the loop a contradictory turn. */
+export function coherentTurn(turn: Turn, usageKnown = true): Turn {
+  if (isToolStopWithoutCall(turn.stopReason, turn.blocks))
+    throw new MalformedResponseError(`stop_reason ${JSON.stringify(turn.stopReason)} without a tool call`, usageKnown ? turn.usage : undefined);
+  return turn;
+}
+
 /** Thrown for a refusal, which arrives as HTTP 200 rather than an error. */
 export class RefusalError extends FailedResponseError {
   readonly category: string | null;
@@ -176,6 +199,12 @@ function buildAnthropicClient(
   apiKey: string | undefined,
   options: { fetch?: typeof fetch; oauth?: boolean; baseUrl?: string },
 ): AnthropicTransport {
+  // D18: the User-Agent, not SDK headers, identifies xeno on the wire. Left alone
+  // the SDK sends `Anthropic/JS <version>`, which model gateways fold into "custom
+  // client" attribution; provider-request.ts already stamps xeno's UA on the Pi
+  // path. Constructor defaultHeaders merge after the SDK's built-in UA, so this
+  // entry wins without touching per-request headers.
+  const identity = { "User-Agent": `xeno/${XENO_VERSION}` };
   if (options.oauth === true && apiKey) {
     // authToken is Bearer. Passing apiKey here would send x-api-key, which
     // an OAuth token is not accepted as.
@@ -183,7 +212,7 @@ function buildAnthropicClient(
       maxRetries: 0,
       ...(options.baseUrl ? { baseURL: options.baseUrl } : {}),
       authToken: apiKey,
-      defaultHeaders: anthropicOAuthHeaders(),
+      defaultHeaders: { ...anthropicOAuthHeaders(), ...identity },
       ...(options.fetch ? { fetch: options.fetch } : {}),
     });
   }
@@ -191,6 +220,7 @@ function buildAnthropicClient(
     maxRetries: 0,
     ...(options.baseUrl ? { baseURL: options.baseUrl } : {}),
     ...(apiKey ? { apiKey } : {}),
+    defaultHeaders: identity,
     ...(options.fetch ? { fetch: options.fetch } : {}),
   });
 }
@@ -319,11 +349,11 @@ export class AnthropicProvider implements Provider {
       throw new RefusalError(details?.category ?? null, details?.explanation ?? null, assembled.usageKnown ? usage : undefined);
     }
 
-    return {
+    return coherentTurn({
       blocks: assembled.blocks,
       stopReason: assembled.stopReason,
       usage,
-    };
+    }, assembled.usageKnown);
   }
 }
 

package/src/runtime/retry.ts

@@ -33,6 +33,11 @@ function isStreamFailure(error: unknown): error is Error & { code?: string } {
   return error instanceof Error && error.name === "StreamError";
 }
 
+/** provider.ts MalformedResponseError: a self-contradictory 200, structural for the same reason. */
+function isMalformedResponse(error: unknown): boolean {
+  return error instanceof Error && error.name === "MalformedResponseError";
+}
+
 export interface RetryPolicy {
   /**
    * Attempts after the first. Four means a request can take about 15s of
@@ -140,8 +145,10 @@ export function retryDecision(
   // A failure reported inside a 200 stream carries no status. Relays and
   // Anthropic's own `overloaded_error` use it for exactly the conditions a
   // 5xx would signal; anything else in a stream is a real rejection.
-  if (status === undefined && isStreamFailure(error)) {
-    if (!TRANSIENT_STREAM.test(`${error.code ?? ""} ${error.message}`)) {
+  if (status === undefined && (isStreamFailure(error) || isMalformedResponse(error))) {
+    // A contradictory response is a bad sample, not a rejection of the request:
+    // resend it like a dropped stream, and let the bound turn it into an error.
+    if (isStreamFailure(error) && !TRANSIENT_STREAM.test(`${error.code ?? ""} ${error.message}`)) {
       return { retry: false, reason: "the stream reported a non-transient error" };
     }
     const base = Math.min(0.5 * 2 ** attempt, 8) * 1000;

package/src/runtime/usage.ts

@@ -88,6 +88,34 @@ export function totalUsage(samples: readonly UsageSample[]): UsageTotals {
   return t;
 }
 
+/**
+ * Below this a request's speed is not shown: a response that returns at once
+ * (a test double, a local cache) would divide into thousands of tokens per
+ * second. Assumed, not measured.
+ */
+export const SPEED_MIN_MS = 250;
+
+/**
+ * Output tokens per second over a set of model requests, or undefined when
+ * none can be measured (feat-sidebar-goal-and-speed). OpenCode's built-in
+ * turnTokensPerSecond uses the same definition: output over the time the
+ * requests took, each request counted once. Not output over the time since
+ * the first visible output -- output counts include reasoning that providers
+ * do not always stream (OpenAI summaries arrive late, Anthropic can omit
+ * them), so that would keep reasoning tokens and drop reasoning time, and
+ * overstate. Whole request time never overstates; an overloaded upstream
+ * reads slow, which is what the user is waiting on.
+ */
+export function generationSpeed(samples: readonly UsageSample[]): number | undefined {
+  let tokens = 0, ms = 0;
+  for (const sample of samples) {
+    if (sample.output_tokens <= 0 || !(sample.ms >= SPEED_MIN_MS)) continue;
+    tokens += sample.output_tokens;
+    ms += sample.ms;
+  }
+  return ms > 0 ? tokens / (ms / 1000) : undefined;
+}
+
 /**
  * Cost in equivalent base-input tokens, the unit appendix A's model uses.
  *

package/src/tui/ui/duration.ts

@@ -0,0 +1,16 @@
+/**
+ * Elapsed time as people read it (feat-sidebar-goal-and-speed): `59s`, then
+ * `1m 00s`, then `1h 01m 01s`. The steps are Codex's fmt_elapsed_compact; a
+ * running turn used to read `3725s`.
+ *
+ * Every field after the first is two digits, so a running clock keeps its
+ * width within a unit instead of jittering the labels beside it. Parts of a
+ * second never round up: the clock shows seconds that have fully passed.
+ */
+export function formatElapsed(ms: number): string {
+  const total = Number.isFinite(ms) && ms > 0 ? Math.floor(ms / 1000) : 0;
+  if (total < 60) return `${total}s`;
+  const seconds = String(total % 60).padStart(2, "0");
+  if (total < 3600) return `${Math.floor(total / 60)}m ${seconds}s`;
+  return `${Math.floor(total / 3600)}h ${String(Math.floor(total % 3600 / 60)).padStart(2, "0")}m ${seconds}s`;
+}

package/src/tui/ui/layout.ts

@@ -48,7 +48,7 @@ export function screenLayout(cols: number, rows: number, sidebarWanted = true):
   return { tier: "bare", sidebarWidth: 0, mainWidth: c, topbar: false };
 }
 
-export const STATUS_FIELDS = ["mode", "provider", "activity", "git", "model", "thinking", "context", "title", "workspace", "branch", "usage", "cost", "handoff", "tasks", "files", "background", "resources", "extension"] as const;
+export const STATUS_FIELDS = ["mode", "provider", "activity", "git", "model", "thinking", "context", "goal", "title", "workspace", "branch", "usage", "cost", "handoff", "tasks", "files", "background", "resources", "extension"] as const;
 export type StatusField = (typeof STATUS_FIELDS)[number];
 /** Screen surfaces only; the terminal title is outside the frame and listed separately. */
 export type Place = "sidebar" | "topbar" | "topEdge" | "bottomEdge" | "hidden";
@@ -61,13 +61,13 @@ export type Place = "sidebar" | "topbar" | "topEdge" | "bottomEdge" | "hidden";
 export function placement(tier: Tier): Readonly<Record<StatusField, Place>> {
   switch (tier) {
     case "sidebar":
-      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "sidebar", model: "bottomEdge", thinking: "bottomEdge", context: "sidebar", title: "sidebar", workspace: "sidebar", branch: "sidebar",
+      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "sidebar", model: "bottomEdge", thinking: "bottomEdge", context: "sidebar", goal: "sidebar", title: "sidebar", workspace: "sidebar", branch: "sidebar",
         usage: "sidebar", cost: "sidebar", handoff: "sidebar", tasks: "sidebar", files: "sidebar", background: "sidebar", resources: "sidebar", extension: "sidebar" };
     case "topbar":
-      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", title: "topbar", workspace: "topbar", branch: "topbar",
+      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", goal: "bottomEdge", title: "topbar", workspace: "topbar", branch: "topbar",
         usage: "hidden", cost: "topbar", handoff: "topbar", tasks: "hidden", files: "hidden", background: "topbar", resources: "hidden", extension: "topbar" };
     case "bare":
-      return { mode: "bottomEdge", provider: "hidden", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", title: "hidden", workspace: "hidden", branch: "hidden",
+      return { mode: "bottomEdge", provider: "hidden", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", goal: "bottomEdge", title: "hidden", workspace: "hidden", branch: "hidden",
         usage: "hidden", cost: "hidden", handoff: "hidden", tasks: "hidden", files: "hidden", background: "hidden", resources: "hidden", extension: "hidden" };
     default: return assertNever(tier, "placement");
   }

package/src/tui/ui/screen.ts

@@ -31,8 +31,9 @@ import { screenLayout, sidebarContentWidth, type ScreenLayout } from "./layout.t
 import { greetingLines, mascotFrame, MASCOT_FRAME_MS, MASCOT_FRAMES, type Greeting } from "./mascot.ts";
 import { MessageList, type MessageFeatures } from "./messages.ts";
 import { Motion } from "./motion.ts";
-import { contextLabel, modeLabels, sidebarLines, topbarRow, type Line, type StatusModel } from "./status.ts";
+import { contextLabel, goalLabel, modeLabels, sidebarLines, speedText, topbarRow, type Line, type StatusModel } from "./status.ts";
 import { DEFAULT_CELL, stripImageRows } from "./image-size.ts";
+import { formatElapsed } from "./duration.ts";
 import { Pictures, type PictureSource } from "./pictures.ts";
 import type { ImageView, ViewItem } from "./items.ts";
 
@@ -376,11 +377,14 @@ export class Screen {
       // to recover on the existing edge, without putting control content in it.
       left = [{ segs: [{ text: "Resize for control", role: "accent" }], priority: 0, min: 1 }];
     } else if (d.busy) {
-      const seconds = Math.max(0, Math.floor((Date.now() - this.busySince) / 1000));
+      const elapsed = formatElapsed(Date.now() - this.busySince);
       const activity = this.status?.activity;
       const label = activity ? `${activity.label}${activity.label === "Running tool" || activity.label === "Retrying" ? ` · ${activity.detail}` : ""}${activity.queued ? ` · ${activity.queued} queued` : ""}` : d.activity;
       const transient = this.transientActivity ? ` · ${this.transientActivityText()}` : "";
-      left = [{ segs: [{ text: "●", role: "accent", spin: activity?.state !== "blocked" }, { text: ` ${label}${transient}`, role: activity?.state === "blocked" ? "warning" : "muted" }, { text: ` ${seconds}s`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
+      left = [{ segs: [{ text: "●", role: "accent", spin: activity?.state !== "blocked" }, { text: ` ${label}${transient}`, role: activity?.state === "blocked" ? "warning" : "muted" }, { text: ` ${elapsed}`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
+      // The turn's speed so far, refreshed after each model request (runtime/usage.ts generationSpeed).
+      const speed = this.status?.usage?.speed;
+      if (speed !== undefined) right.push({ segs: [{ text: speedText(speed), role: "muted" }], priority: 3 });
       right.push({ segs: [{ text: "esc interrupt", role: "muted" }], priority: 4 });
     } else if (this.transientActivity) {
       left = [{ segs: [{ text: "●", role: "accent", spin: true }, { text: ` ${this.transientActivityText()}`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
@@ -396,8 +400,10 @@ export class Screen {
       { segs: [{ text: d.model, role: "text" as const, bold: true }], priority: 1, min: 8 },
       ...(d.thinking ? [{ segs: [{ text: d.thinking, role: "muted" as const }], priority: 2 }] : []),
     ] : [])];
+    // Without a sidebar the goal and the context share ride on this edge (layout.ts placement).
     const context = this.shape.tier !== "sidebar" && this.status ? contextLabel(this.status) : undefined;
-    this.bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"], role, left: bottomLeft, right: context ? [context] : [] })]);
+    const goal = this.shape.tier !== "sidebar" && this.status ? goalLabel(this.status) : undefined;
+    this.bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"], role, left: bottomLeft, right: [...(goal ? [goal] : []), ...(context ? [context] : [])] })]);
   }
 
   /** A stream event arrived (delta, tool progress, shell output): the spinner returns to full speed. */
@@ -426,9 +432,9 @@ export class Screen {
 
   private transientActivityText(): string {
     const activity = this.transientActivity!;
-    const elapsed = Math.max(0, Math.floor((Date.now() - activity.startedAt) / 1000));
-    const deadline = Math.max(1, Math.ceil(activity.timeoutMs / 1000));
-    return `${activity.label} · ${elapsed}s / ${deadline}s max${activity.detail ? ` · ${activity.detail}` : ""}`;
+    // The limit is a whole number of seconds, rounded up so it is never shown shorter than it is.
+    const deadline = Math.max(1, Math.ceil(activity.timeoutMs / 1000)) * 1000;
+    return `${activity.label} · ${formatElapsed(Date.now() - activity.startedAt)} / ${formatElapsed(deadline)} max${activity.detail ? ` · ${activity.detail}` : ""}`;
   }
 
   /** The spinner's current interval (tests). */

package/src/tui/ui/status.ts

@@ -14,6 +14,7 @@
  */
 import { clipSegs, clipText, segsWidth, splitLine, type Label, type Seg } from "./edge.ts";
 import { displayWidth } from "../width.ts";
+import { formatElapsed } from "./duration.ts";
 
 export interface ContextStatus {
   readonly used: number;
@@ -30,9 +31,13 @@ export interface StatusModel {
   readonly version: string;
   /** `/name`, else the first prompt; null for a session with neither. */
   readonly title: string | null;
-  readonly goal?: { readonly text: string; readonly status: string; readonly execution: string; readonly observations: number; readonly retries: number;
-    /** S.1: one glyph per rung (ran, tests the change, independent, human) and the reading of them, prepared by apps. */
-    readonly ladder?: { readonly glyphs: string; readonly summary: string } };
+  /**
+   * An explicit /goal, prepared by apps from the log (core/goal-view.ts). The
+   * block exists only while a goal is set, and for one message after it is met.
+   */
+  readonly goal?: GoalStatusView;
+  /** Without a goal: the latest check after this request's last edit, when it changed files. */
+  readonly checks?: { readonly status: "unchecked" | "pass" | "fail" | "stale" | "partial"; readonly command?: string; readonly exit?: number };
   readonly workspace: string;
   readonly workspaceShort: string;
   readonly branch: string | null;
@@ -41,7 +46,8 @@ export interface StatusModel {
   readonly activity?: { readonly state: string; readonly label: string; readonly detail: string; readonly queued: number };
   readonly git?: { readonly staged: number; readonly changed: number; readonly untracked: number; readonly conflicted: number; readonly ahead: number; readonly behind: number } | null;
   readonly context?: ContextStatus;
-  readonly usage?: { readonly input: number; readonly output: number; readonly cacheRate: number; readonly cost: string | null };
+  /** `speed`: output tokens per second over this turn's model requests (runtime/usage.ts generationSpeed). */
+  readonly usage?: { readonly input: number; readonly output: number; readonly cacheRate: number; readonly cost: string | null; readonly speed?: number };
   readonly tools: { readonly running: number; readonly done: number; readonly failed: number };
   readonly handoff?: { readonly verified: readonly string[]; readonly inFlight: readonly string[]; readonly unverified: readonly string[] };
   readonly tasks?: readonly { readonly what: string; readonly status: "active" | "blocked" }[];
@@ -51,6 +57,18 @@ export interface StatusModel {
   readonly extension?: string;
 }
 
+export interface GoalStatusView {
+  readonly phase: "drafting" | "working" | "needs_you" | "met" | "stopped";
+  readonly objective: string;
+  readonly elapsedMs: number;
+  readonly checks: readonly { readonly id: string; readonly kind: "command" | "human" | "fresh_check"; readonly status: string; readonly guard?: true; readonly exit?: number }[];
+  /** S.1: one glyph per rung (ran, tests the change, independent, human), prepared by apps. */
+  readonly ladder?: { readonly glyphs: string; readonly summary: string };
+  /** Model requests since the goal was set (from the log) and output tokens this process saw. */
+  readonly requests: number;
+  readonly tokens?: number;
+}
+
 export type Line = readonly Seg[];
 
 /** 1234 → "1.2k", 1234567 → "1.2m". The same compact form everywhere a token count appears. */
@@ -150,6 +168,10 @@ interface Block {
   readonly items: readonly Line[];
   /** A list block with no items is not shown at all. */
   readonly list: boolean;
+  /** Rows shown after the items, kept with the head (the goal's ladder and spend). */
+  readonly tail?: readonly Line[];
+  /** A list shown even without items: a goal being drafted has no checks yet. */
+  readonly keep?: boolean;
 }
 
 /**
@@ -160,12 +182,12 @@ interface Block {
  */
 export function sidebarLines(model: StatusModel, width: number, height: number): Line[] {
   const w = Math.max(1, Math.floor(width)), h = Math.max(0, Math.floor(height));
-  const blocks = sidebarBlocks(model, w).filter(block => !block.list || block.items.length > 0);
+  const blocks = sidebarBlocks(model, w).filter(block => !block.list || block.items.length > 0 || block.keep);
   const plan: { block: Block; rows: number }[] = [];
   let used = 0;
   for (const block of blocks) {
     const minimum = block.list ? Math.min(block.items.length, 2) : 0;
-    const need = (plan.length ? 1 : 0) + block.head.length + minimum;
+    const need = (plan.length ? 1 : 0) + block.head.length + minimum + (block.tail?.length ?? 0);
     if (used + need > h) continue;
     used += need;
     plan.push({ block, rows: minimum });
@@ -185,6 +207,7 @@ export function sidebarLines(model: StatusModel, width: number, height: number):
       out.push(...items.slice(0, entry.rows - 1));
       out.push([{ text: `+${items.length - entry.rows + 1} more`, role: "muted" }]);
     }
+    out.push(...entry.block.tail ?? []);
   });
   return out.slice(0, h).map(line => clipSegs(line, w));
 }
@@ -203,36 +226,37 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
       ...(model.git.conflicted ? [[{ text: `${model.git.conflicted} conflicts`, role: "warning" }] as Line] : []),
       ...(model.git.ahead || model.git.behind ? [[{ text: `↑${model.git.ahead} ↓${model.git.behind}`, role: "muted" }] as Line] : [])] : model.git === null ? [[{ text: "Git unavailable", role: "muted" }] as Line] : []),
   ] });
+  const goal = model.goal;
+  if (goal) blocks.push(goalBlock(goal, w, row));
+  else if (model.checks) blocks.push({ list: false, items: [], head: [checksLine(model.checks, w)] });
   const context = model.context;
-  if (model.goal) blocks.push({ list: false, items: [], head: [
-    [{ text: "Goal", role: "text", bold: true }, { text: ` · ${model.goal.status}`, role: model.goal.status === "verified" || model.goal.status === "checked" ? "success" : model.goal.status === "not_applicable" ? "muted" : "warning" }],
-    ...(model.goal.ladder ? [[{ text: model.goal.ladder.glyphs, role: "text" }] as Line,
-      ...wrap(model.goal.ladder.summary, w, 2).map(text => [{ text, role: "muted" }] as Line)] : []),
-    ...wrap(firstLine(model.goal.text), w, 2).map(text => [{ text, role: "text" }] as Line),
-    [{ text: model.goal.execution, role: "muted" }],
-    [{ text: `${model.goal.observations} observations · ${model.goal.retries} retries`, role: "muted" }],
-    [{ text: "/control · goal, evidence, context", role: "muted" }],
-  ] });
   if (context) {
     const share = contextShare(context), est = context.estimated ? "~" : "";
     const filled = share === undefined ? 0 : Math.max(share > 0 ? 1 : 0, Math.round(share * w));
     const tone = share !== undefined && share >= CONTEXT_WARNING ? "warning" : "accent";
     const shareText = shareSeg(context);
+    // Two budgets, each named: the segment cut (what the bar shows) and the model window. Both shares
+    // ride on the heading, both denominators on one row below the bar.
+    const modelShare = context.window && context.trigger !== null ? `${est}${Math.round(context.used / context.window * 100)}%` : undefined;
+    const segment = context.trigger !== null ? `seg ${est}${compact(context.used)} / ${est}${compact(context.trigger)}` : `${est}${compact(context.used)} · no cut`;
     blocks.push({ list: false, items: [], head: [
-      row([{ text: "Context", role: "text", bold: true }], shareText ? [{ text: context.trigger === null ? "model " : "seg ", role: "muted" }, shareText] : []),
+      row([{ text: "Context", role: "text", bold: true }], [
+        ...(shareText ? [{ text: context.trigger === null ? "model " : "seg ", role: "muted" as const }, shareText] : []),
+        ...(modelShare ? [{ text: ` · model ${modelShare}`, role: "muted" as const }] : [])]),
       ...(share === undefined ? [] : [[{ text: "━".repeat(filled), role: tone }, { text: "─".repeat(Math.max(0, w - filled)), role: "line" }] as Line]),
-      [{ text: `Segment ${est}${compact(context.used)}${context.trigger !== null ? ` / ${est}${compact(context.trigger)}` : " · cut disabled"}`, role: "text" }],
-      [{ text: context.window ? `Model ${est}${compact(context.used)} / ${compact(context.window)} · ${est}${Math.round(context.used / context.window * 100)}%` : "Model window unknown", role: "muted" }],
-      [{ text: `node ${context.segment}`, role: "muted" }],
+      row([{ text: segment, role: "muted" }], [{ text: context.window ? `model ${compact(context.window)}` : "window unknown", role: "muted" }]),
     ] });
   }
   const usage = model.usage, tools = model.tools;
   const toolCount = tools.done + tools.failed + tools.running;
   if (usage || toolCount) {
+    const figures = usage ? [`↑${compact(usage.input)} ↓${compact(usage.output)}`, `cache ${Math.round(usage.cacheRate * 100)}%`,
+      ...(usage.speed !== undefined ? [speedText(usage.speed)] : [])].join(" · ") : "";
+    // Heading with the cost; one row of figures below it. Together they need about 49 columns, more than the 34-42 the sidebar has.
     blocks.push({ list: false, items: [], head: [
       row([{ text: "Usage", role: "text", bold: true }], usage?.cost ? [{ text: usage.cost, role: "text" }] : []),
-      ...(usage ? [[{ text: `↑${compact(usage.input)} ↓${compact(usage.output)}`, role: "text" }, { text: `  cache ${Math.round(usage.cacheRate * 100)}%`, role: "muted" }] as Line] : []),
-      ...(toolCount ? [[
+      ...(figures ? [[{ text: figures, role: "muted" }] as Line] : []),
+      ...(tools.failed || tools.running ? [[
         { text: `${tools.done} done`, role: "muted" },
         ...(tools.failed ? [{ text: " · ", role: "muted" as const }, { text: `${tools.failed} failed`, role: "error" as const }] : []),
         ...(tools.running ? [{ text: " · ", role: "muted" as const }, { text: `${tools.running} running`, role: "accent" as const }] : []),
@@ -270,6 +294,60 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
   return blocks;
 }
 
+/** `42 tok/s`; under 10 one decimal, so a slow upstream does not read as zero. */
+export function speedText(speed: number): string {
+  return `${speed < 10 ? speed.toFixed(1) : Math.round(speed)} tok/s`;
+}
+
+const PHASE: Record<GoalStatusView["phase"], { label: string; role: Seg["role"] }> = {
+  drafting: { label: "drafting", role: "accent" }, working: { label: "working", role: "accent" },
+  needs_you: { label: "needs you", role: "warning" }, met: { label: "met", role: "success" }, stopped: { label: "stopped", role: "warning" },
+};
+
+/**
+ * `Goal · needs you   4m 12s`, the objective, one row per accepted check with
+ * what it needs, the evidence ladder and what the goal has spent. A met goal
+ * is one summary row. The sidebar may cut the checks; a cut ends in "+N more".
+ */
+function goalBlock(goal: GoalStatusView, w: number, row: (left: readonly Seg[], right?: readonly Seg[]) => Line): Block {
+  const phase = PHASE[goal.phase];
+  const passed = goal.checks.filter(check => check.status === "pass" || check.status === "accepted").length;
+  const elapsed = goal.phase === "drafting" ? [] : [{ text: formatElapsed(goal.elapsedMs), role: "muted" as const }];
+  const title = [{ text: "Goal", role: "text" as const, bold: true }, { text: ` · ${phase.label}`, role: phase.role }];
+  if (goal.phase === "met") return { list: false, items: [], head: [row(title, [{ text: `${passed}/${goal.checks.length} · `, role: "muted" }, ...elapsed])] };
+  const items = goal.checks.map(check => {
+    const done = check.status === "pass" || check.status === "accepted";
+    const glyph: Seg = done ? { text: "✓ ", role: "success" } : check.status === "fail" ? { text: "✗ ", role: "error" } : { text: "○ ", role: "muted" };
+    const need = check.kind === "human" && !done ? `/accept ${check.id}` : check.status === "fail" && check.exit !== undefined ? `exit ${check.exit}`
+      : check.status === "stale" ? "rerun" : check.guard ? "guard" : "";
+    return row([glyph, { text: check.id, role: "text" }], need ? [{ text: need, role: check.kind === "human" && !done ? "warning" : "muted" }] : []);
+  });
+  const spent = [`${goal.requests} ${goal.requests === 1 ? "request" : "requests"}`, ...(goal.tokens ? [`${compact(goal.tokens)} tokens this run`] : [])].join(" · ");
+  return { list: true, keep: true, head: [row(title, elapsed), ...wrap(firstLine(goal.objective), w, 2).map(text => [{ text, role: "text" }] as Line)],
+    items, ...(goal.phase === "drafting" ? {} : { tail: [...(goal.ladder ? [[{ text: goal.ladder.glyphs, role: "text" }] as Line] : []), [{ text: spent, role: "muted" }] as Line] }) };
+}
+
+/** Without a goal: whether a check has passed since this request's last edit. */
+function checksLine(checks: NonNullable<StatusModel["checks"]>, w: number): Line {
+  if (checks.status === "unchecked" || !checks.command) return [{ text: "Checks", role: "text", bold: true }, { text: " · not run since last edit", role: "warning" }];
+  // partial: some of a declared contract holds; the rest may only be waiting for the user, so it is not a failure mark.
+  const mark: Seg[] = checks.status === "pass" ? [{ text: " ✓", role: "success" }] : checks.status === "partial" ? []
+    : checks.status === "fail" ? [{ text: " ✗", role: "error" }, ...(checks.exit === undefined ? [] : [{ text: ` exit ${checks.exit}`, role: "muted" as const }])]
+    : [{ text: " stale", role: "warning" }];
+  const room = Math.max(1, w - segsWidth(mark) - "Checks · ".length);
+  return [{ text: "Checks", role: "text", bold: true }, { text: ` · ${clipText(checks.command, room)}`, role: "muted" }, ...mark];
+}
+
+/** Without a sidebar the goal rides on the input box's bottom edge: `goal 2/3 · needs you · 4m 12s`. */
+export function goalLabel(model: StatusModel): Label | undefined {
+  const goal = model.goal;
+  if (!goal) return undefined;
+  const passed = goal.checks.filter(check => check.status === "pass" || check.status === "accepted").length;
+  const parts = [`goal ${goal.phase === "drafting" ? "" : `${passed}/${goal.checks.length} · `}${PHASE[goal.phase].label}`,
+    ...(goal.phase === "drafting" ? [] : [formatElapsed(goal.elapsedMs)])];
+  return { segs: [{ text: parts.join(" · "), role: goal.phase === "needs_you" ? "warning" : "muted" }], priority: 2, min: 8 };
+}
+
 function fileLine(file: FileStatus, w: number): Line {
   const name = file.path.split("/").pop() || file.path;
   const counts: Seg[] = file.edited && (file.added || file.removed)