@@ -193,7 +193,7 @@ export const Footer = Schema.Struct({
   ),
   time: footerElement(
     [
-      "When an entry happened: the time of day if today, the date and time otherwise.",
+      "When an entry happened: the time of day if today, the date and time otherwise. A running tool call shows when it started.",
       "Applies to: user (prompt sent), assistant (turn finished, in its footer), text (text block finished, below it),",
       "reasoning (thinking block finished), tool (every tool call, plugin and MCP tools included, when it finished),",
       "error (turn failed, in its error box),",
@@ -205,7 +205,7 @@ export const Footer = Schema.Struct({
   duration: footerElement(
     [
       "How long an entry took. Applies to: assistant (the turn's own message), reasoning (the thinking block),",
-      "tool (every tool call).",
+      "tool (every tool call: while it runs, a stopwatch in whole seconds; once finished, tenths of a second up to 11 minutes).",
       "Default: reasoning; turns follow /turn-durations (turn_timing.duration); tool calls when the legacy",
       "timestamps list includes 'tool'.",
     ].join(" "),
 
@@ -102,6 +102,7 @@ import { usePathFormatter } from "../../context/path-format"
 import { LocationProvider } from "../../context/location"
 import { TuiLayout } from "../../layout"
 import { cellText, idUnder, markOwnIds } from "../../ui/id-click"
+import { secondTicker } from "../../util/ticker"
 import { onClick } from "../../ui/click"
 import { DialogModel } from "../../component/dialog-model"
 
@@ -1740,7 +1741,11 @@ function UserMessage(props: {
               </box>
             </Show>
             <Show when={metadataVisible()}>
-              <text ref={markOwnIds} fg={theme.textMuted}>
+              <text
+                ref={markOwnIds}
+                marginTop={userFooterGap(text(), files().length, time() || messageID()) ? 1 : 0}
+                fg={theme.textMuted}
+              >
                 <Show
                   when={queued()}
                   fallback={
@@ -2356,6 +2361,13 @@ export function InlineToolRow(props: {
       <Switch>
         <Match when={props.spinner}>
           <Spinner color={props.color} children={props.children} />
+          <Show when={props.timestamp}>
+            <box paddingLeft={INLINE_TOOL_ICON_WIDTH}>
+              <text ref={markOwnIds} fg={props.timestampColor}>
+                {props.timestamp}
+              </text>
+            </box>
+          </Show>
         </Match>
         <Match when={true}>
           <Show
@@ -2751,11 +2763,13 @@ function toolFooter(ctx: ReturnType<typeof use>, part: ToolPart) {
   const messageID = TuiConfig.toolFooterShowsMessageID((type) =>
     type === "tool" ? shows("message_id") : ctx.footer("message_id", "assistant", part.messageID),
   )
+  const duration = shows("duration")
   return {
     time: shows("time"),
-    duration: shows("duration"),
+    duration,
     messageID: messageID ? part.messageID : undefined,
     format: ctx.tui.datetime_format,
+    now: duration && part.state.status === "running" ? secondTicker.watch() : undefined,
   }
 }
 
@@ -2764,20 +2778,42 @@ function expandHint(overflow: boolean, expanded: boolean) {
   return expanded ? "Click to collapse" : "Click to expand"
 }
 
+// A running call shows when it started and a whole-second stopwatch up to `now`; a finished one
+// when it ended and how long it ran.
 export function formatToolTimestamp(
   state: ToolPart["state"],
-  show: { time: boolean; duration: boolean; messageID?: string; format?: Locale.DateTimeFormat } = {
+  show: {
+    time: boolean
+    duration: boolean
+    messageID?: string
+    format?: Locale.DateTimeFormat
+    now?: number
+  } = {
     time: true,
     duration: true,
   },
 ) {
-  if (state.status !== "completed" && state.status !== "error") return
-  const details = [
-    show.time && Locale.todayTimeOrDateFirst(state.time.end, show.format),
-    show.duration && Locale.duration(Math.max(0, state.time.end - state.time.start)),
-    show.messageID,
-  ].flatMap((detail) => (detail ? [detail] : []))
-  return details.length ? details.join(" · ") : undefined
+  if (state.status === "pending") return
+  const running = state.status === "running"
+  const details = running
+    ? [
+        show.time && Locale.todayTimeOrDateFirst(state.time.start, show.format),
+        show.duration && show.now !== undefined && Locale.stopwatch(show.now - state.time.start),
+        show.messageID,
+      ]
+    : [
+        show.time && Locale.todayTimeOrDateFirst(state.time.end, show.format),
+        show.duration && Locale.duration(Math.max(0, state.time.end - state.time.start), true),
+        show.messageID,
+      ]
+  const shown = details.flatMap((detail) => (detail ? [detail] : []))
+  return shown.length ? shown.join(" · ") : undefined
+}
+
+// A prompt's footer (time, message ID) sits one blank line below its text, unless the file chips
+// already pad it or the text itself ends in a blank line.
+export function userFooterGap(text: string, files: number, footer: boolean) {
+  return footer && files === 0 && !/\n[ \t]*$/.test(text)
 }
 
 export function formatSubagentToolcalls(count: number) {
 
@@ -79,13 +79,18 @@ export function number(num: number): string {
   return num.toString()
 }
 
-export function duration(input: number) {
+// `tenths` keeps the tenth of a second past the first minute, up to 11 minutes: `2m 5.3s`.
+export function duration(input: number, tenths = false) {
   if (input < 1000) {
     return `${input}ms`
   }
   if (input < 60000) {
     return `${(input / 1000).toFixed(1)}s`
   }
+  if (tenths && input < 660000) {
+    const minutes = Math.floor(input / 60000)
+    return `${minutes}m ${(Math.floor((input % 60000) / 100) / 10).toFixed(1)}s`
+  }
   if (input < 3600000) {
     const minutes = Math.floor(input / 60000)
     const seconds = Math.floor((input % 60000) / 1000)
@@ -101,6 +106,12 @@ export function duration(input: number) {
   return `${days}d ${hours}h`
 }
 
+// Elapsed time of something still running, in whole seconds: `0s`, `37s`, `2m 5s`.
+export function stopwatch(input: number) {
+  if (input < 60000) return `${Math.floor(Math.max(0, input) / 1000)}s`
+  return duration(input)
+}
+
 export function truncate(str: string, len: number): string {
   if (str.length <= len) return str
   return str.slice(0, len - 1) + "…"
 
@@ -0,0 +1,41 @@
+import { createSignal, getOwner, onCleanup } from "solid-js"
+
+// One clock shared by everything that ticks at the same interval. It runs only while something
+// holds it: the interval stops itself on the first tick after the last holder lets go, so a
+// holder released and re-taken in the same update (a memo re-running) does not restart it.
+export function createTicker(interval: number) {
+  const [now, setNow] = createSignal(Date.now())
+  let holders = 0
+  let timer: ReturnType<typeof setInterval> | undefined
+
+  const hold = () => {
+    holders++
+    if (!timer) {
+      setNow(Date.now())
+      timer = setInterval(() => {
+        if (holders > 0) return setNow(Date.now())
+        clearInterval(timer)
+        timer = undefined
+      }, interval)
+    }
+    let held = true
+    return () => {
+      if (!held) return
+      held = false
+      holders--
+    }
+  }
+
+  return {
+    now,
+    hold,
+    running: () => timer !== undefined,
+    // The current time, held until the calling computation re-runs or is disposed.
+    watch() {
+      if (getOwner()) onCleanup(hold())
+      return now()
+    },
+  }
+}
+
+export const secondTicker = createTicker(1000)
@@ -8,6 +8,7 @@ import {
   formatSubagentTitle,
   formatSubagentToolcalls,
   formatToolTimestamp,
+  userFooterGap,
   InlineToolRow,
   parseApplyPatchFiles,
   parseDiagnostics,
@@ -268,14 +269,37 @@ describe("TUI inline tool wrapping", () => {
     expect(lines).toContain("1:07 PM · 1.2s")
   })
 
+  test("formats a running tool call's start time and whole-second stopwatch", () => {
+    const start = new Date()
+    start.setHours(16, 25, 29, 0)
+    const state = { status: "running" as const, input: {}, time: { start: start.getTime() } }
+    const time = Locale.todayTimeOrDateFirst(start.getTime())
+    expect(formatToolTimestamp(state, { time: true, duration: true, now: start.getTime() + 37_600 })).toBe(
+      `${time} · 37s`,
+    )
+    expect(formatToolTimestamp(state, { time: true, duration: true, now: start.getTime() + 125_000 })).toBe(
+      `${time} · 2m 5s`,
+    )
+    expect(formatToolTimestamp(state, { time: false, duration: false })).toBeUndefined()
+    expect(formatToolTimestamp({ status: "pending", input: {}, raw: "" })).toBeUndefined()
+  })
+
+  test("a prompt's footer sits one blank line below its text", () => {
+    expect(userFooterGap("hello", 0, true)).toBe(true)
+    expect(userFooterGap("hello\n", 0, true)).toBe(false)
+    expect(userFooterGap("hello\n  ", 0, true)).toBe(false)
+    expect(userFooterGap("hello", 1, true)).toBe(false)
+    expect(userFooterGap("hello", 0, false)).toBe(false)
+  })
+
   test("formats a finished tool call's end time and duration", () => {
     const end = new Date()
     end.setHours(13, 7, 0, 0)
     const start = end.getTime() - 1234
     const input = {}
     const time = Locale.todayTimeOrDateFirst(end.getTime())
     expect(formatToolTimestamp({ status: "pending", input, raw: "" })).toBeUndefined()
-    expect(formatToolTimestamp({ status: "running", input, time: { start } })).toBeUndefined()
+    expect(formatToolTimestamp({ status: "running", input, time: { start } })).toBe(Locale.todayTimeOrDateFirst(start))
     expect(
       formatToolTimestamp({
         status: "completed",
 
@@ -41,3 +41,19 @@ test("an unset datetime_format part keeps the locale output", () => {
   )
   expect(Locale.date(yesterday, { time: "HH" })).toBe(new Date(yesterday).toLocaleDateString())
 })
+
+test("a stopwatch shows whole seconds while running", () => {
+  expect(Locale.stopwatch(0)).toBe("0s")
+  expect(Locale.stopwatch(999)).toBe("0s")
+  expect(Locale.stopwatch(37_900)).toBe("37s")
+  expect(Locale.stopwatch(125_400)).toBe("2m 5s")
+  expect(Locale.stopwatch(-50)).toBe("0s")
+})
+
+test("a finished duration keeps one decimal up to 11 minutes", () => {
+  expect(Locale.duration(4_830, true)).toBe("4.8s")
+  expect(Locale.duration(125_370, true)).toBe("2m 5.3s")
+  expect(Locale.duration(659_990, true)).toBe("10m 59.9s")
+  expect(Locale.duration(660_000, true)).toBe("11m 0s")
+  expect(Locale.duration(125_370)).toBe("2m 5s")
+})
@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test"
+import { createMemo, createRoot, createSignal } from "solid-js"
+import { createTicker } from "../../src/util/ticker"
+
+test("the ticker runs only while held and stops on the first tick after release", async () => {
+  const ticker = createTicker(10)
+  expect(ticker.running()).toBe(false)
+  const release = ticker.hold()
+  expect(ticker.running()).toBe(true)
+  const start = ticker.now()
+  await Bun.sleep(40)
+  expect(ticker.now()).toBeGreaterThan(start)
+  release()
+  release()
+  expect(ticker.running()).toBe(true)
+  await Bun.sleep(30)
+  expect(ticker.running()).toBe(false)
+})
+
+test("one ticker serves every watcher and stops once none is left", async () => {
+  const ticker = createTicker(10)
+  const [running, setRunning] = createSignal(true)
+  const dispose = createRoot((dispose) => {
+    createMemo(() => (running() ? ticker.watch() : undefined))
+    createMemo(() => ticker.watch())
+    return dispose
+  })
+  await Bun.sleep(30)
+  expect(ticker.running()).toBe(true)
+  setRunning(false)
+  await Bun.sleep(30)
+  expect(ticker.running()).toBe(true)
+  dispose()
+  await Bun.sleep(30)
+  expect(ticker.running()).toBe(false)
+})
@@ -506,6 +506,10 @@ A type a key does not apply to has no effect, so `"all"` and `"important"` selec
 
 Each message ID appears once. A tool call belongs to its assistant message, so the tool call shows the message's ID only when the message's own footer does not: with `"message_id": "tool"`, or when `"important"` leaves that step's footer out. With `"all"`, the ID is in the assistant footer and the tool calls show only their time and duration.
 
+While a tool call runs, its footer shows when it started and a stopwatch that ticks every second in whole seconds: `16:25:29 · 37s`, `16:25:29 · 2m 5s`. Once it finishes, the footer shows when it finished and how long it ran, with tenths of a second up to 11 minutes: `4.8s`, `2m 5.3s`, then `11m 0s`. One clock drives every running call, and it stops when none is running.
+
+A prompt's footer sits one blank line below the prompt's text, unless the text already ends with a blank line or file chips sit between them.
+
 ```json title="tui.json"
 {
   "footer": {
Original file line number	Diff line number	Diff line change
@@ -506,6 +506,10 @@ A type a key does not apply to has no effect, so `"all"` and `"important"` selec
`506`	`506`
`507`	`507`	Each message ID appears once. A tool call belongs to its assistant message, so the tool call shows the message's ID only when the message's own footer does not: with `"message_id": "tool"`, or when `"important"` leaves that step's footer out. With `"all"`, the ID is in the assistant footer and the tool calls show only their time and duration.
`508`	`508`
	`509`	+While a tool call runs, its footer shows when it started and a stopwatch that ticks every second in whole seconds: `16:25:29 · 37s`, `16:25:29 · 2m 5s`. Once it finishes, the footer shows when it finished and how long it ran, with tenths of a second up to 11 minutes: `4.8s`, `2m 5.3s`, then `11m 0s`. One clock drives every running call, and it stops when none is running.
	`510`	`+`
	`511`	`+A prompt's footer sits one blank line below the prompt's text, unless the text already ends with a blank line or file chips sit between them.`
	`512`	`+`
`509`	`513`	```json title="tui.json"
`510`	`514`	`{`
`511`	`515`	`"footer": {`