qcontrol New Pages

c90 assembled the Phase-1 mocks (Teams, Users & Devices · User Details · Team Details · Sessions · Session Details · Device Details) behind a shell that mimics qdash — explicitly "the last mocking step before integration with the real app." c88 shipped the v2 Filter/FilterTriggerBar and c91 DataMachine, both released in q-nuxt-layer 0.9.13 on 2026-09-18, so the layer side is ready. The gap is the app side: qdash's live /teams predates all of this, its filter story is hand-rolled chips per page, and the design page speaks a fixture world (Okta/Jamf denominators, accounts) qdash's backend doesn't serve.

1. Phase 1: qcontrol/crates/qdash/ui/app/pages/teams.vue rewritten in place as the c90 combined page on real data — rollups in lib/people-rollups.ts (vitest), projected badges where the denominator isn't served, inline team assignment kept in the Users expand row.
2. Phase 2 (concurrent): a shell-owned global filter in qdash (useGlobalFilter + GlobalFilterBar in layouts/default.vue) with URL as source of truth, follow-across-pages persistence, lazy suggestions and two-way FilterTriggerBar sync — replicating app.qpoint.io's seven filter behaviours in qdash idioms; layer fixes shipped as 0.9.14.
3. Phase 3: User Details, Team Details, Sessions, Session Details, Device Details ported, each as its own thread with a ruling on the existing /inventory/* pages they overlap.
4. actor-listings: every actor listing under /inventory/* (Models, MCP Servers, Tools, Workspaces, Harnesses, Machines, Agents, Sessions, fleet index) registers with the global filter and gets a three-DataMachine overview — no other overview component — with numbers that cross-foot with the filtered table. Plan: actor-listings-plan.md.
5. surface-section: "Surface" (what an actor touches) componentized — DataSurfaceSection chrome in the layer, <SurfaceSection> composition in qdash over a scoped /api/surface — and placed on every actor detail page. Plan: surface-section-plan.md.
6. working-nav: a "Working" toggle in the qdash sidebar footer (above Experimental) reveals a WORKING section listing every listing page and every detail page a listing jumps to — detail links resolve a real example id so they open populated pages — italic via a nav-working hook class. Plan: working-nav-plan.md.
7. people-pages: /teams sliced into three presentational components (TeamsOverview, UsersOverview, DevicesOverview; rows in, events out — the rollups stay the only code that knows /api/*, so the data source is swappable for the front site), the combined page renamed /teams-users-devices, and solo /teams, /users, /devices pages composed from them; whether all four survive is a team discussion. Plan: people-pages-plan.md.
8. listing-viz: every listing page's three-DataMachine band gets one visual device per card — segment bars for compositions, ranked bars for concentration, a donut only where both slices are named things, a history graph on Sessions (the one listing with a real time axis) — all derived from the filtered rows through the bands libraries; a DataSegmentBar primitive lands in the layer (0.9.16) with DataMachine presets and a Listing overview band pattern on the design site; the fleet index's projected sparks retire. Plan: listing-viz-plan.md.
9. timeframe-always: the global filter starts with a timeframe pill already and always in place — the layer's v2 bar renders a non-removable when: column (a FilterItem with removable=false, last before Config), qdash owns one shell-level ?period= defaulting to 7d (omitted from the URL, persisted across pages), and every listing endpoint honours it server-side through the backend's existing universal-scope helpers so bands and columns are in-window, not decorative. Plan: timeframe-always-plan.md.
10. detail-pages: the six old-style actor detail pages — Harness, Machine, MCP Server, Model, Tool, Workspace — rebuilt on the frame the three model pages (Agent Detail, Session Detail, User Detail v3) already use: combined identity header → elsewhere links → DataMachine band → jump pills → ledgers → Surface → "More detail" rule. Purpose-and-value guide: detail-pages-guide.md; plan: detail-pages-plan.md.
11. day-series: one /api/history endpoint (per-axis and per-scope daily runs · calls · denied · tokens · cost, the surface scope grammar, timeframe-always's window anchor) puts an honest trend on every listing — a history row under the band and a trend column in the table — and a History section on every actor detail page; reconciles the listing bands to the served judged/ok/failed and tokens = input + output + reasoning fields; lifts RankedBars into the layer as DataRankedBars with a stacked layout; adds a concurrent-threads rule to the canonical cycle-manager. Sequenced after timeframe-always and detail-pages. Plan: day-series-plan.md.

• Design repo: cycles/c92.qcontrol-new-pages/ (this record, plan.md, global-filter-plan.md, per-thread <thread>-prompt.md/-plan.md — actor-listings, surface-section, session-details, working-nav, people-pages, listing-viz, timeframe-always, detail-pages (+ detail-pages-guide.md), day-series, session-header (prompt only — executed directly), skill-definition (research + four lo-fi wireframes under app/pages/pages/phase1/skill-definition-wf*.vue, fixtures app/data/skill-definition-fixtures.ts, helpers app/components/phase1/SkillDef*.vue, the combined wf5, and the mockup app/pages/qcontrol/skill.vue + server/api/skill-definition/body.get.ts)); source mocks under app/pages/qcontrol/ are read, not modified (except user-v3.vue adopting DataSurfaceSection and teams.vue flipping to the timeframe pill); design-site documentation of every layer addition (demos, registry entries, the Listing Overview Band and Actor Detail Frame patterns); the visual record — public/cycles/design/c92-* captures via scripts/shot-programs/c92-qdash.json + single-route shots, three archive entries under content/archive/2026-q3/.
• qcontrol repo (feat/new-pages, never main): crates/qdash/ui/app/{pages/teams.vue → teams-users-devices.vue, pages/{teams,users,devices}.vue, components/{Teams,Users,Devices}Overview.vue, lib/people-rollups.ts, lib/people-sample.ts, lib/working-nav.ts, composables/useWorkingNav.ts, lib/filter-query.ts, lib/filter-keys.ts, composables/useGlobalFilter.ts, components/GlobalFilterBar.vue, layouts/default.vue, components/AppSidebar.vue}; every pages/inventory/*/index.vue (bands via lib/actor-bands.ts) and detail.vue (bands via lib/detail-bands.ts, chips via lib/entity-chip.ts, components/surface/Section.vue + lib/surface-rollups.ts, lib/session-transcript.ts, components/RankedBars.vue as a one-release shim); cycles/c15.* twin record; dist/ regenerated at PR time (and after each session-header follow-up).
• q-nuxt-layer: components/filter/* fixes (finish the sticky/stuck prototype in the component, tokens, endcaps) → release 0.9.14; FilterKeyDefinition.formatVal + DataSurfaceSection → 0.9.15; DataSegmentBar + shared data/palette.js + DataMachine presets → 0.9.16; FilterItem.removable + the always-visible timeframe column in Filter + ActorHeader / ActorHeaderCell → 0.9.17; DataMachine showFullNumber + AgentAvatar size → 0.9.18; DataRankedBars (inline / stacked) → 0.9.19, rows keyed by index + label → 0.9.20 (what qdash and every consumer pin).
• qcontrol backend: one endpoint, /api/surface?<scope>=, generalizing the agent-detail surface builder (the surface-section thread's strictly-necessary change), later gaining a policy block per scope (detail-pages) and a ?run= scope (session-header); session_detail_value serving the event grain through normalize::redact_text (session-details); ?period= on every listing endpoint under one fleet_anchor with cutoff_pred replacing time_pred, plus a tool_calls(run_id) index (timeframe-always — the plan's time_pred/window_cutoff reuse turned out wrong, see Key Changes); correlated_agents both maps, tools.judged/ok/failed, models.reasoning_tokens (detail-pages); /api/history still planned (day-series §B); /api/providers and /api/skills (+ provider / skill surface scopes) and the seed's installation.details emission (providers-skills).
• Out: backend changes beyond what phase 1 proves necessary; identity/MDM integrations; FilterManage v2 design; migrating existing qdash pages (Findings/Inventory/Sessions/Cost) onto the global filter — they render the disabled bar until their own threads.

skill-definition wireframed (2026-09-23, phase 3 — Skill detail's missing object): Mark's ask ("we need to show the actual skill definition … research typical skill definitions … handle multi-file skills … a preview of the raw skill … start by mocking up a few options in the design project via the bob-wire wireframing skill" — skill-definition-prompt.md). Research (skill-definition-plan.md §1): every harness reads the agentskills.io standard — a directory with SKILL.md (YAML frontmatter + Markdown body) plus optional scripts/ · references/ · assets/, disclosed in three tiers (name + description always ≈100 tokens; body on trigger, <500 lines guidance; supporting files on demand by relative path); per-harness paths (.agents/skills is now cross-vendor), Codex's agents/openai.yaml sidecar, three spellings of the invocation policy, and load-time !`cmd` shell as the security-relevant construct. Most skills are one file; the multi-file ones are dominated by scripts (docx: 91 lines of prose over ~40 script files). What qcontrol has: SkillDetail { name, description } from Claude Code's user-scope skills/ only — the plan's §2 lists the six inspector/endpoint additions in cost order, and names the grain question every option must answer (the page keys on a name; definitions live per install and drift → group carrying installs by SKILL.md hash, elect a canonical). Four lo-fi wireframes on the design site under /pages/phase1/skill-definition-wf1…wf4 (registry collapse c92-skill-definition, listed on the Phase 1 index as "New — not yet in Linear"), each keeping the built Skill detail chassis (Phase1SkillDefFrame: actor header · band · jump pills · shipped sections collapsed) and a fixture switch across pdf (12 files, 3 fleet variants) / capture (single file) / deploy (Codex + a curl script) from app/data/skill-definition-fixtures.ts: WF1 Dossier (frontmatter fact grid + rendered body with Rendered ⇄ Raw, Bundle ledger with preview drawers), WF2 Bundle Browser (two-pane file tree + raw preview with an evidence header), WF3 Load Order (the three disclosure tiers as sections, invocation controls with defaults spelled out, a Reach strip), WF4 Fleet Variants (Definitions band + hash ledger + frontmatter comparison + the picked variant raw with drift shaded). Two lo-fi helpers (Phase1SkillDefRaw, Phase1SkillDefProse) — wireframe-only, not layer candidates. Recommendation (plan §4, a default): WF4's band only when definitions > 1, WF1's Definition + Bundle as the body with WF3's tier labels as captions and WF2's evidence header inside the drawers. Verified headless (/tmp/c92/skill-def/verify.mjs): 4 routes SSR 200, 15 screenshots across fixtures and interactions, 0 console errors. Note: the design dev server on :3000 was found wedged (vite-node "IPC connection closed" on every route, pre-existing) and restarted detached — the one state change outside the repo. Not done: any qdash/inspector change; captures into public/cycles/; a Linear note on PRO-30. Combined + mocked (2026-09-23, same day, Mark: "let's try combining them as you recommend. Then build a details page mockup based on our details pages and using our existing q-nuxt-layer components wherever possible"): WF5 /pages/phase1/skill-definition-wf5-combined draws the §4 recommendation (the frame gained a v-model for the fixture so a page can read it in its own scope); then /qcontrol/skill?skill=pdf|capture|deploy (app/pages/qcontrol/skill.vue, registry qcontrol-skill) — WF5 on the real actor frame, section for section with qdash's inventory/skills/detail.vue, every device the layer's (ActorHeader/ActorHeaderCell, DataMachine, NavJumpPills, DataSegmentBar, DataTable with a #details drawer, UxTabGroup, UxCodeBlock, UxPill, AgentAvatar, DataSurfaceSection/DataSurfacePanel, MDCRenderer); plan §5 has the anatomy. Found: the MDC parser can't run in this project's client bundle and python fences hit a highlight route the site doesn't serve — the body parses in server/api/skill-definition/body.get.ts (the cycles pages' recipe) and the Rendered/Raw panes are v-show. Verified headless: three fixtures SSR 200, drift pick swaps the rendered body and the raw frontmatter, Rendered survives the toggle, 0 console errors (/tmp/c92/skill-def/verify-m1.mjs, mdc-probe3.mjs). Not done: commit; captures into public/cycles/; qdash. Wording (Mark, same day): "Sessions on carrying installs" → Sessions (caveat into the provenance line and ledger caption), "Configured on" → Installs (cell, tile, ledger, pill), "behind the carrying installs" → "who own those installs", and carrying swept out of every visible string on the mockup and the shared wireframe frame — plan §5a; proposals for the qdash page, not applied there. Built in qcontrol (2026-09-23, Mark: "let's build the page in ../qcontrol now"; skill-definition-build-prompt.md / -build-plan.md, twin qdash cycles/c15 §skill-definition): the whole path, bottom up — SkillDetail grows the definition (frontmatter verbatim, capped body, sha256, mtime, bundle inventory; additive, make schemas, CHANGELOG pending), the Claude inspector captures it (+3 tests), qdash gains the additive install_skill_definitions table with the body redacted on ingest, /api/skills?skill= serves definitions[] grouped by hash with canonical election and a structured delta (+1 test, 426 pass), the seed emits real definitions with one drifted install, and inventory/skills/detail.vue is rebuilt on the mockup with the wording rulings and the box last (lib/skill-markdown.ts + skillBand.definitions + definitionDelta, vitest 329). Bundle rows have no preview drawer — contents aren't captured, the page says so. Headless on an isolated :7882/:3032 stack: 24/24, console clean. Left for Mark: commit; regenerate the live seed and restart :7879/:7880; dist.

kick-off (2026-09-18): Research and plan, no code. Located the real target (qdash UI, not app.qpoint.io), verified layer 0.9.13 is installed there with every component the page needs, mapped the fixture world → /api/* gap (the problem's shape is data, not components), read app.qpoint.io's filter end to end (layouts/global.vue teleport, URL-computed filters, query-string store persistence, lazy requestValSuggestions, useTrafficFilters consumption) and restated it for qdash. Four decisions taken with Mark: rewrite /teams in place · projected badges for unserved denominators · replicate the global filter shell-wide · keep team assignment in the expand row. See plan.md, global-filter-plan.md.

phase 1 + 2 (2026-09-18): Executed plan.md end to end on qcontrol feat/new-pages (twin record: qcontrol/crates/qdash/ui/cycles/c15.teams-users-devices-port/CYCLE.md). Layer: finished the sticky/stuck prototype in filter/index.vue — the component owns pinning (stickyTop prop, _stuck class + stuck emit, bg-surface-sunken backing), filter v2 hex → tokens; released as q-nuxt-layer 0.9.14. qdash: lib/filter-query.ts (URL grammar, 14 specs), lib/filter-keys.ts, composables/useGlobalFilter.ts (singleton, URL as truth, localStorage follow-across-pages, ready gating), components/GlobalFilterBar.vue mounted once in layouts/default.vue; lib/people-rollups.ts (16 specs: person/device/team rows on real /api/* data, PROJECTED constants for the unserved denominators); pages/teams.vue rewritten in place from the design source with projected badges, inline team assignment kept, ?team=/?user= deep links preserved; nav label → "Teams, Users & Devices". Verified headless against live :7878 (sparse) and the Meridian seed (populated): console clean, filter round-trips through the URL, persists across pages, pins on scroll, both themes. Endcap SVGs were already real art — the "checkerboard" fix in global-filter-plan.md §3.4 was moot.

actor-listings + surface-section (2026-09-19): Plans written, nothing executed. Surveyed all 17 /inventory pages and the design mocks: no listing has an overview today, filter state is four idioms (useAgentFilter chip, posture/kind chips, UxTabGroup period, none), and Surface already exists three times on DataSurfacePanel (fleet index, agent detail, user-v3) with four more hand-rolled look-alikes on detail pages. See actor-listings-plan.md, surface-section-plan.md — each ends with the decisions to confirm.

actor-listings + surface-section executed (2026-09-19): Both plans run end to end on qcontrol feat/new-pages (twin record qdash cycles/c15). Actor listings: all eight /inventory/* listings and the fleet index register with the global filter and carry a three-DataMachine overview cross-footing with the filtered table (lib/actor-bands.ts, vitest); key catalogue extended; agentKeyDef() shows the agent's name for an entity-id pill via the new layer FilterKeyDefinition.formatVal; useAgentFilter / InventoryAgentFilterChip and every hand-rolled chip row retired; Sessions' period is now the global timeframe; the fleet index's hand-rolled DataMetricBase box and sparkGeo sparks became DataMachines. Surface section: backend /api/surface?<scope>= (agent / host / user / team / model / server / tool / workspace / adapter, none = fleet, own axis omitted; builder lifted out of /api/agent; Rust tests per scope); layer DataSurfaceSection chrome; qdash <SurfaceSection> + lib/surface-rollups.ts (bar metric per axis, house cells, listingTo deep links onto the filtered listings); placed on all seven actor detail pages and the fleet index (replacing five hand-rolled lists and agent detail's inline block; tools detail net new). Design site: DataSurfaceSection demo + registry entry, Filter demo documents formatVal, user-v3 adopts the chrome, stale page-registry note corrected. Layer released as 0.9.15. Verified headless on the Meridian seed with a clean console on every page; npm test 232, cargo test -p qdash 52. Not done: Sessions detail (phase 3), the expand-row compact grid, migrating Findings / Cost onto the global filter; the live :7878 backend must be restarted on the rebuilt binary for /api/surface.

session-details executed (2026-09-19, phase 3 thread 1 of 5): /inventory/sessions/detail replaced in place with the c90 session mock (session-details-prompt.md, -plan.md). Backend: session_detail_value now serves the run's event grain (events, ≤500, typed per event — tool calls pre-joined with decision and result by call_id, message text and tool arguments passed through a new normalize::redact_text so secrets/SSNs render masked exactly as the DLP findings show them) and token_parts; the "may not serve an event log" worry in plan.md was moot — the events table had everything. qdash: lib/session-transcript.ts (vitest 9) turns the grain into the layer TranscriptPanel shape (a turn per user prompt, one tool part per call, policy kept out of the dialogue), raw-event rows, the Surface chip grid, the rail's policy-event count. Page: identity ribbon, Transcript ⇄ Surface, TranscriptPanel with the BYOK disclaimer, Raw events toggle, sticky rail of four DataMachines + labelled fields + Files, "(AI gen summary)" and Account projected; per Mark, everything the old page had that the mock doesn't (Actions, Commands, Egress, Sensitive files, DLP, Models & Tokens) stays under a "More detail" rule. Verified on the seed (Marcus's run with an AWS key in the prompt renders masked; Priya's Cursor run with a denied call); no event-less run exists in the seed, so that branch is covered by tests only. cargo test 54, npm test 241. working-nav + people-pages planned (2026-09-20): Plans written, nothing executed (working-nav-prompt.md/-plan.md, people-pages-prompt.md/-plan.md). Verified before planning: the sidebar's NAV literal + useExperimentalNav singleton are the templates for the new toggle; layer NavVerticalItem takes a fallthrough class, so the nav-working hook needs no layer change; every detail page needs an id in the query and renders an empty shell without one, so Working's detail links must resolve a real example — fleet /api/surface + /api/agents + /api/installations + /api/sessions cover every kind in four requests. For the people pages: teams.vue already routes every number through typed rows (PersonRow/DeviceRow/TeamRow) from lib/people-rollups.ts, which is the swappable-data seam; seven inbound /teams links (surface-rollups, sessions detail, index checklist, nav) need retargeting; the design-site phase-1 rows are a different shape, so synthetic data is qdash-shaped (lib/people-sample.ts). Components stay qdash-local until a layer-extraction thread (arbitrary-value classes, ProjectedBadge, qdash routes are the seams). Each plan ends with the decisions to confirm.

working-nav + people-pages executed (2026-09-20): Both plans run end to end on qcontrol feat/new-pages (twin record qdash cycles/c15), every decision on its default. Working nav: useWorkingNav (localStorage, off by default) + a footer toggle above Experimental; a WORKING section after PROVE lists all thirteen listing pages and the eight detail pages; lib/working-nav.ts (vitest 6) resolves a real example per detail kind — the busiest row from fleet /api/surface, /api/harnesses, /api/sessions fetched once on toggle-on — and kinds with nothing observed fall back to their listing, dimmed; nav-working hook class, italic only. People pages: TeamsOverview / UsersOverview / DevicesOverview lifted from the combined page as presentational components (rows in, events out, linkTo function prop from lib/people-links.ts so the front site can render them link-less), usePeopleData holding the feeds + rollups + filter registration + /api/teams write path, lib/people-sample.ts as the synthetic data source in the rollups' exact row shape (vitest 2); /teams → /teams-users-devices (git mv, composes the three; Devices Sensored moved into a four-card Devices band with legends below the rings, a Teams band added, Users gained Active · 30d), solo /users, /devices, /teams (row → /users?team=; stray ?user= forwards); seven inbound /teams links retargeted. Verified headless on an isolated seed instance (:7880 — the :7879 seed wedges at 900% CPU under the dev proxy's polling; noted, not fixed): console clean on every page, deep links and row clicks land where the plan says. npm test 241 (29 files); dist regenerated. Not done: component mount specs (qdash's vitest is node-only — headless instead), design-site demos and layer extraction (their own thread, once the front-site framing exists), archive captures (kept in /tmp/c92, as the earlier c92 threads did).

listing-viz planned (2026-09-20): Plan written (listing-viz-prompt.md/-plan.md), execution handed to a separate agent in the same session with every decision on its default. Surveyed all thirteen listing bands against the layer's data components and the dataviz form heuristic: eleven of thirteen bands are number-only, and three of the four existing devices are 2-slice donuts (the form the heuristic rejects for a single ratio). Catalogued each category's information types by column — identity · magnitude · composition · outcome · time · reach — and found composition is the missing column everywhere while a real time axis exists only on Sessions (started_at) and the fleet's /api/trends series, so trend sparks are honest on exactly those. The one missing note is a segmented bar (hand-rolled once on the fleet index, needed on nine pages) → DataSegmentBar in the layer, sharing the donut's token-role resolver and the history graph's validated palette via a lifted data/palette.js.

timeframe-always planned (2026-09-20): Plan written, nothing executed (timeframe-always-prompt.md/-plan.md). Verified before planning: the layer's v2 Filter carries timeframe/timeframeValue/timeframeOptions props but never renders them — c88 moved timeframe selection into the Config modal — so the only registrant (Sessions, default all) compensates with a hand-placed period trigger bar; useGlobalFilter.period is per-registration and not persisted; the backend's "universal scope" (period_span · time_pred · window_cutoff, anchored to the data's MAX timestamp) is honoured by exactly four endpoints (costs, dlp, security, sessions) and none of the listings; models and workspaces rows carry no timestamp at all, so client-side windowing can't be honest. Read as three requirements — always visible, already applied, honoured — the plan puts the pill in the layer as FilterItem with a new removable prop, makes the period shell-owned (DEFAULT_PERIOD = '7d', URL omits the default, localStorage follows), and adds period to every listing endpoint so magnitudes come out in-window. Seven decisions to confirm, headed by the default window (7d vs 24h vs 30d). Confirmed same day, all on their defaults; Mark asked that server-side windowing be assumed necessary and thought through, so the plan's §C became a per-endpoint spec under four rules — one fleet anchor (MAX(events.observed_at), replacing the per-table anchors), activity facts window while at-rest facts don't, magnitudes are windowed at the fact grain (never "in-window runs × all-time cost"), and presence follows existence (activity-only entities drop out, at-rest ones stay with zeros) — plus the consequence for pages: coverage denominators are fetched all-time, activity feeds with the global period.

detail-pages planned (2026-09-20): Guide and plan written, nothing executed (detail-pages-prompt.md, -guide.md, -plan.md). Read all six old pages against the three model pages and inventoried every detail endpoint's payload: all six are all-time with no day series (so User Detail's chart-beside-band has no honest data anywhere yet); the shared correlated_agents builder zeros calls on three pages and tokens/cost on the other two; tools computes its success denominator but doesn't emit it; models.tokens excludes reasoning; findings attach to agents only; /api/surface has no harness axis; MCP Server's per-tool denied is served but no longer rendered since Surface replaced its Tools table. The recurring story on four pages is at rest vs at runtime (installs config vs observed runs) and none of the old pages puts the two side by side. The guide catalogues the model pages' patterns A–Q, gives each page its purpose, three-reader value, holes, numbered objectives and a four-tile DataMachine band, and records a six-item backend backlog (per-scope policy block and day series first). The plan sequences one groundwork thread (three backend fixes, an ActorHeader extraction, lib/detail-bands.ts, a shared chip/glyph table, an Actor detail frame pattern entry) then six page threads Model → Workspace → MCP Server → Tool → Harness → Machine, and ends with eight decisions. Mark confirmed 1, 2, 4–8 on their defaults and overruled 3: Device Details stays its own later Phase-3 thread (the c90 device mock is still in manual design), so Machine Detail is rebuilt on the actor frame without borrowing from the mock.

listing-viz executed (2026-09-20): listing-viz-plan.md run end to end, every decision on its default. Layer (released as 0.9.16): DataSegmentBar (data/SegmentBar.vue) — values in, normalized; 2 px surface gap; per-segment hover title; legend below / beside / none (title + value in text tokens); no colors → the three validated categorical slots with a fold into "Other" past the third uncolored part (explicitly colored parts never fold); ordinal → one grape hue stepped light → dark, validated with the dataviz validator in both modes (light #BBA5FF · #895AE8 · #5E29CC · #32146E, dark #E5DAFF · #BBA5FF · #895AE8 · #5E29CC); color: 'outline' for the presence vocabulary's "stopped"; empty → hairline track. data/palette.js lifts the donut's token-role resolver + palette, the history graph's categorical slots and the ordinal ramp into one file (history-graph/palette.js re-exports; donut and history graph render byte-identically). data-val / data-total / data-value hooks on DataMachine / DataSegmentBar so headless checks read raw numbers. Design site: DataSegmentBar demo (empty · minimal · typical · overflow-fold · ordinal · zero part · outline · beside · none-with-shared-key · inside a DataMachine) + registry entry; DataMachine demo gains the Composition / Ranked share / History presets with copy snippets; Listing Overview Band app pattern carrying the four rules and the honest empty state. qdash (feat/new-pages, twin cycles/c15): lib/actor-bands.ts grew shareOf / segmentsOf / byDay and per-band *Segments / *Top / byDay (+ toolsBand ok · failed · denied with judged = calls − denied, since judged isn't served); lib/people-rollups.ts gained intensity / coverage segments, shadow-by-harness and teamsBand; RankedBars composition (UxPercentBar rows, share of the whole); npm test 262 (was 241). All thirteen bands re-drawn per the plan's table: three 2-slice donuts became meters (Machines, Harnesses coverage) and one a three-part outcome donut (Tools); Sessions gained the full-width sessions-per-day history (clean · flagged, window follows ?period=, caption names the 200-row cap); fleet index presence → DataSegmentBar, At-risk :spark from the real /api/trends.posture[].crit (a flat zero line on the seed — honest), five footprint sparks + rampTo + the ProjectedBadge line retired. Verified headless on the isolated seed (/tmp/c92/listing-viz.mjs): 149 checks, 0 failures over 22 page loads — 13 pages, 9 filtered (?kind=cli, ?kind=mcp, ?source=observed, ?provider=anthropic, ?posture=Critical → empty state, ?posture=Elevated, ?period=7d&status=running, ?period=30d, ?team=Payments), both themes (token-role fills flip): console clean everywhere; every bar's parts sum to its card's value or to the whole its provenance names; ranked shares ≤ 100 and match the provenance's "top N = X %"; Tools donut counts = Calls; per-harness rows sum to installs; Sessions history lanes sum to the table rows under every period. Design demos render clean-console (the DataMachine page's 7 hydration warnings pre-exist — the demo's random-walk spark data). Consumer lockfiles refreshed, qdash dist/ regenerated. Deviations, all recorded here: Models' Tokens headline is now every token kind (in + out + cache read + cache write) so the four-part bar cross-foots — the table's column stays in + out and the provenance says so; Sessions' Flagged bar counts sessions by worst flag (DLP > sensitive > denied) so it sums to the card, the provenance carries the event counts; DataSegmentBar grew a width prop (a #right flex child has no intrinsic width) and honors legend="none" for the per-harness stack, which owns one shared key; the people-page bands stay fleet-wide under a team filter (the people-pages ruling — cards describe the fleet, the table the filter), so those devices cross-foot with the provenance's "of N seen" rather than the filtered table. Not done: a per-category daily series (plan decision 3, the next thread); archive captures kept in /tmp/c92/listing-viz/, as the earlier c92 threads did.

day-series planned (2026-09-20): Plan written, nothing executed (day-series-prompt.md/-plan.md) — the listing-viz follow-ups made concrete. Verified before planning: the three timestamped fact tables (llm_usage, tool_calls, runs ⋈ agent_instances via run_meta_map) cover every listing axis; /api/surface's scope resolver and /api/trends' day axis + dedup key are the pieces to reuse; detail-pages' backend commit already emits judged/ok/failed and reasoning_tokens, so the listing bands' two recorded deviations now disagree with Model detail and are reconciled first (§A, unsequenced); everything else waits for timeframe-always's fleet_cutoff (executing in the other session as this was written — cost.vue already reads gf.apiUrl). Eight decisions at the end, defaults stated.

detail-pages executed (2026-09-20): Plan run end to end, every decision as ruled (detail-pages-guide.md, -plan.md; twin record qdash cycles/c15 §detail-pages). Groundwork: backend web.rs — correlated_agents callers pass both maps (real calls / tokens / cost on every page's Agents ledger), /api/tools emits judged / ok / failed, /api/models emits reasoning_tokens (tokens = in + out + reasoning), /api/surface gains a policy block per scope, workspace runs end at their last observation; cargo test 58. Layer: ActorHeader + ActorHeaderCell extracted from agent detail's inline header (decision 2 — layer, with a demo; shipped in 0.9.17 alongside timeframe-always's Filter change), then DataMachine showFullNumber and AgentAvatar size as 0.9.18; consumer lockfiles refreshed. qdash: lib/detail-bands.ts (six pure band functions, vitest 20), lib/entity-chip.ts (the session page's glyph + chip vocabulary, shared); agent detail adopts ActorHeader with no visual change. Design site: both components documented (registry, adminProps demos), an Actor Detail Frame pattern on /patterns/app whose demo cross-foots. Pages: six fresh-context agents, one per page, each holding the guide's §4 section and a shared brief (/tmp/c92/detail-pages/BRIEF.md) — Model → Workspace → MCP Server → Tool → Harness → Machine, all on the frame, nothing old dropped (What the first screen doesn't carry sits under a "More detail" rule). Review caught two rule breaks before commit: Spend tiles abbreviated to "$2k" (→ showFullNumber) and the model token bar's parts included cache and didn't sum to the headline (→ parts are in / out / reasoning; cache is named in provenance). Verified headless on a fresh seed instance (:7881, rebuilt binary) — populated / empty / not-found / dark, console clean, band ↔ ledger pairs checked per page, link spot-checks; npm test 287. Seed gaps (no skills, configured-only servers, shadow installs, default_on) covered by specs and route-fulfilled fake payloads. Machine was rebuilt on the frame alone per decision 3 — Device Details remains its own later thread. Follow-ups in the twin record (listingTo adapter branch, modelsBand reasoning part, DataMachine provenance slot, detail pages + timeframe).

timeframe-always executed (2026-09-20): timeframe-always-plan.md run end to end (qdash ca04a2ee + record c15; layer 0.9.17 — overtaken minutes later by detail-pages' 0.9.18, which is what qdash pins). Layer: FilterItem.removable and Filter's permanent when: column, last before Config, rendered whenever timeframe is on and options are given — the bar is never in its empty state on such a consumer; timeframe=false keeps the "Add Filter" pill. Design site: Filter demo's "Empty" scenario became "Timeframe only — the always-in-place state" plus a timeframe=false scenario; FilterItem demo gained removable=false (with formatVal option labels) and the removable admin toggle; registry entries for both (props formatVal / roundLeft / removable documented, timeframe-only state); qcontrol/teams mock flipped to the pill (page-registry note); all four pages render the pill headless with a clean console (/tmp/c92/timeframe-design.mjs). qdash shell: DEFAULT_PERIOD = '7d', period shell-owned in useGlobalFilter (URL omits the default, localStorage follows, hydrated on register with URL winning), keys: [] as a period-only registration, gf.periodLabel / apiParams / apiUrl(path, keys) — the picker because ?host= is /api/machines' detail mode, so a listing forwards only the keys its endpoint reads; 8 new specs. Pages: eight listings + fleet index fetch through gf.apiUrl and label their bands with the window; fleet index's seen7d retired for the windowed count with an all-time denominator; Sessions' period trigger bar and Cost's tab group retired (same ?period=, deep links hold); Findings / DLP period-only; people pages fetch rosters ?period=all and activity with the global period, row fields window-neutral, Overviews take a period prop, intensity keeps its fixed 30d feed; the solo Teams page registers period-only so its windowed numbers carry the pill. Backend: fleet_anchor (MAX(events.observed_at)), fleet_cutoff / cutoff_pred / lifetime_pred / run_cost_map_in; period on agents, inventory, models, tools, mcp-servers, workspaces, machines, harnesses under the four §C rules; costs / dlp / security / sessions / stats-24h moved onto the fleet anchor; agents_value / costs_value extracted; one windowed test per body + the §C.2 invariant (agents_cost_cross_foots_with_costs). Where the plan was wrong: harnesses already carried agents / runs / tokens / cost / last_active (the plan said the row had no activity fact) — windowed those, identity read from every run on record so an installed adapter keeps its name; time_pred replaced (its space-form datetime() literal let the whole cutoff day through against T-form timestamps — cutoff_pred writes a T-form literal); a third index was needed, tool_calls(run_id) — /api/agents took ~5 s on the seed on both binaries (its run_id = ? OR entity_id = ? subselects scanned) and now takes 0.1 s; useApi dropped a path-change refetch that arrived mid-flight, so the hydrated period was served one poll late — it now queues (a real race the plan didn't foresee); PersonAgent's windowed fields are windowSessions / windowTokens (sessions was already the all-time roster count). Verified headless (/tmp/c92/timeframe.mjs): isolated seed :7880 on the rebuilt binary — 53 checks, 0 failures: pill with no ?period= on all 16 registered pages, Not Applicable on the unregistered ones, band = table on every listing at 24h / 30d, Σ agents cost = Cost total at 24h / 7d / 30d (66.07 / 331.44 / 1926.20) on the API and in the DOM, all-time denominators constant across windows, persistence across a breadcrumb navigation / reload / bare URL, ?period=all deep links, back-to-default clears URL and store, dark theme; console clean apart from two DataRankedBars duplicate-key warnings under 30d that belong to the concurrent day-series thread's layer component (keys by label). Live :7878 (old binary, root-owned): 30 shell-only checks pass; it needs the restart for windowing. npm test 290 (+8), cargo test -p qdash 68 (+10). Not done: dist regeneration (PR time); detail pages still Not Applicable (detail-pages decision 6 inherits ?period= + /api/surface period); archive captures kept in /tmp/c92/ (timeframe-*.png, timeframe-design-*.png).

day-series §A executed (2026-09-20): day-series-plan.md §A run end to end, every decision on its default; §B–§F wait for timeframe-always (landed the same day, qdash ca04a2ee) and detail-pages — start §B from the branch tip. Twin record qdash cycles/c15 §day-series §A. Reconcile (qdash lib/actor-bands.ts, vitest 290): modelsBand.tokens is the served field (input + output + reasoning — the detail-pages ruling), the composition bar's parts are those three and sum to it, cache read / write are named in the provenance (+2.87B cache read · 324.1M cache write · 83 % of all tokens served from cache), never drawn — Models listing and Model detail now share one definition (the listing keeps a zero reasoning part in its legend where the detail omits it, so the legend states the definition); toolsBand reads served judged / ok / failed / denied, the calls − denied derivation and its comment are gone, success = Σ ok ÷ Σ judged (the definition Tool detail's donut draws); specs assert parts sum to tokens and ok + failed + denied = calls. Layer (0.9.19, then 0.9.20 minutes later): DataRankedBars (data/RankedBars.vue) — qdash's RankedBars lifted verbatim plus layout: 'inline' | 'stacked'; stacked puts the label on its own line above a full-width bar with the share at the right end in text tokens, so id-shaped labels never truncate; 0.9.20 keys rows by index + label after timeframe-always's headless run caught duplicate-key warnings under 30d (two sessions by one user · agent, two workspaces named alike). qdash's RankedBars.vue is a shim for one release; Models / Workspaces / Machines Spend and Sessions Tokens call DataRankedBars layout="stacked" — the three third-column Spend sites at :width="150", because a 190 px device beside a 4.2k USD value overflows the card (the inline version had always overflowed there too, invisibly, since the bars have no track and the labels truncated); Teams / Devices / MCP Servers / Tools / Agents stay inline through the shim. Design site: DataRankedBars registry entry + demo (both layouts, empty em-dash, the same long paths inline vs stacked, people with mono off, inside a DataMachine); the DataMachine Ranked share preset and its copy snippet re-pointed to the component. Cycle-manager: concurrent-threads paragraph under Thread Documentation Convention, synced to the six sisters (bob-wire, market-analyst, app.qpoint.io, qflow, qmap, qpixel), each committed. Verified headless (/tmp/c92/day-series-a/verify.mjs, captures there): 192 checks, 0 failures over 48 page loads, both themes, console clean — Models Tokens headline = Σ served tokens = Σ in + out + reasoning, bar parts input / output / reasoning sum to it, cache in the provenance only, tokens-by-model bar sums to it, every Model detail Tokens tile = its listing row and the seven sum to the headline; Tools Calls = Σ served calls, Outcome donut counts = Σ served ok / failed / denied = Calls, headline = Σ ok ÷ Σ judged, five Tool details' Calls / Denied / Success tiles and judged · ok · failed provenance = their rows; every stacked label = the rollup's top 3 and renders untruncated (also under ?period=30d and ?period=all); the inline shim pages render. On seed :7881, not :7880 — :7880 runs a binary from before detail-pages and serves neither reasoning_tokens nor judged / ok / failed, so §A can't be checked there; :7881 is the rebuilt binary on the same seed db. Consumer lockfiles refreshed to 0.9.20 and committed (design, bob-wire, app.qpoint.io, www.qpoint.io, qflow, qdash). Concurrency, as it happened: the sibling timeframe-always session committed the four listing pages (ca04a2ee) minutes after this thread had edited them, sweeping the Tokens-card reconcile and the four call-site switches into its commit — the very interleaving the new rule names; noted in both threads' commit messages, nothing to undo. The design registry (shared with timeframe-always's uncommitted edits) was staged as this thread's hunk only (/tmp/c92/day-series-a/stage.mjs: HEAD blob + substitution → update-index). Not done: §B–§F (sequenced); the RankedBars.vue shim deletion (next release); the Listing overview band pattern still hand-rolls its ranked rows (§F); dist not regenerated (§A doesn't ask; PR time); archive captures kept in /tmp/c92/day-series-a/.

session-header (2026-09-21): Session detail's identity ribbon replaced by the shared ActorHeader (session-header-prompt.md, executed directly — no plan): technology mark + name, ⇄ person and status in the subline; the Duration cell and the run's metadata grid (Account, full id, Harness behind Show All) parked at the bottom in a Working section per Mark's follow-up. The header is added for consistency only — the body is the mock unchanged, so the rail keeps its tiles, its labelled fields (deliberately repeating the header's), Files and the projected summary. TranscriptPanel capped at 640px; hairline under the header; the Transcript ⇄ Surface switch sticky, the rail static and sitting against the 640px column rather than the far edge; the shared SurfaceSection above the Working section, scoped to the run via a new /api/surface?run= scope; the rail padded 50px at the top so it aligns with the transcript card. Verified headless on the seed, console clean; committed on qcontrol feat/new-pages, twin record updated.

providers-skills executed (2026-09-22): Two new inventory categories in qdash from Linear PRO-25 / PRO-30 (providers-skills-prompt.md / -plan.md, planned and executed the same session, every decision on its default; twin record qdash cycles/c15 §providers-skills). The problem's shape was the grain: a provider in qdash is the wire provider (who receives the prompts — llm_usage.provider), not the harness vendor (Cursor's harness is Anysphere's, its wire provider is cursor, and it routes Claude and GPT models), so PRO-25's vendor → technology → instance hierarchy reads provider → harnesses → agents; a skill is a configured capability with no runtime witness anywhere in the field, so the page is the register against the exercise and the exercise is an honest zero with the sessions on carrying installs as candidates — the phase-1 mock's sharpest sentence ("40 sessions on 24 installs carrying deploy in the past 7 days; none invoked it."). Backend: /api/providers grouped from the deduped usage rows (not /api/models' first-seen provider), with accounts as distinct account_uuid and org_id presence as the honest org-scoped ⇄ unscoped proxy for enterprise vs personal; /api/skills joining the register to harness, machine, person and runs through agent_instances.installation_id, unioned with runtime tool_kind = 'skill'; /api/surface?provider= / ?skill=; cargo test 72. Seed: the Meridian generator now emits installation.details for every instrumented install (a 7-skill catalog by harness × team, team MCP registrations, default models, plugins) — the first time qdash's at-rest surface (harness MCP/skills, MCP configured side, Model "Default on") is populated on the seed; no runtime skill call is invented. The generator's self-validation turns out to fail on the current binary with or without the change (shadow installs read as instrumented, coverage 92 %) — recorded in the twin, not chased. qdash UI: four pages on the listing anatomy and the actor frame, providersBand / skillsBand / providerBand / skillBand (vitest 300), ◈ / ✦ glyphs, scope kinds, Working nav entries, and the doors (Models' provider cell, Tools & Skills' skill rows and the old tools/detail?kind=skill address, Harness detail's skill chips). Both new detail pages register period-only so their tiles equal the listing row that opened them — the plan hadn't foreseen the mismatch the headless run surfaced (listing at 7 days, detail all-time); this is a proposal for the six older actor pages (detail-pages decision 6). Verified headless on the rebuilt binary + regenerated seed (/tmp/c92/providers-skills/verify.mjs): 346 checks, 0 failures over 36 page loads, both themes, console clean; :7879 (the dev proxy) restarted on the new binary + db so the pages are populated at :3030. Concurrency: two other sessions were mid-thread in the same trees (devices-labels / header-margin landed during this thread; a harness-rename plan and a dist regeneration were on disk) — the two files both threads touched (harnesses/detail.vue, tools/detail.vue) were staged as this thread's hunk only (HEAD blob + substitution), dist left alone. Not done: dist regeneration; design-site demos (no new layer component — every device already existed); archive captures kept in /tmp/c92/providers-skills/.

documented (2026-09-21): Visual record captured for the atlas (/cycles/design/c92) — until now every thread had kept its shots in /tmp/c92/. qdash (24 states, scripts/shot-programs/c92-qdash.json against the :3030 dev server proxied to the rebuilt-binary Meridian seed on :7879): the combined and three solo people pages, the fleet index, all eight listings (Agents also filtered at 30d and Models also in the dark theme), the seven actor detail pages plus session detail with its ActorHeader, and the sidebar with Working on — full-page renders wherever a page runs past the fold. Design site (11 shots, content mode): the DataSurfaceSection, DataSegmentBar, DataRankedBars and ActorHeader demos, the DataMachine presets, the Listing Overview Band and Actor Detail Frame pattern sections as element crops (the page-top hero showed Form Layout), the Filter timeframe-only and FilterItem removable scenarios, the qcontrol/teams mock with the pill (chrome kept — content mode hides the title block the pill lives in) and user-v3 on the chrome. Three archive entries for the cycle's highlights (the combined people page on real data, the actor detail frame, the listing overview bands); captions and the "New in this cycle" line in the capture manifest; Scope brought up to date with the layer releases through 0.9.20, the backend changes each thread actually made, and the two threads the list had missed (day-series, session-header). Left as found, deliberately: timeframe-always's design-site edits (Filter / FilterItem demos, both registries, qcontrol/teams.vue) are on disk uncommitted for Mark's review — the captures show that state; its timeframe-always-prompt.md / -plan.md are committed with this pass since the record already cites them.

devices-labels (2026-09-22): Three-line vocabulary ruling from Mark on the qdash Devices page, executed directly (devices-labels-prompt.md, no plan; twin record qdash cycles/c15 §devices-labels). Sensored = monitored → one Devices Monitored card ("Sensor installed and checking in", real share + segment bar), the projected unseen count folded onto the MDM line behind its PROJECTED badge; Shadow Processes → Shadow Harnesses (card, Coverage cell, flag reason, footnote); Installs = Harnesses → the table column is "Harnesses" with "(N shadow)" as its sub-count. Data keys and tests untouched; other pages' "Installs" ledgers out of scope. Verified headless (/tmp/c92/devices-labels.mjs), dist regenerated.

header-margin (2026-09-22): Spacing ruling from Mark, executed directly (header-margin-prompt.md, no plan; twin record qdash cycles/c15 §header-margin). Detail pages: the header-closing hairline's gap to the band 16 → 40px on all eight actor detail pages (Harness first, approved from a screenshot). Listing pages through the header component: qdash PageHeader bottom margin 24 → 40px, which also evens out the detail pages' breadcrumb → identity header gap; Devices / Users / Teams drop their extra mt-2. Layer ActorHeader untouched.

trigger-bar (2026-09-24 → 25): Layer FilterTriggerBar restyled to a screenshot from Mark, executed directly (trigger-bar-prompt.md + trigger-bar-reference.png, no plan). One bordered bar (rounded-8, py-1): a key segment whose stretched-SVG chevron points into single-select value segments — "All" (was "View All") plus one per option, hairline-divided; the endcap image and "Add Filter" label are gone, a label prop covers the screenshot's "Global Filter :" lead-in, and the key caret + dropdown appear only when there is more than one key (every qdash consumer passes one). The component owns its alignment — full-width, right-aligned — so all eight qdash consumers sit over their table's right edge with no page edits (Sessions' flex-row wrapper had held it left). A follow-up cruft pass: the colour classes gathered into one TONE role map (lineBorder … focusRing) as the first step toward tokens — still off-token by Mark's call, legacy brand blue at opacity + stock slate-500, and the comment says so; inset keyboard-focus rings (the bar's overflow-hidden clipped outset ones, and the invisible key <select> never showed one); the first segment's padding derived from the chevron overlap; orphaned assets/svgs/filter/bar.svg removed; comments on every atypical choice. Design site: registry entry rewritten, demo gains a label control and a lead-in scenario. A mid-thread "move it higher" instruction was meant for another session — its qdash edits were reverted in full, so qdash has no net change. Verified in the browser on qdash :3030 (both themes) and the design demo. Not done: layer release — consumers see it only through NUXT_LOCAL_LAYER.

harness-rename executed (2026-09-22): "Agent" → "Harness" on every qdash page (harness-rename-prompt.md / -plan.md, executed with all seven decisions on their defaults; twin record qdash cycles/c15 §harness-rename). The rename collided with the existing adapter-level "Harnesses" entity, so the plan's decision 1 renamed that entity to "Harness types" throughout — listing title, tiles, breadcrumb, jump-nav, and every "All harnesses →" / "Show all N" string that refers to the adapter (Claude Code, Cursor…) rather than the monitored tool × user instance. Routes, query params, API paths, component names, scope-kind values, event type names, and CSV column keys were left untouched per the plan's own rule — only rendered text changed, across ~60 files: every /inventory/* listing and detail page, the fleet index, Live, Findings, Posture, Cost, Performance, DLP, Compliance, Identity, Users, Controls, Integrations, AppSidebar, the shared components (AgentExpandDetail, AgentCard, live-page chips/tables, integration previews), and the label helpers in lib/ and utils/ — including the generic AI-agent prose in policies.ts and frameworks.ts (decision 3, renamed by default). The concurrently-landed providers-skills pages (/inventory/providers, /inventory/skills) weren't in the original plan's file list but used the same Agent/Harnesses vocabulary, so they got the same treatment for consistency — including a same-day naming interaction with the devices-labels vocabulary ruling (DevicesOverview.vue's "Shadow Harnesses" already meant the adapter-type sense before this thread ran; it was left as Mark's explicit, freshly-landed wording rather than reflowed into "Shadow harness types"). Rust-served strings picked up too (decision 4): the Control Center's "Agent autonomy" category → "Harness autonomy" in rules.rs, and two web.rs finding strings. npm test 300/300, cargo test -p qdash 72/72 after three test assertions and a plural() call-site update (the helper's default plural adds a bare "s", so agent/agents counts needed the explicit 'harness', 'harnesses' form); cargo build --release -p qdash clean. Verified via a whole-tree regression grep (only identifiers, routes, and comments survive) plus a 200-status curl pass over every registered route on the live :3030 dev server — that server is a CSR shell, so rendered text wasn't checked in a browser; a headless pass is recommended before the layer step below. Concurrency: a second live session was mid-edit on largely the same files (providers-skills, then committed as 3c4883af/a44bf3b6); every edit here re-read each file's current disk content immediately before writing, rather than reusing earlier reads, and two edits the first pass missed (machines/detail.vue's "Show all N agents" ledger footer, providers/detail.vue's "Agents" section heading) were caught by the regression grep and fixed. Not done: the two layer-component strings (agent/MiniCard.vue's "Go to Agent" button, policy-config/ListEditor.vue's raw-scope-value rendering) — decision 5's default asks for new props plus a layer release and a lockfile refresh across every consumer, which is a separate, outward-facing action (publishes a package other live projects depend on); left as a flagged follow-up rather than run unattended. dist/ not regenerated; qcontrol's running seed processes (:7878/:7879/:7880) still serve the pre-rename binary — the Rust rebuild is on disk, not deployed to those instances. Follow-up (2026-09-22, Mark's screenshot): the fleet index's Harness-types lens (lens-harnesses on /inventory — "Harnesses · 7 tools · 39 installs", tool/footprint/versions/coverage table) had been missed by the rename pass entirely — it duplicated the renamed Harnesses (agent-entity) section's label in the jump nav. Removed rather than renamed: the section, its harnessRows/harnessCols computed, the harnessGroups import, and the jump-nav entry; the page-intro sentence's stale "the harnesses they run in" fixed to "the harness types they run as". /inventory/harnesses (the standalone Harness-types listing) is untouched — this was only the fleet-index's embedded copy of it. npm test still 300/300.

user-details executed (2026-09-23, phase 3 thread 2 of 5): /users/detail?user=<email> in qdash from the c90 user-v3 mock on the actor frame, per Mark's ask ("based on user-v3, use the header pattern found on the other details pages" — user-details-prompt.md, executed directly; twin record qdash cycles/c15 §user-details). Header: the layer ActorHeader — avatar · name · team / ● last active, a Coverage pill cell, the mock's fact grid as Metadata with endpoints / models / providers / the projected Accounts line behind Show All. Data: the PersonRow the Users listing already builds, so every tile equals the row that opened the page; this person's rows from the same windowed /api/sessions feed drive the Sessions tile, the ledger and the chart. userBand + dailyTotals in lib/detail-bands.ts (vitest 306 total, +6). Where it departs from the detail-pages guide, deliberately: the chart beside the band is kept — a person's own session rows are an honest daily series (the Sessions listing's idiom), so the mock's clickable tiles survive for Sessions per day and Tokens per day (run totals, captioned as distinct from the Tokens tile's Cost-feed usage); the per-device cards (guide Q, "design-only") are built as PeopleDeviceCard over the row's harnesses and detected-only installs regrouped by endpoint. No backend change — the fleet feed's 200-session cap is stated on the page. Doors: pages/users.vue → users/index.vue so the route can nest; every ?user= link (endpoint / session / workspace / provider / skill detail, the Surface users axis, the /teams forward) retargeted to the page; person link kind; user detail → in the Users expand row; a Working-nav entry resolving the busiest person. Verified headless on the rebuilt-binary seed :7879 through a :3031 dev server (/tmp/c92/user-details/verify.mjs): 55 checks, 0 failures over 8 page loads, both themes, console clean — tiles = the feeds recomputed (costs by_user, agents, installations, sessions), Sessions tile = ledger rows = chart caption, tile click swaps the chart, one card per host with the detected-only row inside, not-found / no-param states, all three doors land. Concurrency: a sibling session had the machines → endpoints rename on disk uncommitted across ~80 files (including people-links, working-nav, detail-bands); every file was re-read before its edit and the new page speaks endpoints. Not done: commit (left for Mark with the rename thread's tree), dist regeneration, design-site demo (no new layer component), archive captures kept in /tmp/c92/user-details/.

account-details executed (2026-09-23): /inventory/accounts/detail?account=&provider= in qdash from Linear PRO-27, per Mark's ask ("a new details page for account — who's using the account, what harness are they using", then "this should be an account with a provider type … I have two Claude accounts, my personal account and the company account"; executed directly; twin record qdash cycles/c15 §account-details). The model: an account is a (provider, id) pair with a type — the id is the harness's own user.account_uuid, so it is that vendor's account (vendor_provider); type is company / personal from org_id presence; dual use is another account on the same provider. Seed: one uuid per (user, provider) instead of per user, plus personal_accounts in world.json (dana: Anthropic, jake: OpenAI) presenting a no-org id on ~⅓ of their runs — 33 accounts on the seed, two real dual-use pairs. Page: actor frame with Type and Provider as the headline cells, the attention block from served fields only, the Users ledger with each person's other same-provider accounts as typed doors, harness-type chips + the harness-instance ledger, sessions, Surface. Backend: /api/accounts (list + ?account=&provider= + ?user=), provider detail's Accounts ledger now the provider's own accounts (typed), /api/surface?account=, session detail carries the run's account posture + provider; cargo test 75, npm test 317. Doors from provider / agent / session / user detail and the Working nav. Verified headless on the rebuilt seed: 87 checks, 0 failures over 17 page loads, both themes. Not done: the accounts listing, dist, commit.

todos-2026-09-23 planned (2026-09-24, not executed): Mark's shorthand todo sheet (todos-2026-09-23.md, the prompt) turned into five per-page plans under todos-2026-09-23/ — README index (shared ground, verification recipe, nine collected questions with defaults) + 01-harnesses-listing (Harness types → Harnesses: columns endpoints/providers/sessions, versions/configured/harnesses count out, Installs card first; backend providers per adapter row), 02-harness-install-detail (Harness type detail → Harness Install Detail: Providers tile replaces Harnesses, Versions tile = most used, installs columns sessions/tokens/most-used-model/monitored, Surface gains Versions/Skills/Providers/Teams and drops Endpoints; backend per-install runs/top_model/monitored), 03-harness-detail (security score out, metadata = User · Endpoint · OS · Last updated, Sessions above Surface, Surface without Users/Endpoints; no OS field exists anywhere — flagged), 04-endpoint-detail (Harnesses + Installs ledgers merged into one "Harness installs on this endpoint" table joined on installation_id = install_id, rows linking to the install-detail page), 05-models-listing ("fix the data machines": nothing renders broken on seed or live :7878 — four candidate fixes listed, headline alignment / 331USD vs $ idiom / stale "all-time" subtitle / Other outweighing the top-3). Each plan is meant for a different executing agent; baselines captured to /tmp/c92/todos/*.png via /tmp/c92/todos/shots.mjs. Plans 1+2 share the providers backend change.

todos plan 1 executed (2026-09-24): Harnesses listing (todos-2026-09-23/01-harnesses-listing.md; twin record qdash cycles/c15 §todos plan 1). qdash /inventory/harnesses: title "Harness types" → Harnesses with full reach (Working-nav label, detail-page crumb and empty text, endpoint detail's "All harnesses →", surface captions, posture tooltip; left as "harness type" only where a runtime-harness column sits beside it — Providers, Skills, Accounts, Models pages, the Fleet index sentence); Installs card before Work; columns now harness · installs · endpoints · coverage · providers · sessions · spend (versions, configured, harnesses count gone; hosts key relabelled endpoints; sessions = the API's in-window runs). Backend web.rs: providers on every /api/harnesses row — [{ provider, label, calls }] most calls first, deduped in-window responses per run bucketed by wire provider (run_provider_calls_in / providers_of_runs, same dedup group as run_cost_map_in), shared with plan 2; test extended (cargo test 76). Rendered as ◈ pills linking to the provider page (no logo assets exist). Mark's note on the empty state became a layer component: FilterNoMatches (components/filter/NoMatches.vue — "No {subject} match the current filter." + a Clear filter button, @clear to the consumer) plus a #empty slot on DataTable inside its own empty chrome; documented here (registry entry in the Filter group, adminProps demo with minimal / typical-in-a-DataTable / overflow, DataTable demo gains a filtered-to-nothing scenario). Found and fixed while verifying headlessly: two gf.clear() calls in one tick collapse to one (the batched URL write re-reads the stale query), so the page clears with a single keyValFilters = [] write. Not yet a layer release — qdash's :3030 runs the local layer; ship needs a tag. LATER: approved / unapproved (no per-adapter approval field today).

todos naming correction (2026-09-24, plans 2–4 re-pointed before execution): the first draft had the two harness detail pages inverted — Mark's shorthand header "Harness Details (becomes Harness Install Detail)" sat above the type page's list, so plan 2 named harnesses/detail.vue (Claude Code across the fleet) "Harness Install Detail" and plan 3 left agents/detail.vue (Claude Code on one person's machine) as "Harness detail"; plan 1's executor had already written the type page's Working-nav label as Harness install detail. Mark's ruling: hierarchy is Harness (type, adapterId) → Harness install (instance, agentId; the runtime identity is keyed harness kind × user, web.rs:1402, host + installation_id attached) → Session; the type page is Harness Detail, the instance page Harness Install Detail, nav labels swap. Consequence for decision 8: an endpoint-detail row's primary link is the instance page when monitored, and only shadow installs (no identity, no page) fall back to the type page's ledger row via plan 2 §A.1's ?installId=; the secondary "runtime →" chip is gone. README (note, Vocabulary, decisions 3 + 8), plan 2 §A/§A.1, plan 3 new §A.0, plan 4 §C/§D/Verify rewritten; plan file names kept (02-harness-install-detail.md is still the type page) so briefed executors' links hold — titles are authoritative. Nothing in qdash changed in this thread; plan 2 carries the one-line label revert.

todos plan 2 executed (2026-09-24): Harness Detail, the type page (todos-2026-09-23/02-harness-install-detail.md; twin record qdash cycles/c15 §todos plan 2). Working-nav labels swapped to Harness detail (type) / Harness install detail (instance), fixing what plan 1 had set. Configured metadata out; band Installs · Providers · Versions (most-used version as the headline, a string in #right since DataMetricValue only formats numbers) · Spend; ledger "Harness installs" with columns user · endpoint · version · sessions · tokens · most used model · status (monitored / unmonitored) · spend, path and default model moved into the expand. Backend: per-install runs, top_model, monitored (the listing's predicate per row, so it cross-foots with the donut). Surface drops Endpoints and adds Versions (older pill) / Skills / Providers / Teams from lib/harness-surface.ts, in the same grid via a new default slot on qdash SurfaceSection. ?installId= lands on, expands and rings one ledger row (plan 4's shadow-row target). cargo test 76, npm test 337, verified headless. Not committed.

todos plan 3 executed (2026-09-24): Harness Install Detail (todos-2026-09-23/03-harness-detail.md; twin record qdash cycles/c15 §todos plan 3). qdash inventory/agents/detail.vue only, no backend: empty/not-found text says "harness install"; Security Score cell (+ DataSmile, sec) gone, Spend alone; subline leads with the owner chain user / ▭ endpoint (both linked) ahead of vendor / kind / state (decision 7); metadata = User (now a link) · Endpoint (laptop glyph) · OS (—, no field anywhere — decision 6) · Last updated, Credential / Terminal / Host-OS-user dropped; Show-All tail keeps Organization · Version · Binary fingerprint · Binary path · Config source · First seen, minus Account / Model / Working dir / PID (decision 5); Sessions above Surface (pills swapped); Surface only = models, MCP, workspaces, tools, sensitive files, egress (no Users / Endpoints), footprint strip 5 → 4 (endpoints out). Working-nav labels were already Harness install detail / Harness detail when this ran. Inbound link wording left for a later sweep (AgentCard.vue ×2, AgentExpandDetail.vue, endpoints/detail.vue crumb). Verified headless against :7880 (chen-mba Claude Code): layout, both owner links, Show-All tail, console clean; npm test 337. Not committed (the file also carries the uncommitted harness-rename edits).

todos plan 4 executed (2026-09-24): Endpoint detail (todos-2026-09-23/04-endpoint-detail.md; twin record qdash cycles/c15 §todos plan 4). qdash inventory/endpoints/detail.vue, no backend: the Harnesses and Installs ledgers merged into one Harness installs on this endpoint table — one row per scanned install with its runtime identity joined on installation_id (lib/endpoint-rollups.ts installRows, + agents with no scanned install appended), columns harness · user · version · sessions · tokens · cost · last active · status (monitored / unmonitored) · posture; path / configured / first seen moved into the expand. rowTo links runtime rows to Harness Install Detail (from=endpoint crumb) and shadow rows to their ledger row on Harness Detail (installId, plan 2) — the name cell carries the link because DataTable ignores onRow on expandable rows (row click still expands). Instrumented-but-never-ran installs read no runs yet rather than shadow. from=agent crumb now Harness install. Verified headless (chen-mba, felix-tower, both link branches); npm test 344. Not committed.

todos housekeeping (2026-09-25): the todo sheets are now named by their Logseq journal date (the meeting day), not the paste day: todos-2026-09-24.md + todos-2026-09-24/ → todos-2026-09-23.*, and the new sheet todos-2026-09-25.md → todos-2026-09-24.md (source journal core/journals/2026_09_24.md, not yet planned). References repointed in this record, the plan README, component-registry.ts (FilterNoMatches description), the qdash twin record and six qdash source comments. The workflow itself — sheet → per-page plans → parallel executors — is reviewed in c94, which will own the shorthand and the skill.

band-polish (2026-09-24 → 25): A conversational polish pass over the qdash bands and the layer devices under them (band-polish-prompt.md — 82 turns verbatim — / band-polish-plan.md). Layer (unreleased): DataMachineGroup (new) aligns a band's value rows on a 4-row CSS subgrid — missing or wrapped descriptions no longer drift siblings, empty rows collapse, the body is one cell; DataMachine gains #below, a filling #right, an italic hairline footer; DataRankedBars gains scale, row marks + legend, valuePosition, thin and solid bars; DataSegmentBar / DataRankedBars fill their container; UxPercentBar gains solid / titlePosition / thin / titleSize; DataMetricValue unit="$"; DataDonutChart align + one-line legend items; the categorical palette → black · slate · grey from Mark's reference (fails the validator's slate↔grey separation — legend + titles carry identity, recorded); UxPill outlined for every tone + size; metadata hairlines in ActorHeader; the global Filter restyled to the reference (Config → Filter). Arbitrary-value Tailwind introduced mid-thread was back-fixed to inline/scoped CSS. qdash: every band in a DataMachineGroup; ranked lists thin with right-hand values, Spend / Tokens / Coverage / Tools-exposed in #below; three hand-built row sets replaced by DataRankedBars; descriptions audited (timeframe removed — the pill owns it; redundant ones dropped; filler → caveats); identity segments on the default slots, Flagged denied → error; "Harness Inventory" → "Inventory", "Tools & Skills" → "Tools"; Endpoints shows the host's top model, from /api/endpoints now ordering models by runs (web.rs; cargo test 76; :7879 rebuilt + restarted). npm test 331/331. Captures c92-polish-* (13, programs scripts/shot-programs/c92-polish-{qdash,design}.json). Not done: layer release; FilterTriggerBar (c95); MCP detail vs listing Source pill tone; nothing committed.

todos-2026-09-24 planned (2026-09-25, not executed): Mark's 2026-09-24 product-review notes read straight from the Logseq journal (core/journals/2026_09_24.md; no sheet file — the block is quoted verbatim in the README) and turned into 17 per-page plans under todos-2026-09-24/ by the new /todos skill (c94): README (verified shared ground incl. a dead :7879 seed found and restarted, seed ids per route, wave order, 62 decisions with defaults, Voices, Notes) + 00-sweep (TUD page removal, harness logos via the layer's existing AgentAvatar registry — no new component, runs/harness-count column inventory with owners) + 01-harness … 16-workspace, written by seven parallel agents grouped listing+detail, every edit row verified against the live feat/new-pages files. Backend needed by three plans only: 01 (installs_detail[].agent_id, ranked models_detail), 03 (harnesses[], os — no OS source exists anywhere in the pipeline, schema chain documented), 16 (skills[] per workspace). Shared pieces: 02 creates the owner card and the skills-on-installs join that 04, 09, 16 reuse; 12 may need a layer release (UxFileTree). Baselines for all 18 page ids in todos-2026-09-24/baselines/ via scripts/shot-programs/todos-pages.json. Two sheet readings corrected in planning: "no logo assets exist" was stale (the layer ships 17 harness marks), and Providers has no runs column (read as two column families).

todos plan 00 executed (2026-09-25): Sweep (todos-2026-09-24/00-sweep.md; twin record qdash cycles/c15 §todos plan 00). Decisions 00.1–00.4 taken at their defaults (Mark had not answered). TUD removal: pages/teams-users-devices.vue deleted; THE FLEET sidebar now lists Teams · Users · Devices (exact-path active); route dropped from working-nav.ts and surface-rollups.ts LISTING_KEYS (no listingTo targets /teams or /devices, so no new entries); Team / User detail crumbs are one segment; comments in usePeopleData, devices, users, teams reworded; /teams-users-devices now renders the Nuxt 404. Logos: no new component — layer AgentAvatar logo-only ([&>span]:hidden) adopted at 8 cells: Harnesses listing name cell (24 px), Tool detail ×3 (configured-on, harnesses, recent calls), MCP server detail configuration ledger, Sessions listing harness cell, Provider detail accounts ledger harness types pills, Account detail users ledger harness chips (14 px); qdash now has 34 [&>span]:hidden sites for the later logoOnly layer prop. Sites assigned to 04 / 11 / 12 / 16 left to them; EXP pages untouched. Columns: runs removed from Provider detail (harness-types + accounts ledgers), Account detail (users + instances ledgers; users ledger initial sort runs → tokens), Tool detail and MCP server detail harness ledgers; Provider detail models ledger harnesses count removed. Left to owners: Endpoints runs (03), Workspaces runs (15), Workspace runs (16), Skill detail runs (12), Providers listing count columns (05); listing harness-count columns kept (00.4); sessions-labelled columns kept. Provider detail's harness-types ledger keeps its instances column (not in the inventory). npm test 344; after shots in todos-2026-09-24/after/ (harnesses, teams, devices, provider, tool, mcp-server, sessions, account, tud — five ids added to todos-pages.json: harnesses, provider, mcp-server, sessions, devices). Committed qcontrol e193adb3 (sidebar, working-nav, surface-rollups, usePeopleData, devices, TUD delete, Harnesses listing, Tool / MCP server detail, Sessions listing — hunks applied onto HEAD, other sessions' rewrites left unstaged); not committed, on disk only because those files carry other sessions' uncommitted rewrites or are untracked: Provider detail, Account detail (untracked — plan 06 commits it), Team / User detail crumbs (untracked), Users / Teams listing comments (new files staged by another session).

todos plan 00 corrected (2026-09-25, Mark): Devices was wrongly kept as a THE FLEET sidebar entry — Devices is not Endpoints and goes entirely: /devices page deleted, AppSidebar.vue + lib/working-nav.ts entries removed (qcontrol 81d2880c); Team detail's Endpoints-ledger footer All devices → now All endpoints → (/inventory/endpoints?team=, on disk — the file is untracked). DevicesOverview.vue is now unmounted but carries another session's uncommitted edits — left for its owner; deviceRows/devicesBand stay (Team detail and tests read them).

todos plan 01 executed (2026-09-25): Harness (todos-2026-09-24/01-harness.md; twin record qdash cycles/c15 §todos plan 01). Decisions 01.1–01.3 taken at their defaults (Mark had not answered): versions otherwise unchanged; installs ledger keeps its expand and gains an open → column; most used model = most sessions, ties alphabetical. Meta: Most used model pair after Default models (harnessBand().topModel, provenance N sessions of M sessions · K models on hover) — claude-sonnet-4-6 on the seed. DM: Providers tile keeps its count and adds a #below DataRankedBars of API calls via shareOf (top 4; provenance Anthropic carries 100 % of 3.4k calls). Ledger: trailing open → column to /inventory/agents/detail?agentId= (shadows —); lede names it. Versions tile: Mark, 2026-09-25: Versions tile removed for now — the band is Installs · Providers · Spend (3 columns); harnessBand().versions trimmed to { latest, ranked } (the Surface Versions panel's inputs), tests rewritten; Meta pair, ledger column, Surface panel and backend untouched. Surface: Providers panel deleted (providerRows import dropped, the export stays), Teams moved to the first sibling so Users · Teams share a row. Backend (/api/harnesses?adapterId=): installs_detail[].agent_id (latest runtime identity on the install, null for shadows) and models_detail now ranked [{model, runs}] (runs desc, ties by name; model-less runs uncounted) — harness_installs_attribute_a_user_by_run_then_by_machine_owner extended. npm test 346 (344 + 2), cargo test -p qdash 76. Verified: curl on :7880 (14/14 monitored rows carry an agent_id; top model sonnet 69 runs), open → on priya-x1 lands on the Harness install page (Claude Code · priya / priya-x1), ?installId=ec899f6b… still finds and expands its row; after shot todos-2026-09-24/after/harness.png. Plan correction: the seed's priya-x1 link is 3a3e0b9f… (the same identity agents_detail uses), not the plan's f8b6bdee… — both resolve to the same page. Both seeds (:7879, :7880) restarted on the new binary. Not committed in qcontrol: all four files (harnesses/detail.vue, lib/detail-bands.ts + test, web.rs) build on other sessions' uncommitted hunks (2026-09-23 plan 2 state) — on disk only; twin record committed qcontrol 80cf800c.

todos plan 01 corrected (2026-09-25, Mark): Harness installs ledger — row click opens the Harness install page (shadows, no agent_id, stay inert); the open → column, the row expand (path / default model / MCP / skills / plugins / warnings / settings), the section description and the N total count removed. ?installId= landing now scrolls + rings without clicking. Decision 01.2 → its alternative (row-click, drop expand). Page file still uncommitted (sits on the 2026-09-23 plan 2 hunks).

todos plan 02 executed (2026-09-25): Harness install (todos-2026-09-24/02-harness-install.md; twin record qdash cycles/c15 §todos plan 02). Decisions 02.1 and 02.3 taken at their defaults (Mark had not answered): the card replaces the User / Endpoint metadata pairs (subline owner chain stays); Skills bar = fleet installs, no backend. 02.2 → none (Mark, 2026-09-25: footprint strip removed entirely — sparks, "N → M" / "mostly flat" captions and the four count tiles gone, no sessions tile; rampTo / trendLabel / footprint and the surfModels / surfMcp / surfWs / surfToolCalls computeds that only fed it deleted). Owner card (Mark, 2026-09-25: user + endpoint in one card; owner card is a reusable layer component): new layer PeopleOwnerCard (q-nuxt-layer/components/people/OwnerCard.vue, committed c3e39cd, unreleased — prod qdash needs the next layer tag) — one bordered frame, User (initials / avatar image, bold name = name or the email's local part, email, grey team pill) and Endpoint (laptop glyph, mono host, OS —) columns split by a hairline, each part a link via userTo / hostTo, only="user" for the Endpoint page (plan 04); inline-style pixel sizes (no arbitrary classes). Documented here: new people group + registry entry + _demos/PeopleOwnerCard.vue (all 12 props in adminProps; empty / user-only / typical / missing-team / overflow). Mounted under the Harness install header with ownerTeam from /api/teams (priya → Payments, not the plan's "Data"). Skills: skillsOnInstalls(skills, installIds) in qdash lib/harness-surface.ts (one id or many; rows {skill, description, installs, here, calls}, sorted here ↓ · installs ↓ · name; +3 tests) and SurfaceSkillsPanel (components/surface/SkillsPanel.vue: rows, barKey = installs, barLabel = fleet installs, caption, empty, expandCap; rows → Skill detail, all → Skills) — plans 09 and 16 reuse both. priya-x1 lists deploy 24 · review-pr 15 · commit 14 · db-migrate 7. At-rest config the Harness ledger expand used to show: this page shows version, binary fingerprint, binary path, config source and first seen (Show All tail) and live MCP servers / models from Surface — not path-level default model, configured skills beyond the panel, plugins or warnings. npm test 349 (346 + 3). Verified on :7879: both f8b6bdee… and 3a3e0b9f… resolve to priya-x1 (program id kept); runs 40, tokens.calls 24 (plan said 17); links → /users/detail?user=priya%40meridian.dev, /inventory/endpoints/detail?host=priya-x1&from=agent&agentId=…, /inventory/skills/detail?skill=deploy; after shot todos-2026-09-24/after/harness-install.png. Committed qcontrol 830e3523 (SkillsPanel); not committed: inventory/agents/detail.vue (edits sit inside the uncommitted 2026-09-23 plan 3 header) and lib/harness-surface.ts + test (untracked, earlier plans' content).

todos plan 03 executed (2026-09-25): Endpoints (todos-2026-09-24/03-endpoints.md; twin record qdash cycles/c15 §todos plan 03). Decisions 03.1–03.6 taken at their defaults (Mark had not answered; 03.3 — no $ helper this round). Band: Install Coverage (coverage %, fully / partial / unmonitored segment bar, M of N hosts · K installs scanned) · Endpoint Hosts (host count, OS rolldown macOS · Windows · Linux · Containers · unknown from new endpointsBand().osBars / osSegments / osKnown + exported OS_BUCKETS / normalizeOs / osLabel in lib/actor-bands.ts); Spend tile removed, third column left as the issues donut's seat (not built). Table: harnesses column lists harness-type chips with AgentAvatar logos (shadow installs dimmed) → Harness page; installs → coverage; runs → OS (— until reported). Backend: /api/endpoints rows (listing + ?host=) gain harnesses[] {adapter_id, name, vendor, monitored} and os; installations.os column added in place (db.rs add_missing_columns, no epoch bump); endpoints_window_runs_but_keep_installed_hosts extended. OS chain: column + API + test landed; the monitor producer (qevents InstallationRecord.os) and seed are follow-ups, so every seed host reads unknown. Verified headless (after/endpoints.png): 100 % · 9 / 5 / 0, Endpoint Hosts 14 all unknown, tomas-mba = Claude Code + Codex CLI chips, chen-mba a dimmed windsurf shadow; npm test 351, cargo test -p qdash 76; :7879 / :7880 restarted on the new binary. LATER: issues donut (03.4 sources), moneyShare $ sweep (Mark to assign), OS producer + seed. Committed qcontrol a0479169 (db.rs) + 51d58982 (twin record); web.rs, actor-bands.ts + test stay on disk (inside the uncommitted machines→endpoints rename) and endpoints/index.vue stays on disk (staged by another session).

todos plan 04 executed (2026-09-25): Endpoint (todos-2026-09-24/04-endpoint.md; twin record qdash cycles/c15 §todos plan 04). Decisions 04.1–04.5 taken at their defaults (Mark had not answered) except §C's device, per Mark's clarification: the Harnesses replacement is a DataMachine with a rolldown, not the Surface-panel rows in the image. Owner card: layer PeopleOwnerCard only="user" (label Owner (most seen), team pill from /api/teams, link → User detail) under the header at half width so it lines up with plan 02's user column — the plan's qdash-local PersonCard was superseded by plan 02's layer component. Meta: the 16 px UxAvatar override left the Users chips (04.2 default). Band (3 columns): Coverage (the Installs tile renamed, donut kept) · Harnesses — headline = harnesses with a runtime identity on the host, DataRankedBars rolldown of the top 3 by all-time sessions (Team detail's Spend device; scale="max", value at the right; label harness · user only when the host has more than one user), provenance 29 sessions · 1 user on tomas-mba (Codex CLI 16 + Claude Code 13), from new endpointBand().agents.top (shareOf) · Spend; At-risk posture tile gone. endpointBand(hostAgents, hostInst) drops the findings argument, atRisk and openRisk (+1 test: ranking, cross-foot, multi-user label, empty). No harness logo on the bars: DataRankedBars rows carry a color mark only, no icon slot. Ledger: titled Harnesses on this endpoint, no expand (the #details at-rest block is gone, 04.5), row click → rowTo() (Harness install page, or the Harness page's installId row for shadows), footer Show all N harnesses, pill Harnesses; Findings section and the /api/security fetch removed. Surface: :only omits agents and users. The plan's initialSort="lastMs" "fix" was wrong: layer DataTable sorts by column label, so "last active" stays. npm test 352. Verified headless: after shot todos-2026-09-24/after/endpoint.png; a Claude Code row click lands on /inventory/agents/detail?agentId=1bf2e087-…&from=endpoint&host=tomas-mba; no expand controls, no Findings. LATER: harness logos on DataRankedBars rows (layer per-row icon); the Surface lede still says "who was at the keyboard" (SurfaceSection copy). Not committed in qcontrol: endpoints/detail.vue (staged by another session), and lib/detail-bands.ts + test (endpointBand itself is uncommitted in HEAD, so my hunks can't be separated); twin record committed qcontrol e421afb5.

todos plan 05 executed (2026-09-25): Providers (todos-2026-09-24/05-providers.md; twin record qdash cycles/c15 §todos plan 05). Decisions 05.1–05.3 taken at their defaults. Table: the requests column label is now API requests (key and slot unchanged). The band has no Requests tile, so the column is the page's only "requests". Mark then queried whether the line meant a DataMachine elsewhere. Mark's follow-up applied the same rename in qcontrol ee96427f: the Provider detail Requests tile and Show-All metadata row, and the Model detail tile and metadata row. The Account detail Sessions-tile provenance (N API requests in accountBand) was renamed on disk only, because detail-bands.ts isn't separable. The instance column (key agents, label harnesses) and its slot are removed. The type column is relabelled harness types → harnesses, and the subtitle now reads "models, harnesses and accounts". providersBand() never read agents, so no helper or test changed. There is no runs column on this page; the sweep inventory (§C) belongs to 00. npm test 352 (the README's 344 predates plans 00–04). Verified headless: after shot todos-2026-09-24/after/providers.png, whose headers read provider · models · harnesses · users · accounts · API requests · tokens · share · spend · last used. Anthropic shows harnesses 2 and the tiles are unchanged. Committed qcontrol 92d7080a (page + twin record, built from the HEAD blobs through a scratch index). The page's older uncommitted DataMachineGroup band restyle and Inventory crumb hunks stay on disk.

todos plan 06 executed (2026-09-25): Account (todos-2026-09-24/06-account.md; twin record qdash cycles/c15 §todos plan 06). Decision 06.1 was taken at its default: the account surface scope stays in web.rs and surface-rollups.ts as a dormant scope, and /api/surface?account= still answers. Surface removed: pages/inventory/accounts/detail.vue loses the <SurfaceSection>, its sec-surface jump pill, the scope computed and the SurfaceScope import, and the header comment no longer mentions it. The page now ends after the Sessions ledger, and the pills read Users · Harnesses · Sessions. Band, attention block and ledgers are unchanged. Decision 06.2 (commit the page) was overridden by the dependency check. HEAD 92d7080a lacks four things the page needs: accountBand in lib/detail-bands.ts; the account kind in ENTITY_GLYPH (lib/entity-chip.ts); the account-detail fields on /api/accounts?account= in web.rs (provider_label, harness_types, users_detail, other_accounts, sessions_detail, reached_detail, endpoints_detail, anonymous_runs); and the layer's DataMachineGroup, which is untracked in q-nuxt-layer and not in v0.9.21. Committing the page alone would leave HEAD with a page that can't build, so it stays untracked on disk. It lands together with those four. Verified headless (todos-pages.json / account, baseline vs after): no Surface heading. npm test stays at 352, and there is no backend change. Qcontrol commit is record-only (twin §todos plan 06), and the page is not committed.

todos plan 07 executed (2026-09-25): Teams (todos-2026-09-24/07-teams.md; twin record qdash cycles/c15 §todos plan 07). Decisions 07.1–07.3 were taken at their defaults. Mark 2026-09-25: 03.3 carried by plan 07. Band and table: Est. spend → Spend on the tile (description "Estimated from measured tokens") and on the table column. The Assigned tile is removed together with assignedSeen / assignedPct / assignedSegments, the people prop and teamsBand's people parameter, leaving two cards in the 3-col grid. $ sweep: the layer's DataRankedBars has no prefix, unit or format prop, but it draws row.display in place of its compact number. So the fix is one helper, moneyShare() in lib/actor-bands.ts, which formats with fmtC, the house formatter ($156.22, $12.3k). It is applied to every costTop band (models, workspaces, endpoints, agents, sessions, providers) and to teamsBand.spendTop. Values, shares and totals are unchanged, and no layer prop was needed. Pages that now read $ on their ranked spend rows: Teams (Spend tile), Providers (Spend), Models (Spend), Repos & Workspaces (Spend) and Sessions (the cost rows under Tokens). Team detail already formatted its rows inline. Every spend table cell (fmtC), tile value ($ slot or unit) and provenance string (est. $331.44) already carried $. npm test 353 (+1 moneyShare). Verified headless: after/{teams,providers,workspaces,sessions}.png. Teams reads Payments $156.22 · Frontend $69.86 · Data $63.06, the same as its table cells. The Models listing has no program entry and was checked live through :3030 ($899.97 · $723.93 · $149.53). Qcontrol 7480b1e0 carries the $ helper and tests. The Teams page hunks stay on disk: TeamsOverview.vue, pages/teams/index.vue (staged by another session) and the teamsBand Assigned removal in people-rollups + test. HEAD's TeamsOverview predates the uncommitted band restyle, and HEAD has no Teams page.

todos plan 08 executed (2026-09-25): Users (todos-2026-09-24/08-users.md; twin record qdash cycles/c15 §todos plan 08). Decisions 08.1–08.3 were taken at their defaults: "Users using AI agents" in sentence case, "Users needing Attention" left as is, and Team detail's Active tile left as is. Band: User Coverage → Coverage, with its projected badge and "N seen · M known" kept. Active → Activity, with the description line "Users using AI agents" under the title. Mark, 2026-09-25: identity-integration line removed. That is the "○ Okta not connected · projected · N people seen by the sensor" row under the band, plus its identityIntegrations computed. PROJECTED's okta entry stays in people-rollups. Part B, Mark 2026-09-25: DataListingBar + key dropdown on every listing (c95 wiring). Users: the roster keeps UxTableList, because rows pre-open by ref from ?user= and it has its own cross-field search, which DataTable doesn't expose. It gains a column model instead: a catalog from its cols map with Person locked, v-if per header and cell, and colspans that follow the visible count. Hiding the sorted column drops back to the roster order. The strip is DataListingBar (Team; Provider has no column). Teams: usePeopleData({ register: 'teams' }) registers team, the page filters visibleTeams, and TeamsOverview takes a quickFilter prop with the strip in DataTable #toolbar. ?team= is now the table's filter, no longer forwarded to Team detail; ?user= still forwards. Endpoints: the strip starts on Team, and the endpoint column (whose cell shows users · team) answers user/team via filterKey. Providers: Provider (label column → filterKey: 'provider'). Models: Provider. Repos & Workspaces: users/hosts annotated user/host, but both carry more values than the strip seats, so the toolbar holds a standalone UxColumnPicker until a short key has a column (plan 15's team key + teams column switches it to the bar by itself). Fleet index: the Harnesses strip moves to useQuickFilter (posture only, no caret). useQuickFilter gains a cap: a key with more than QUICK_FILTER_MAX_OPTIONS (8) values stays off the strip. The segmented bar has no overflow handling, and fourteen hostnames pushed its key segment off the page. The seven c95 strips are unchanged: their carets and values were checked live. Verified live through :3030 on Users, Teams, Endpoints, Providers, Models, Workspaces and Fleet: the bar renders, Columns hides a column and the table follows, picking a value filters and writes the URL, and sorting by a column then hiding it falls back. npm test 353. After shots are after/users.png, plus after/{endpoints,providers,models,workspaces,teams,fleet}.png published -p08; the program gains a models entry. Qcontrol b36a026e carries Part A only, applied to HEAD's band. The rest is on disk: Part B depends on the untracked useQuickFilter and the unreleased layer DataListingBar, and pages/{teams,users}/index.vue and inventory/endpoints/index.vue are staged by another session.

todos plan 09 executed (2026-09-25): User (todos-2026-09-24/09-user.md; twin record qdash cycles/c15 §todos plan 09). Decisions 09.1–09.3 were taken at their defaults: adjacent "Devices" words on other pages are left, shadow-install skills are counted, and the Skills panel header is harnesses. Mark, 2026-09-25: Devices → Endpoints on the tile and table titles (User detail + Team detail), and the tile says Endpoints throughout. Endpoints: on User detail, the band tile, the section heading and the jump pill now read Endpoints; the keys (band.devices, sec-devices, PeopleDeviceCard) stay. userBand()'s tile strings already said endpoints, so detail-bands is unchanged. On Team detail, the section heading and pill read Endpoints. Team detail has no Devices tile, and its Devices metadata pair, device column and lede are left. Surface: :only is models · mcp_servers · workspaces · tools · sensitive_files · egress, so Harnesses and Endpoints are gone. Skills: plan 02's SurfaceSkillsPanel sits in the section's slot over skillsOnInstalls(/api/skills, monitored installationIds + detected installIds), with the bar on here and the header harnesses. PersonDetectedInstall gains installId, and its test asserts it. Verified live through :3030 (priya, 30d): Endpoints 1 · Harnesses 4 · Spend; pills Endpoints · Sessions · Surface · Attention; Surface is Models, MCP Servers, Repos & Workspaces, Tools and Skills 4 distinct (deploy 2 · review-pr 2 · commit 1 · db-migrate 1), with no Harnesses or Endpoints panel. The rows open /inventory/skills/detail?skill=… and all → opens /inventory/skills. npm test 353. After shot after/user.png, published as c92-todos0924-user-{before,after}. Qcontrol 3fed378a carries the people-rollups installId hunks and the twin record. pages/users/detail.vue and pages/teams/detail.vue stay on disk, because they are untracked and HEAD lacks userBand/teamBand, harness-surface.ts, SurfaceSection's slot and PeopleDeviceCard.

todos plan 10 executed (2026-09-25): Model (todos-2026-09-24/10-model.md; twin record qdash cycles/c15 §todos plan 10). Decisions 10.1–10.5 were taken at their defaults: only the Default-on tile goes (the "Configured as default" ledger stays), the chip strip is dropped, the type rows come from a client rollup, there is no instance-count column, and the header's "Harnesses 22" is left and flagged. Mark, 2026-09-25: table column reads API requests, matching the tile (the coordinator had already renamed the tile and its Show-All metadata row in qdash ee96427f). Band: API requests · Tokens · Spend on one row (md:grid-cols-3); modelBand() loses defaultOn, and its test becomes "rounds spend to cents". Harnesses: the "Harness types" chip strip is gone, and the instance ledger (22 rows, capped at 10, row → Harness install) is now one row per harness type. modelHarnessRows() in lib/detail-bands.ts rolls up agents_detail into harness · users · endpoints · sessions · API requests · tokens · spend · last active, with the AgentAvatar logo at 14 px. Rows open Harness detail and the footer reads All harnesses → /inventory/harnesses. The rollup has four new vitest cases. Surface: the section, its pill and the SurfaceScope/listingTo import are removed, so the pills are Harnesses · Default on. Verified live through :3030 (claude-sonnet-4-6): claude-cli 14 · 14 · 252 · 2,019 · 72.7M · $1412.84, cursor-cli 5 · 5 · 77 · 630 · 19.7M · $390.91, claude-desktop 3 · 3 · 21 · 205 · 7.62M · $152.49. The cross-foot holds: API requests Σ 2,854 = the tile (2.9k) and tokens Σ 99,988,633 = the Tokens tile (100M). The plan's 1,242 / 45.8M came from an earlier seed; both seeds now serve 2,854 / 99,988,633. Configured as default still lists 22 installs. npm test 353 → 357. After shot after/model.png, published as c92-todos0924-model-{before,after}. Qcontrol 7d697cc5 (code, built on HEAD blobs) and 5de0e37f (twin record); the page's and lib's foreign hunks (the DataMachineGroup band, harness-rename wording, other bands) stay on disk.

todos plan 11 executed (2026-09-25): Skills (todos-2026-09-24/11-skills.md; twin record qdash cycles/c15 §todos plan 11). Mark, 2026-09-25: both tiles kept, each gains a top-10 rolldown. This overrides the plan's §A reading, "remove Invocations, add two machines". Decisions 11.1–11.5 were otherwise taken at their defaults. Band: skillsBand() caps callsTop at 10 (it was 3) and adds installsTop, the top 10 by installs. Each of its bars is the skill's coverage of the scanned fleet rather than a share of the sum, because installs aren't exclusive (11.2). Its tooltip reads "on N of M scanned installs". The Installs tile keeps its title, headline and provenance, and its % bar gives way to a #below DataRankedBars (11.1). The Invocations tile keeps its title, headline and real-zero provenance and gains an unconditional #below DataRankedBars, which draws an honest em-dash while every call count is zero, with no fallback to installs (11.5). Table: the columns are skill · harnesses · source · installs · invocations · last invoked · first registered. definitions, people and hosts are gone (11.3), and harness types became harnesses (11.4). The harnesses cell draws logo-only AgentAvatar :size="14" marks. None of the removed columns carried a filterKey, so the strip's Harness key is unchanged. Verified live through :3030: Installs 25 ("64 % of 39 scanned installs"), with rolldown deploy 24 (62 %) · review-pr 15 · commit 14 · db-migrate 7 · incident-runbook 4 · storybook 4 · dbt-model 3. Invocations 0 with an em-dash. deploy and review-pr show the Claude + Codex marks and storybook shows Claude + Cursor. The harness filter cursor-cli narrows the page to storybook (Installs 4, one bar), and the Columns picker shows 7 of 7. npm test 357 → 358. After shot after/skills.png, published as c92-todos0924-skills-{before,after}. Qcontrol 5027b042 holds the band, the test, the page's table hunks (logo cell, two columns out) and the twin record, all built on HEAD blobs. The tile rolldowns, the definitions removal and the label rename stay on disk: they sit inside the uncommitted DataMachineGroup band and c95 listing strip, and they need the unreleased layer's DataMachine #below and DataRankedBars thin / valuePosition.

todos plan 11 follow-up (2026-09-25, Mark): Skills tile selector. Mark asked for "an optional slot to the DataMachine component to the right of the title" holding a simple selector over all three rankings, and for the configured info to go. Layer (f783613 + 640fb24, unreleased; pending 0.9.22): DataMachine #title-right lays the title row out as title · slot, justify-between, baseline-aligned; clicks inside it don't reach to; in a card too narrow for both it wraps under the title, right-aligned and capped at the card width; unused it renders the unchanged title div. New UxSelectInline: the current label + a small primary triangle caret over an invisible native <select> (options { value, label }[], v-model, ariaLabel, keyboard-only focus ring; a long label truncates). Nothing was reused: UxSimpleSelect's grey chevron ships to many consumers, and the FilterTriggerBar key segment isn't separable. qdash: the Skills tile loses its "across N harnesses · N configured, never called" provenance and the configured/called DataSegmentBar. Its title row carries UxSelectInline People (default) · Installs · Invocations (Mark, 2026-09-25: short picker labels (People default); the description swaps per view to say what the rolldown means; this replaced an interim "Total People Using" label), which switches a #below DataRankedBars (top 10, valuePosition="right" thin :labelWidth="140", scale="max" for Invocations only). skillsBand() gains usersTop: each bar is the skill's people of peopleTotal, the distinct identified people with an agent on any scanned install (peopleOnScannedInstalls over /api/agents?period=all, proxy-only excluded; 14 today). It drops idle / sourceSegments, which nothing else read. The static description "Called at runtime or configured" is gone; the description now says what the rolldown means: People "People with each skill on at least one of their installs"; Installs "Harness installs carrying each skill, of the N scanned" (N = band.installsTotal, 39 today, never typed by hand); Invocations "Runtime calls per skill in this period". Mark, 2026-09-25: the headline takes unit="skills" and reads "7skills" — DataMetricValue's dimmed suffix sits flush, as req / requests do elsewhere; on one line at every width, beside the selector. Verified on :3030: People (the default) reads commit 14 · deploy 14 · review-pr 8 · db-migrate 7 · incident-runbook 4 · dbt-model 3 · storybook 3, tooltips "deploy: 14 people using"; Installs puts deploy 24 on top (deploy 24 · review-pr 15 · commit 14 · db-migrate 7 · incident-runbook 4 · storybook 4 · dbt-model 3), so the two orders differ at the top (commit ties deploy on people) and at the tail; Invocations shows the em-dash. Tab + typeahead switch it with a keyboard-only ring; the Teams / Providers / Endpoint detail DataMachines render the unchanged title div; the console is clean. npm test 358 → 361. Design docs (on disk until the layer releases): two #title-right scenarios in the DataMachine demo, the slot in its registry entry, and a UxSelectInline registry entry + adminProps demo. Qcontrol 22e67c7a + fe7119bd + f1c31efd hold the band + tests; the page hunk stays on disk (foreign DataMachineGroup restyle + unreleased layer). Mark, 2026-09-25: no headline; short per-view description + provenance explain the rolldown. This supersedes the per-view descriptions and unit="skills" above. The Skills tile is device-only: no val, and the rolldown moves to #right, which owns the row, so no empty value row opens a gap (no layer change). People: "Total people with this skill" / "of 14 people on scanned installs". Installs: "Installs with this skill" / "of 39 scanned installs". Invocations: "Calls to this skill" / "none reported yet by any harness" ("N calls this period" once any exist). Every number comes from the band (peopleTotal, installsTotal, calls). The separate Installs tile drops its headline the same way. It keeps "With at least one of these skills" and its rolldown, and its provenance stands alone: "25 of 39 scanned installs carry a skill" (carrying, installsTotal). Mark, 2026-09-25 (later): the Invocations tile drops its headline too, so none of the three tiles has one. It is device-only with the rolldown in #right. With calls, its provenance carries the count on its own: "N calls · M of K skills exercised", plus " · D denied" when there are denials (calls, exercised, skills, denied). At zero it keeps the honest line "no harness emits runtime skill attribution yet — a real zero" over the em-dash rolldown. Nothing else wraps at 1440 or 1100; that honest-zero line wraps to two lines at 1100, as it did before. After shots c92-todos0924-skills-after-p11b (interim) and -p11c (final).

todos plan 11 follow-up 2 (2026-09-25, Mark): Skills tile — layout A. Mark, 2026-09-25: layout A — Skills picker Team (default) · People · Installs · Harness · Drift; Installs tile removed; Invocations only as its own tile. Band: skillsBand() takes an opts bag { teamIndex, harnessNames }. skillsTeamIndex(agents, teams) maps install id → the teams of the identified people with an agent on it (/api/agents?period=all × /api/teams; a person on no team → unassigned, proxy-only never counts). teamsTop counts each team's distinct skills; each bar is out of all skills, because skills aren't exclusive across teams (tooltip "Data: 4 of 7 skills"). unassigned ranks only when it has skills. harnessesTop counts the skills per harness type, each bar out of all skills, labelled with the /api/harnesses name. driftTop lists skills with definitions > 1, scaled to the most-drifted (tooltip "deploy: 2 definitions across 24 installs"), and drifting counts them. Page: the Installs tile is gone, so the grid shows Skills · Invocations with the third column empty. The Invocations tile is unchanged. Team and harness labels drop the mono face. Copy: Team "Skills installed per team" / "of 7 skills · 4 teams"; Harness "Skills per harness" / "of 7 skills"; Drift "Skills whose installs disagree" / "1 of 7 skills has more than one definition" (with none, an em-dash over "every install carries the same definition"). People and Installs are unchanged. Not done: (1) Harness names read "Codex CLI" / "Cursor CLI" rather than the expected "Codex" / "Cursor": the harness cell's resolver (layer components/agent/registry.js resolveAgent) isn't exported, so matching it needs a layer export. (2) No harness logos: DataRankedBars has no leading-icon slot. (3) Drift rows don't link to Skill detail: the device has no row link. Verified on :3030: Team (default) Data 4 · Payments 4 · Platform 4 · Frontend 3, with no unassigned row. People commit 14 · deploy 14 · review-pr 8 · db-migrate 7 · incident-runbook 4 · dbt-model 3 · storybook 3. Installs deploy 24 · review-pr 15 · commit 14 · db-migrate 7 · incident-runbook 4 · storybook 4 · dbt-model 3. Harness Claude Code 7 · Codex CLI 2 · Cursor CLI 1. Drift deploy 2. With cursor-cli on the strip, every view recomputes: Team Frontend 1 ("of 1 skill · 4 teams"), People storybook 3, Installs storybook 4, Harness Claude Code 1 · Cursor CLI 1 (the storybook row carries both), and Drift an em-dash over "every install carries the same definition". Tab + typeahead switch every view with the keyboard-only ring, and the console is clean. npm test went from 361 to 366. LATER: a Risk view for skills that bundle executable scripts or widen allowed-tools, which needs a backend field on /api/skills listing rows (today only Skill detail sees files and frontmatter). Qcontrol abc61c61 holds the band + tests and aebf636e the twin record; the page hunk stays on disk (foreign DataMachineGroup restyle + unreleased layer). After shot c92-todos0924-skills-after-p11d.

todos plan 11 correction (2026-09-25, Mark): Installs back out of the Skills picker — moving it in was a miscommunication. Installs is its own tile again (no headline; description "With at least one of these skills"; provenance "25 of 39 scanned installs carry a skill" from band.carrying / installsTotal; rolldown installsTop), so the band is Skills · Installs · Invocations; the Skills picker is Team (default) · People · Harness · Drift. Page on disk only (same reasons as plan 11). Verified on :3030 unfiltered.

todos plan 13 executed (2026-09-25): Tools (todos-2026-09-24/13-tools.md; twin record qdash cycles/c15 §todos plan 13). Decisions 13.1–13.2 were taken at their defaults. Tiles: Tools → Tool type. Its headline is still the tool count (26), with the kind segment bar as the device. Calls → Invocations, with its headline kept (1.4k over 30d, 330 over 7d). The Outcome description now reads "weighted by invocations". toolsBand() is unchanged. Words: every rendered "call(s)" on the page is now "invocations" (subtitle, tile, empty state, column header). Keys stay calls. initialSort moves to "invocations", because DataTable matches initialSort against labels; the plan kept the key, which would have dropped the default sort. Table: the denied and success columns merge into one outcome column (success_pct, 160px). It shows the percent, then an N failed pill in neutral and an N denied pill in warning, nonzero parts only. Skill rows show —. The column sorts by the percent, and the denied count is no longer a sort target. On :3030 over 30d, Write shows 100% 8 denied and Bash shows 100% 6 denied; the seed has no failed invocations. Also checked: outcome sorts both ways (skills sink), and the Columns picker lists outcome (7 of 7). Hiding outcome falls back to the invocations sort. The only "call" text left on the page is a skill description ("on-call"). The after shot (7d default) shows no pills, since that window has 0 denied. npm test 366. LATER: HEAD's Skills listing opens in API order (initialSort="installs" against a HEAD label of "configured on"; the disk version is fine); Sessions still says "denied calls". Committed qcontrol f7d94625 (HEAD-based page hunks; the equivalent edits sit on disk inside foreign code) + 95b3650c (twin). Atlas pair c92-todos0924-tools-{before,after}(-full).png.

todos plan 14 executed (2026-09-25): Tool (todos-2026-09-24/14-tool.md; twin record qdash cycles/c15 §todos plan 14). Decisions 14.1–14.2 were taken at their defaults: the header's Denied cell stays, and no /controls link replaces the tile. Surface: the SurfaceSection and its jump pill are gone, so the pills read Harnesses · Recent invocations. The lib's 'tool' scope stays, now unconsumed. Band: the Denied tile (the page's only /controls door) is removed and the grid narrows to three: Invocations · Success · Harnesses. Denied lives on in the header cell (red when > 0), the donut's denied slice and the per-call decision pills. Words: every rendered "call(s)" now reads "invocation(s)", including the tile, the empty states, the lede, the Recent invocations h2, the footer and the ledger column (label: 'invocations', 100px). initialSort moves to "invocations" (it matches labels). toolBand() provenances and the one test assertion follow; keys stay calls. Plan 00's state is confirmed: logos on the harness cells, no runs column. Verified live through :3030. The detail request carries no period, so the numbers are all-time. Glob: Denied 0 · Invocations 298 ("by 31 harnesses · avg 1953 ms") · Success 100 % · Harnesses 31, with the ledger sorted 39 → 11. Write: Denied 16 in red · 246 · 100 % ("judged 230 · 230 ok · 0 failed") with an orange denied slice · 34, and two denied pills (config, user) past the first 10 recent rows. The console is clean. npm test 366. LATER: the skill branch is unreachable (redirect), and band.denied.provenance is no longer rendered. Committed qcontrol f0f78d8e (HEAD-based page, lib and test hunks; the equivalent edits sit on disk inside the foreign harness-rename hunks) + 1d81822a (twin). Atlas c92-todos0924-tool-before(-full).png + c92-todos0924-tool-after-p14(-full).png (plan 00 had published tool-after).

todos plan 15 executed (2026-09-25): Workspaces (todos-2026-09-24/15-workspaces.md; twin record qdash cycles/c15 §todos plan 15). Decisions 15.1–15.3 were taken at their defaults: a top-3 Tokens rolldown, name labels kept although three payments-core rows collide, and the team key added. Band: the Runs tile becomes Tokens. It takes the Spend tile's shape: a Σ tokens headline, the provenance top 3 = N % of tokens, and DataRankedBars below it with Spend's on-disk props. workspacesBand(): runs → tokens, sharedRunSegments out, tokensTop beside costTop. The Runs tile's one other fact, shared, moves into the Workspaces tile's provenance (… · N shared · by last activity). Table: users, hosts and runs are out; teams and tokens (fmtN mono) are in. Teams come from the Endpoints listing's user → team join (teamByUser over /api/teams, a set per row). The team key is registered (suggestions + matcher), while user / host stay in the Filter bar. Strip: the teams column carries filterKey: 'team' and useQuickFilter starts on team, so the page moves from plan 08's standalone UxColumnPicker to the full DataListingBar (Team · All · Data · Frontend · Payments · Platform · Columns). Verified live through :3030 against the :7879 seed. Default Past 7 days: Workspaces 14 ("0 with a git remote · 0 shared"), Tokens 24m = curl Σ 23,954,170, with the rolldown etl-pipelines 3.3M · payments-core 3M · web-checkout 2.5M ("top 3 = 37 %"), and Spend $331. At 30d: Tokens 122m = curl Σ 122,393,771, with payments-core 19.9M · etl-pipelines 13.5M · payments-core 12M (37 %). Headers kind · workspace · harnesses · teams · tokens · spend · last active, sorted by last active descending. team:Payments leaves 4 rows (tomas / marcus / elena payments-core, priya payments-migration) and Tokens 8.1m, then was cleared. The Columns picker shows 7 of 7 with workspace locked, and hiding and restoring tokens works. The console is clean and the global filter was left {}. npm test 366 (unchanged; the workspacesBand block was rewritten in place). Committed qcontrol 21cdbaae (HEAD-based page, lib and test hunks; the Tokens tile uses HEAD's Spend props there) + 417c8dec (twin). On disk only: the listing-strip half (useQuickFilter(gf, 'team'), the #toolbar strip; useQuickFilter is untracked and DataListingBar unreleased), plus the on-disk Tokens-tile props that sit on the foreign Spend restyle. Atlas c92-todos0924-workspaces-before(-full).png + c92-todos0924-workspaces-after(-full).png.

todos plan 16 executed (2026-09-25): Workspace (todos-2026-09-24/16-workspace.md; twin record qdash cycles/c15 §todos plan 16). Decisions 16.1–16.5 were taken at their defaults. The Runs tile is out, so the band is Harnesses · Tokens · Spend in three columns. The Harnesses table became Users: new lib/workspace-rollups.ts userRows() rolls agents_detail up per person with the team from /api/teams, the columns are user · team · harnesses · sessions · tokens · spend · last active, and a row click opens User detail. Recent runs is now Sessions (latest N), and "no runs yet" now reads sessions. The Surface lost its Endpoints axis and gained plan 02's SurfaceSkillsPanel. There is no backend change: the plan's skills[] was replaced by a client join (workspaceInstallIds() matches agents_detail system_id@host → /api/installations, then skillsOnInstalls()), which is equivalent on the seed because it has no duplicate adapter-on-host installs. Verified via :3030 (payments-core, all-time): the Users row tomas · Payments · 2 · 29 · 31.2M · $389.55 cross-foots with the curl Σ, and Skills reads deploy 2 · review-pr 2 · commit 1 · db-migrate 1. npm test 372. LATER: the shared Surface panels still say Calls, and the Surface lede still names endpoints. After shots: c92-todos0924-workspace-*. Committed qdash 8aac2792 + 47fdd603 (twin) as HEAD-based hunks; the Skills panel stays on disk because HEAD lacks skillsOnInstalls and SurfaceSection's slot.

todos plan 12 executed (2026-09-25): Skill (todos-2026-09-24/12-skill.md; twin record qdash cycles/c15 §todos plan 12). Mark, 2026-09-25: VS Code-style — file tray left, small editor right (tabs, Preview/Source with line numbers); UxFileTree + editor frame in the layer, unreleased. Decisions 12.1, 12.2, 12.3 and 12.5 were taken at their defaults; 12.4 became two layer components plus a UxCodeBlock prop, with no release. The Definition section is one UxEditorFrame. Its tray is a UxFileTree of the skill directory, with SKILL.md first, ⚙ for executables, ○ for bundled-only files and a footer caption. The editor shows one tab and a Preview / Source UxTabGroup in #toolbar. Preview shows the evidence line, frontmatter pills (drifted keys warning-tinted), dashed decoded pills and the lib/skill-markdown body. Source is UxCodeBlock lineNumbers. Other files open an inventory card that gives size · lines · mode, "Referenced from SKILL.md line N — body line M" and "Contents not captured" once. The Bundle section is gone. Surface is out; its five Reach tiles now sit under the editor. The band is now Installs 24 · Invocations 0: skillBand() drops people and candidates.provenance, with two test assertions removed. Verified via :3030 (7d): deploy canonical has preflight.sh at 1.3 KB · 52 lines · executable · line 12 / body line 7. The drift definition 3b2e6f7c adds force-unlock.sh ⚙ ○, the Rollback section and a warning-tinted allowed-tools pill. commit has a one-row tree. Tray keyboard works, and there are no Bundle or Surface headings. The console is clean. npm test 372. The design site documents UxFileTree (empty / single / typical / adornments / overflow) and UxEditorFrame (full composition, minimal, typical, long tab name, #tab), and adds a lineNumbers scenario to UxCodeBlock. LATER: line highlight for "show in source", multiple tabs, and file contents (12.3). After shots: c92-todos0924-skill-*. Committed layer c28b37c (local main, unpushed) and qdash 0f55fd7a (twin). The page and skillBand hunks stay on disk because they sit on the uncommitted skill-definition build and need the unreleased layer.

todos plan 12 follow-up (2026-09-25, Mark): "In the skill definition section, can we have a syntax highlighter for .md files?" The layer's UxCodeBlock gains an optional lang prop. It uses highlight.js core on a private instance with four grammars: markdown/md, yaml/yml, bash/sh/shell/zsh and json. highlight.js ^11.12.0 is now a layer dependency; the lockfile gained only that package. For markdown, a leading --- frontmatter block is highlighted as YAML, because hljs would read its last line as a setext heading. Fenced blocks are highlighted in their info-string language, and left plain when the language isn't registered. An unknown lang renders escaped plain text. Without lang the render is unchanged: the design demo's SSR body was byte-identical before and after the layer edit, apart from nondeterministic icon ids. The .hljs-* classes map to tokens in an unscoped <style> anchored under .ux-codeblock-hl, so the no-lang DOM gains no scope attribute:

• headings: brightest text, bold
• attr / bullet / keyword: primary (dark: grape-400)
• string / code: leaf-600 with dark:leaf-300 (dark block: leaf-300)
• number / literal / built_in / variable / link: signal-info (dark: grape-200)
• comment / meta: content-subtle (dark: grey-500)
• quote: content-muted, italic

qdash inventory/skills/detail.vue: the Source view's UxCodeBlock passes lang="markdown". It's the only raw SKILL.md on the page. Verified on :3030:

• deploy canonical: frontmatter keys grape and values green, headings bold, list markers grape, inline code green.
• The drift 3b2e6f7c highlights its Rollback section the same way.
• commit works.
• The gutter matches the code height (18 / 22 / 15 lines), copy yields the raw text, and the console is clean.

qdash resolves highlight.js through the local layer's node_modules: Vite pre-bundled highlight__js_lib_* on first use, with no qdash install. npm test passes (372). The design demo gains a lang control and seven scenarios: SKILL.md with frontmatter plus fenced bash and toml, dark and light + lineNumbers, bash, json, an unknown-lang fallback that shows <script> as text, and long yaml lines in both themes. The registry entry gains lang. After shot: c92-todos0924-skill-source-highlight.png (+ -full), subject page/skill-detail. Committed layer ebbd424 (local main, unpushed, unreleased: pending 0.9.22) and the qdash twin record eacca125. The qdash page edit stays on disk with the rest of plan 12's page. LATER: line highlight for "show in source", and more grammars on demand (toml, ts).

detail-titles (2026-09-26): Mark: "exploring adding the title of the various details page to the title bar / breadcrumb, let's experiment with Harness Detail", then "let's add it to all the details pages" (detail-titles-prompt.md; executed directly, no plan; twin record qdash cycles/c15 §detail-titles). qdash PageHeader passes titleSize to UxPageTitle; every detail page closes its breadcrumb with the entity name at crumb size (15px — ActorHeader keeps the hero name; ids mono), and a new useDetailTitle composable names the browser tab <name> · <section> · qdash. Then "restructure so that accounts appears under providers so that the nav item is highlighted": Account detail moved to /inventory/providers/accounts/detail (links + Working nav repointed; todos-pages.json route updated). Verified on :3030 across all 12 detail pages. Committed qcontrol cc411276 (Header, composable, the nine tracked detail pages); Endpoint / Account / User / Team detail hunks and the Account move stay on disk with their uncommitted pages. Open: Harness install's trail reads Inventory / Claude Code, same as Harness detail — Inventory / Harnesses / Claude Code / <user> offered.

toggle-cell (2026-09-26): Control Center policy rows — Mark: "there are times where I accidentally trigger the toggle when I mean to open the page…" (toggle-cell-prompt.md with toggle-cell-reference.webp / toggle-cell-open-track.png; executed directly; twin record qdash cycles/c15 §toggle-cell). The toggle <td> is its own zone: grape wash (10%) + inset outline on hover; the row's hover muted with :has() (colours only — zeroing border widths caused a one-pixel row jump); any click in the cell toggles and never expands the row; toggling ON no longer auto-opens the row; the off track darkens on expanded rows (content/18%) and on hover (26%). A "stuck" wash turned out to be stale Chromium paint from the layer's ._stretchy td fade (computed background already clear) — !transition-none on the cell. All page-local in pages/controls/index.vue; layer untouched. Committed qcontrol ae1dc78f (the harness-rename's egress wording hunk in the same file stays on disk); pushed feat/new-pages @ 52fa4de7. No dist rebuild (Mark: this session's hunks only).

team-nav (2026-09-26): Mark: "let's add a team nav item under the fleet, when clicked show these sub item listing pages : users, team & endpoints", then Sessions too, then "endpoints and session need to be moved physically to a team subdir … what do you think makes the most sense?" (team-nav-prompt.md; executed directly, no plan; twin record qdash cycles/c15 §team-nav). IA ruling: Inventory = what's in the fleet (equipment); Team = who and from where — Users, Teams, Endpoints, Sessions, all moved to /team/* (pages physically under pages/team/, ~100 links rewritten, breadcrumbs Team / …, a team-routes.global.ts middleware redirects the old /users, /teams, /inventory/endpoints, /inventory/sessions paths with query kept). THE FLEET is now Fleet Overview · Inventory · Team; Fleet Overview moved off / to /fleet. Landings: /fleet, /inventory, /team render a new DesignInProgress component (48px bold headline, one line, the section's listings stacked left between hairlines) — the Inventory overview and Fleet Overview they replaced are saved here as *-pre-placeholder.vue (Harness install detail keeps its door through Harness detail's installs ledger). Home: / is the page behind the sidebar logo; its content is the Working jump list, extracted from AppSidebar into WorkingNav (sidebar toggle + home share one example fetch). Verified on :3030 and on the rebuilt release binary against the seed (:7881); vitest 372, cargo test qdash 76. Committed with the whole qcontrol + layer trees at Mark's ask ("let's commit all the changes in qcontrol and q-nuxt-layer … and build etc"): layer 764ce82 (c95 listing strip) + 25fdf9f (c92 band-polish restyle); qcontrol 4e5795f6 (backend + qevents skill-definition schema + seed), 38a74e88 (UI — this thread plus every c92 thread on disk), 480de013 (dist from local layer 25fdf9f). Unpushed; layer unreleased (pending 0.9.22 — qdash's lockfile still pins the old layer SHA).

team-details executed (2026-09-23, phase 3): /teams/detail?team=<name> in qdash from the c90 qcontrol/team mock on the actor frame, per Mark's ask ("a new details page for team — follow the existing details page patterns; cogitate deeply on what the top data machines should show" — team-details-prompt.md, executed directly; twin record qdash cycles/c15 §team-details). The band, one tile per reader: Tokens · Sessions as the chart's clickable tiles over the team's own session rows; People (covered · partial · not seen segment bar — an assignment with no telemetry is real here), Active (adoption in the window, 30d intensity bar), Harnesses (monitored / detected-only donut, devices in the sentence), Spend (top-3 members as ranked bars, the concentration device). Data: no backend change — teamRoster / teamAttention / teamBand over the Users listing's rows and the raw assignments (vitest 318, +12), so every tile equals the Teams listing's row; unassigned served as a page with an honest-absence Surface. Doors: teams.vue → teams/index.vue; the solo Teams row click, /teams?team=, User detail's team subline, Cost Center's team row and the Working nav all open it; ⁂ glyph. Verified headless on the seed :7879: 90 checks, 0 failures over 11 page loads, both themes, console clean. Not done: commit, dist, design-site demo (no new layer component).

(phase 3 open — Sessions listing, Device Details, each its own thread; filled in at completion)