zidane-ui/session/headless

The blocks shown, in the user's order and at the widths they picked, and the ones they hid.

An equality key for a wire attachment list: type, name, length and both ends of the data (the whole payload would cost tens of ms per change for multi-MB images).

Builds the tree of the changed files: folders before files, both by name, a chain of single-folder folders merged into one row, totals on each folder.

Whether Keep applies: a repeat the agent made, which the backend turns off at expiresAt unless you keep it.

The patches of a session's edits, in order (several edits to one file stay separate entries).

The number of artifacts across groups: the indicator badge.

Creates an ArtifactsState.

Creates a KeyedState.

Creates a PlansState.

Creates a ProviderUsageState. The cadence (when to auto-load) is the reader's: useProviderUsage.

Creates a QueueState.

Creates a RunningWorkState.

Creates a SchedulesState.

Creates a SecretsState.

The session actions over an app's hosts.

Creates an empty SideRequests: one per window.

Creates a UsageSummaryState.

The plan a session shows: the session scope's applying plan, else its most recent stopped one, else the last that closed (read-only). Never a proposal: the Inbox shows those. Sub-agent plans are not shown here.

Changed-line counts for a parsed working-tree file. pierre's FileDiffMetadata.additionLines / deletionLines are the LINE CONTENTS (context included), not counts; rendering them printed file content where the list should show +12 −3. The hunks carry the real + / - counts.

Files in tree order, collapsed folders included.

Number and day helpers of the usage views. The usage card's own words (costs, hours, the comparison line) are zidane's (zidane/chat/pure: formatCost, formatHour, tokenComparison), shared with the usage block.

Groups rendered artifacts by kind, the built-in kinds first, the others alphabetically; rows keep their order.

The entries per path, in first-seen order, with summed counts: the file list on top of the panel.

prefs with block id hidden.

The panels that are blocks, in default order (home.order, then catalog order).

The rows the shown blocks make.

Splits a session's plans into the Inbox's "In progress" and "Recent". Session scope only: sub-agent plans close with their run and are not listed.

Whether a reminder is finished: on, but with no next time (a one-off that was sent).

Enough of the shape to render without throwing; anything else is dropped.

Local YYYY-MM-DD for a Date. Matches SQLite's date(…, 'localtime') buckets the backend aggregates by, or streak math drifts at midnight.

prefs with block id moved delta places among the shown blocks.

Every project's arrangement from its stored form; undefined for anything unrecognised.

Reads /side with an optional question: the question ('' for none), or null for any other prompt.

The summary to show for range: its own, or while it loads another range's (the one on screen, else any).

prefs with block id moved to the place of block target among the shown blocks (a drop on that card): before it when coming from below, after it when coming from above.

A plain row for a stored artifact: its label as the title, a web URI as the link. For a backend that answers stored artifacts without rendering them.

A plan's steps per status, as the tally chips show them.

Reads the Reminders form's time field (in 20m, tomorrow 9:00, weekdays 9:00, cron "0 9 * * 1-5") in the client's time zone. The prompt has its own field, so words after the time are refused.

key relative to root when inside it; untouched otherwise.

The composer badge's summary of a session's schedules. null when none will fire.

Same items, in the same order and states: the list on screen stays.

The session actions as key commands on the session on show (sessionGenerateTitle, sessionCompact, sessionExportMarkdown, sessionExportJson, sessionDelete, sessionCopyId, sessionFavorite). None without a session; no favorite on the main session.

prefs with one control of block id set.

prefs with block id at width.

prefs with block id shown (added, or hidden and shown again), after every shown block.

Schedules as the Reminders panel lists them: the ones that will fire, soonest first, then the rest, newest first.

Secrets by name, as the panel lists them.

Staged attachments → wire attachments. An entry whose data URL can't be parsed is dropped.

The queue rows of a session's entries.

The schedules that will fire, soonest first: on, with a next time.

The rows on screen: a collapsed folder hides what is below it.

Wire attachments → staged ones. size comes from the base64 length; name falls back to '' so the round trip keeps attachmentsKey stable.

The default English strings of the session panels. Override any of them through SessionProvider.

Nothing arranged yet.

The ranges, in the order a range switcher shows them.

The default storage key of the usage snapshot.

The one-line summary the composer pill and the TUI footer show.

The artifact groups of every session a host has seen.

One changed file, as a diff source lists it.

A folder row of the tree.

A file row of the tree.

A block of the home.

What the home needs of a panel summary.

How the user arranged one project's home.

A session's plans as the Inbox shows them.

A map of values whose keys each have a readable store.

What a window shows of a session's plans.

The plan snapshots of every session a host has seen.

One step of a plan; the todo item the agent tracks.

The plan a session shows as "in progress", with a display-only liveness flag.

Attachment carried alongside the prompt text (base64, no data-URL prefix).

One banked reset.

What redeeming a banked reset did. reset: the windows were emptied; nothing_to_reset: no window had usage, so nothing was spent; no_credit: no reset left; already_redeemed: this request was already applied; failed: the request failed (error says why), possibly before reaching the provider.

Which account a banked reset is spent on: a snapshot's provider and credential.

Usage of one credential of a provider, as probed at one moment.

The backend calls a ProviderUsageState makes.

One cache of subscription usage, shared by every reader.

What the subscription-usage readers see.

What goes with a message added to the queue.

The backend calls the queue state makes.

An attachment on a queued prompt, without its bytes.

One message waiting in a session's queue, as the queue panel shows it.

The queues of every session a host has seen.

What the composer's Reminders badge shows: how many will fire, and the soonest time.

Parent-level cancellable tool call or background task.

The running work of every session a host has seen.

A stored schedule.

One fire of a schedule, newest first in schedules.fires.

What schedules.create takes.

What schedules.update takes: the fields to change. expiresAt: null keeps a schedule for good (you pinned it).

What a SchedulesState reads from the backend.

The reminders a host holds, as stores.

Whether reminders are on (Settings.schedules) and whether the backend's store keeps them (zidane's schedules.status).

The secret lists of every session a host has read.

The session actions; each one present only when its capability is.

What the session actions run over. Each member left out removes the actions that need it.

The session an action runs on: what the actions read off its row.

A recorded output of a session, such as a pull request, a branch, a commit or a file.

A session's artifacts of one kind.

One artifact and its rendered row.

An artifact's row, rendered by the backend (the kind registry lives there).

What a session produced: pull requests, branches, commits, files, extension kinds.

What confirm is asked before a delete.

The session details dialog's actions on one session.

One edit the agent made, as a patch.

A transcript event as the Diffs panel reads it: a tool event may carry the edit it made.

The session panels' host. Every member is optional: what a host leaves out is not shown.

A session's plans: the one the agent applies, the ones that stopped or closed.

A session's type-ahead queue: messages sent while the agent works, delivered when the run ends.

A session's cancellable work: parent-level tool calls and background tasks.

Reminders (zidane's schedules): prompts sent to a session at a set time, once or on a repeat. The Reminders panel and the composer badge. Every action rejects with the backend's reason (the feature is off, a refused input).

What a secret saved by hand takes: its name, its value, how long it stays.

The saved secrets of a session's project (Settings.secrets): the Secrets panel. Values go in, never out: the entries carry names and expiry times only. The backend lists none while the setting is off.

/side chats: a hidden session about another one (never listed, deleted with it), running read-only tools that read the parent, while the parent's own run streams.

One persisted turn of a session: a user prompt, an assistant response, or a system or command entry.

A session's stored turns: what the turn details dialog reads and does.

Usage: spend summaries and the providers' subscription windows.

A session's side chat (null until the first send creates it) and the session's own row.

A session row as the side chat needs it: its id; the app's pickers read the rest.

The /side hand-over between a composer and the side chat.

An attachment staged in the queue editor.

One item of a todowrite call.

One heatmap cell. Sparse: days without activity are left out.

One stacked-bar segment of the models chart: a model's tokens on a day.

Per-model usage over the summary's range. tokensIn counts prompt input plus cache reads and writes; cost is USD.

Spend per provider.

Usage and spend over a range. The heatmap always spans the last ~26 weeks.

The usage summaries a host keeps.

Options for createUsageSummaryState.

A row of the Diffs file tree: a folder or a file.

A row of the home: one full block, or two half blocks.

Stops or drops a plan.

A user edit to a plan's steps.

How the backend delivered a message added to the queue.

How the backend delivered a queued message pushed into the run now (missing: the entry was gone).

The time words of the Reminders form, read: a trigger, or why not.

The names onError reports.

A session's recent requests and their prompt-cache numbers (zidane's CacheReport).

The export formats of a transcript.

The shape of the session label dictionary. Some values are functions that build a string.

One saved secret of a session's project, without its value: name, save time, expiry, the session that saved it.

Why a /side cannot open: no conversation yet, a host without side chats there, no side panel to open.

Steps per status.

The time window of a usage summary.

The summaries held, by range.