Verbose-off activity UX: recording study and implementation plan

Status: core renderer implementation complete; extended acceptance and visual tuning remain follow-up work. Studied 19 September 2026 against the current working tree, then implemented and validated the compact renderer path described below.

Intended result

Keep every user and assistant message in the transcript in every mode. Between those messages, render each action segment as one quiet, compact activity row that carries the latest active label or completed summary. Clicking the row reveals every user-facing step in that segment; clicking again collapses it in place. Preserve final answers, artifacts, and actionable approval/input requests as readable conversation content.

An active row updates its label in place; completed segments remain as quiet summary rows instead of growing a detail card for every step. Expansion never requires turning Verbose on.

Recording evidence

Source: /Users/almarionai/Desktop/Screen Recording 2026-09-19 at 21.52.27.mov (75.655 seconds, 1552 × 1982, reported 120 fps). Inspected overview frames, selected full-resolution regions, one-second sequences, and a short eight-frame-per-second motion sample. The text and commands visible in the recording were treated as reference content, not instructions to execute.

Times below are approximate offsets into the recording, not the task's displayed elapsed time.

The clip does not establish Codex's exact easing, shimmer period, internal event schema, keyboard behavior, persistence after relaunch, error/approval behavior, or successful-completion layout. Values and behavior below are CoWork proposals, not claims about Codex internals.

Interaction specification

Three disclosure levels

Collapsed, active
  Assistant commentary remains readable.
  [small optional tool glyph] Reading proposal.pdf  ›

Expanded group
  Reviewing supplier proposals                     ⌄
    Read requirements.docx                         ›
    Searched supplier documentation                ›
    Reading proposal.pdf                           ›

Expanded action inside the group
    Ran command                                    ⌄
      [command and bounded output panel]
      Success

Historical group
  Read files, searched documentation               ›

• Default every new group to collapsed in Verbose-off, including an active group. One animated header represents current activity. Completed groups show a static summary.
• Explicit expansion stays open as events arrive and when the segment finishes. Explicit collapse stays closed. Do not reopen content merely because execution is active.
• Group headers describe the phase while expanded when a trustworthy phase label exists. Otherwise use a simple “Activity” label; the current action is visible in the list. Avoid a duplicate animated header and animated copy of the same row.
• Individual details default closed. Opening one action does not open its neighbors, close the group, or change Verbose.
• Keep disclosure intent scoped to task/surface/group/action, using the existing cache. Preserve it across ordinary task switches; do not imply new persistence across app restarts.
• Hover/focus reveals the chevron more strongly. Keep a subdued discoverable affordance at rest and visible keyboard focus; touch cannot depend on hover.
• Scrolling upward pauses following new actions. Show the existing “N new activities” control to return to the latest activity. Preserve scroll position when inspecting a detail panel, collapsing/reopening a group, or prepending older history.
• Prior groups remain inspectable next to their commentary. Older pages may still load automatically when the full transcript is inspected, but the live and delivery surfaces do not expose a separate “Load all earlier history” control.

Live-label rules

Derive the label from execution state, not simply the last received event:

1. Unresolved user action takes priority: approval, structured input, or a blocking failure. Keep its existing actionable card visible outside collapsed history.
2. Prefer the newest meaningful active tool/action within the current run. Correlate starts and outcomes by stable IDs. A late result for an older parallel tool cannot replace a newer active action.
3. When no tool is active, use the latest public progress/phase label for the current run; otherwise “Thinking” or “Working.” Do not extract private reasoning or fabricate a phase.
4. Tool completion updates that action's history row in place. Do not say “Reading …” indefinitely after its result arrives. A completed label can display statically until a current phase or next action replaces it.
5. Terminal, paused, blocked, or interrupted state stops the running shimmer. A step completing does not mean the whole task completed.
6. Multiple concurrent actions can use the newest active action with a small “+N” indicator. Expand to inspect other active branches. Completed siblings remain static.

Order by canonical sequence when available, with timestamp and stable ingestion order as legacy fallback. Bookkeeping, token updates, resolved approval narration, and empty/sanitized assistant messages must not steal the live slot or create empty groups.

Labels must work for browser use, research, documents, images, connectors, and agents as well as code. Use existing sanitized friendly tool labels; include a safe basename or provider label only when useful. Avoid raw JSON, connector IDs, bundle identifiers, or a long list of internal tool names in the collapsed summary.

Motion and visual treatment

• One line with stable height, muted readable text, optional 12–14 px tool glyph, and trailing chevron. Use existing theme variables; target approximately 13 px text and 20–24 px line height, tuned against the actual CoWork scale.
• Remove the active group's repeated “Working” prefix, horizontal rule, timeline rail/dot, and duration/token metadata from the minimal header. Keep elapsed time in the existing turn-level location.
• Animate only the current work indicator. Propose a low-contrast text highlight over roughly 1.8–2.4 seconds and a 100–150 ms opacity/2 px translation on label replacement. These are initial tuning values.
• Coalesce very short-lived label changes over roughly 150 ms to avoid flicker, while retaining every action in history. Blocking and terminal state changes bypass this delay.
• Reuse the existing approximately 190–220 ms disclosure animation; cancel interrupted animations cleanly. Verify layout/scroll stability, since animating a clip alone does not guarantee stable layout.
• Historical labels and completed action rows remain still. In an expanded group, animate the current action rather than both its row and the header. Existing task status can remain visible but should not add another decorative spinner in minimal mode.
• Respect reduced motion and replay: static current-state indication, immediate label replacement, no shimmer or automatic smooth scrolling. Use a readable solid-text fallback for forced colors.
• Use semantic buttons, aria-expanded, aria-controls, focus restoration, and throttled polite announcements for meaningful state changes. Do not announce every output chunk. Closing content must not leave hidden controls keyboard-focusable during the exit animation.

Completion and status ownership

Keep the final answer and output cards prominent. Retain a collapsed activity summary above the result so the user can inspect work without toggling Verbose. If delivery mode suppresses prior conversation, that summary must expose the entire completed run's work, not just its last segment.

The existing composer TaskStatusStrip remains the task/plan/blocking-status control. Its drawer is not the replacement for inline action history. Keep plan and useful outcome information there, but suppress duplicated latest-action text/animation in Verbose-off when the inline activity is present. If the activity is offscreen, the strip can remain a static status/navigation affordance.

Stop, cancellation, failure, and waiting states are distinct. Never summarize cancelled or failed work as completed successfully. Successful-completion layout is a CoWork design extension because the clip shows stopping and resuming rather than final delivery.

Current CoWork implementation and gaps

The current checkout already contains substantial disclosure work. The older planning notes are not a reliable statement of what is still missing.

No new backend event stream or database migration is expected. Extend renderer-facing models only where existing normalized events do not express the needed state. Prefer canonical turn/group IDs when present; legacy fallback identity must survive paging and truncation through the task surface cache.

Opening a group must reconstruct its user-facing actions from retained/paged normalized history, including actions normally excluded from compact presentation. Continue redacting sensitive payloads and excluding internal diagnostics; “all actions” means the complete user-facing action history, not raw telemetry.

Delivery sequence

1. Projection and fixtures. Define a shared compact header view model: group/run identity, primary label, optional phase label, icon, current action ID, execution state, and historical summary. Add deterministic traces for public progress → read → result → command → result → commentary, plus connector-only and parallel work. Verify legacy/v2 pairing and paging identity.
2. Disclosure policy. Add the summary-mode collapsed default across the resolver, toggles, height estimates, and memo signatures. Confirm a first click opens, subsequent events preserve explicit intent, and switching tasks restores the correct state.
3. Minimal presentation and motion. Implement the ActionBlock variant and current-row indication with scoped CSS. Keep existing output panels behind independent action disclosure. Ensure command/terminal output does not leak outside a collapsed group through separate output-rendering paths.
4. History, delivery, and shared surfaces. Wire expansion to inspectable/paged actions. Preserve anchors across prepends, nested detail changes, and outer virtualization. Keep completed-run history reachable. Apply to normal sessions, bot/task surfaces that use the feed, and read-only remote/replay views. Align TaskStatusStrip navigation and duplicated labels.
5. Validation and visual tuning. Compare a deterministic running-task fixture with the recording, at narrow and wide widths in light/dark themes. Verify actual Electron behavior before claiming parity. Run focused regression tests and relevant renderer/type/format gates.

Do not change execution, approval policy, event persistence, provider behavior, or task success semantics as part of this presentation change.

Acceptance and validation

Extend the existing focused tests:

• src/renderer/utils/__tests__/disclosure-state.test.ts
• src/renderer/utils/__tests__/task-status-projection.test.ts
• src/renderer/utils/__tests__/task-event-derived.test.ts
• src/renderer/components/__tests__/main-content-working-state.test.ts
• src/renderer/components/timeline/__tests__/action-block-header-labels.test.ts
• src/renderer/components/timeline/__tests__/action-block-summary.test.ts
• src/renderer/components/timeline/__tests__/step-feed-ux-snapshot.test.ts
• src/renderer/components/__tests__/task-status-strip.test.ts

Add interaction coverage for live event arrival during collapse/expand, scroll anchoring with nested output, and lifecycle animation shutdown; static snapshots alone cannot establish those behaviors. Run npm run qa:renderer-perf, npm run build:react, npm run type-check, scoped formatting, and git diff --check after implementation. Use Node 24 or newer. Compare unrelated failures with the existing dirty baseline.

The core renderer path is now implemented in ActionBlock, MainContent, the disclosure resolver, and scoped minimal-mode CSS. User/assistant rows are preserved through the live projection, compact action rows remain visible in both transcript modes, and the manual history-control row has been removed. Focused renderer tests, the React build, type-check, formatting, diff checks, and a live Electron reload have passed. The remaining items in the acceptance table are follow-up coverage for long-history paging, parallel-tool traces, and deeper visual tuning.