@sergeychuvayev/claude-fleet 0.6.0 → 0.8.0

package/README.md

@@ -121,6 +121,55 @@ session's own process and never appear as separate rows at all.
 
 </details>
 
+### The status bar watches the account, not the session
+
+Context pressure is per conversation. The five-hour and weekly plan windows are not:
+every Claude process on the machine draws on the same ones, including the terminal
+sessions Fleet only watches. They get one line along the bottom of the window.
+
+```
+5h ▇▇▇▇▇▇░░░░ 62%  resets 13:28   ·   week 31%   ·   opus wk 48%
+```
+
+Only the window closest to stopping you gets a bar; the rest stay bare numbers. The
+same 75% amber and 90% red as context, so "nearly full" reads the same way everywhere.
+Past 90% the countdown replaces the bar, because by then the question is when it clears,
+not how full it is.
+
+When a request is actually refused, the bar turns into the refusal, and the new-agent
+dialog says so before you write a prompt:
+
+```
+⊘ Rate limited · five-hour window · resets 11:42 (35m) · organisation spend cap reached
+```
+
+<details>
+<summary><b>Where the numbers come from, and when they are missing</b></summary>
+
+Three sources, none of them available all the time:
+
+| Source | Gives | Available |
+|---|---|---|
+| `rate_limit_event` | utilisation, reset | only while a Fleet agent streams |
+| The runtime's `/usage` data | every window, the plan | pulled once at the end of a turn |
+| A refused request in any transcript | the wall and its reset | whenever it happened, to any session |
+
+Nothing here ever spends a token to find out: a synthetic request would consume the
+window it claims to measure. That has consequences the bar is explicit about.
+
+Utilisation only refreshes while an agent is running, so after an idle stretch the
+cluster dims and stamps itself `as of 09:38` rather than presenting an old reading as
+current. Nothing measured yet shows nothing at all, never `0%`. On an API key, Bedrock
+or Vertex, where plan limits do not apply, the cluster is absent entirely.
+
+A refusal is the one signal that survives Fleet being idle, because it is written into
+the transcript of whichever session hit it. It expires by itself at its reset time, and
+a refusal with no reset time is discarded rather than shown: a warning that cannot
+clear itself is worse than none. Being blocked never disables anything. Fleet says what
+it knows and leaves the decision where it belongs.
+
+</details>
+
 ### Old sessions can be put away
 
 Every transcript Claude has ever written is a row, so a machine that has been
@@ -412,7 +461,11 @@ In **New agent**, choose **Software delivery** to give a brief to a Manager back
 Product, Developer, Reviewer and QA roles. Choose **Customize team…** to save your own
 team: rename/add/remove roles, write their instructions, select a Claude model per role,
 and choose allowed tools. Built-in teams are copied; existing custom teams can be edited.
-The original Bug fix preset remains available for existing workflows.
+Choose **Quick task** for small, clearly scoped changes: a Sonnet manager, one developer,
+and one independent QA verifier, with two implementation attempts and a $3 usage cap.
+**Software delivery** keeps the thorough review-and-QA workflow. **No team · single agent**
+avoids orchestration entirely when you just need one agent. Existing initiatives keep
+their original team snapshot. The original Bug fix preset remains available.
 
 One role is the manager and at least one separate role is a required verifier. A third
 role owns the work. Fleet adds delegation and operator-question tools to the manager;
@@ -431,7 +484,7 @@ not a guarantee that their evaluation is correct or that later work cannot regre
 
 Delegations run sequentially in the shared initiative worktree. After an interruption,
 the saved task board survives and unfinished delegations are marked interrupted. Message
-the Manager to resume. The initial limits are three implementation attempts per task and
+the Manager to resume. Software delivery starts with three implementation attempts per task and
 $10 in reported SDK usage; **Adjust limits** changes them explicitly while idle. The SDK
 budget is an execution cutoff, not a billing guarantee: usage is reported at turn end,
 and a killed runtime may not report its final spend. Each turn also has a 100-turn SDK
@@ -442,3 +495,21 @@ snapshots live with the initiative in `sessions.json`. This version supports mod
 available through the Claude Agent SDK, up to eight roles per team, and 100 tasks per
 initiative. It finishes at a local branch ready for review; it does not automatically
 publish or merge changes.
+
+### Inspect individual agents
+
+Select a subagent row beneath a managed initiative to inspect its assignment, actual
+model, status, elapsed time, attempt, tool steps, and report. Expand **Input and output**
+to see a tool's recorded payload. The inspector is read-only; send direction and answer
+approvals through the manager. Tool history keeps the most recent 200 steps with bounded
+inputs and outputs. Older runs may have no recorded steps or usage.
+
+The inspector shows reported input/output and cache tokens, or SDK progress totals when
+only those are available. Repeated assistant events do not count usage twice. Per-agent
+cost appears only when the SDK explicitly reports it; missing data is not shown as zero.
+Token totals describe recorded usage across messages, not current context size.
+
+Task-board reads return compact metadata, so repeatedly checking task state does not
+re-inject all assignments, tool output and reports into the manager's context. The manager
+can request a specific delegation's full assignment/report using the task tool's
+`inspect` action with `delegationId`. Verification gates and saved evidence are unchanged.

package/fleet.js

@@ -189,6 +189,9 @@ function readTranscript(file) {
     events: [],
     cwd: null,
     gitBranch: null,
+    // The newest 429 this transcript recorded, if any. Plan limits are account-wide, so
+    // a rejection here describes the whole machine, not only this session.
+    rateLimit: null,
   }
 
   for (const line of text.split('\n')) {
@@ -209,6 +212,16 @@ function readTranscript(file) {
       if (!data.firstTs) data.firstTs = d.timestamp
       data.lastTs = d.timestamp
     }
+    // Claude records the quota it hit only when a request was actually refused. There is
+    // no routine utilisation record to read here, so this is a wall, never a gauge.
+    if (d.quotaLimits && d.quotaLimits.status === 'rejected') {
+      data.rateLimit = {
+        at: d.timestamp ? Date.parse(d.timestamp) || null : null,
+        rateLimitType: d.quotaLimits.rateLimitType || null,
+        resetsAt: d.quotaLimits.resetsAt || null,
+        reason: d.quotaLimits.overageDisabledReason || null,
+      }
+    }
     if (d.timestamp) {
       const at = Date.parse(d.timestamp)
       if (at) for (const event of classify(d)) {
@@ -349,6 +362,7 @@ function collect() {
   const index = transcriptIndex()
   const now = Date.now()
   const sessions = []
+  let rateLimit = null
 
   // The registry describes running processes, not saved conversations: Claude
   // removes registrations on exit. Join it with durable transcripts so handoff
@@ -373,6 +387,10 @@ function collect() {
     const file = meta.sessionId ? index.get(meta.sessionId) : null
     const t = file ? readTranscript(file) : null
 
+    // Whoever hit the wall, the wall is the account's. The freshest rejection on this
+    // machine describes the whole fleet, including sessions Fleet only watches.
+    if (t && t.rateLimit && (!rateLimit || (t.rateLimit.at || 0) > (rateLimit.at || 0))) rateLimit = t.rateLimit
+
     const lastActivity = Math.max(
       meta.updatedAt || 0,
       t && t.lastTs ? Date.parse(t.lastTs) : 0
@@ -436,7 +454,7 @@ function collect() {
   const counts = { busy: 0, idle: 0, stale: 0, dead: 0 }
   for (const s of sessions) counts[s.state] = (counts[s.state] || 0) + 1
 
-  return { generatedAt: now, counts, total: sessions.length, sessions }
+  return { generatedAt: now, counts, total: sessions.length, sessions, rateLimit }
 }
 
 // Look up a transcript by session id without going through the process registry.

package/managed.js

@@ -9,6 +9,7 @@ const { askReason, normaliseMode, MODES, DEFAULT_MODE } = require('./permissions
 const { stateDir } = require('./paths')
 const { getTeam, compile } = require('./teams')
 const { TeamStore } = require('./team-store')
+const { UsageTracker } = require('./usage')
 const tasks = require('./tasks')
 const worktrees = require('./worktree')
 
@@ -63,6 +64,10 @@ class ManagedSessions extends EventEmitter {
     this.closed = false
     this.models = null
     this.saveTimer = null
+    // Plan windows belong to the account, so one tracker serves every session and
+    // outlives all of them. It is deliberately not persisted: a utilisation figure from
+    // before a restart describes a window that has probably already turned over.
+    this.usage = new UsageTracker()
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 })
     this.file = path.join(directory, 'sessions.json')
     this.attachmentsDir = path.join(directory, 'attachments')
@@ -353,24 +358,38 @@ class ManagedSessions extends EventEmitter {
   }
   event(s,run,event) {
     if (event.session_id && !event.parent_tool_use_id) s.sessionId=event.session_id
+    // Account-wide, so it is recorded whoever emitted it, sub-agent turns included.
+    if (event.type==='rate_limit_event') this.usage.recordEvent(event.rate_limit_info)
     if (s.taskBoard && event.parent_tool_use_id) {
       const d=s.taskBoard.delegations.find(d=>d.id===event.parent_tool_use_id)
       if (d && event.type==='assistant') {
         const content=event.message.content || []
         d.activity=content.filter(b=>b.type==='tool_use').map(b=>b.name).join(', ') || d.activity
         d.model=event.message.model || d.model
+        this.delegationUsage(d,run,event.message)
         const output=content.filter(b=>b.type==='text').map(b=>b.text).join('\n')
         if (output) d.output=output.slice(0,24000)
         // The one place a sub-agent's own tool calls are kept at all: as steps on its
         // delegation, never as messages (every branch above stays guarded by
-        // `!event.parent_tool_use_id`). No input, no result; those belong to d.report.
+        // `!event.parent_tool_use_id`). Inputs and results are bounded for inspection.
         for (const block of content) if (block.type==='tool_use') this.stepStarted(d,block)
       }
+      if (d && event.type==='result' && Number.isFinite(event.total_cost_usd) && event.total_cost_usd>=0) d.costUsd=event.total_cost_usd
       if (d && event.type==='user') {
         for (const block of event.message?.content || []) if (block.type==='tool_result') this.stepFinished(d,block)
       }
     }
-    if (event.type === 'system' && event.subtype === 'init') { s.model=event.model; s.status='running' }
+    if (s.taskBoard && event.type==='system' && ['task_progress','task_notification'].includes(event.subtype)) {
+      const d=s.taskBoard.delegations.find(d=>d.id===event.tool_use_id)
+      if (d && event.usage) {
+        d.runtimeUsage ||= {}
+        for (const key of ['total_tokens','tool_uses','duration_ms']) {
+          const value=event.usage[key]
+          if (Number.isFinite(value) && value>=0) d.runtimeUsage[key]=Math.max(d.runtimeUsage[key] || 0,value)
+        }
+      }
+    }
+    if (event.type === 'system' && event.subtype === 'init' && !event.parent_tool_use_id) { s.model=event.model; s.status='running' }
     if (event.type === 'stream_event' && !event.parent_tool_use_id) {
       if (event.event.type === 'message_start') { run.assistant=null; run.streamText='' }
       if (event.event.delta?.type === 'text_delta') {
@@ -398,17 +417,29 @@ class ManagedSessions extends EventEmitter {
     if (event.type === 'user' && !event.parent_tool_use_id) {
       for (const block of event.message?.content || []) if (block.type==='tool_result') this.toolFinished(s,run,block)
     }
-    if (event.type === 'tool_progress') s.currentTool=event.tool_name
+    if (event.type === 'tool_progress' && !event.parent_tool_use_id) s.currentTool=event.tool_name
     if (s.taskBoard && event.type==='system' && event.subtype==='task_notification' && event.tool_use_id && event.status!=='completed') tasks.finish(s,event.tool_use_id,event.summary,true)
-    if (event.type === 'result') {
+    if (event.type === 'result' && !event.parent_tool_use_id) {
       run.result=true
       if (event.is_error) { s.status='error'; s.error=event.errors?.join('\n') || event.result || 'Claude could not finish this turn.' }
       else if (event.result && !s.messages.some(m=>m.role==='assistant' && m.text===event.result.slice(-24000))) s.messages.push({id:randomUUID(),role:'assistant',text:event.result.slice(-24000),at:Date.now()})
       s.costUsd=(s.costUsd||0)+(event.total_cost_usd||0)
       s.messages=s.messages.slice(-MAX_MESSAGES)
+      this.captureUsage(run)
     }
     this.changed(s)
   }
+  // The end of a turn is the one moment a query is both idle and still open, so it is
+  // where the every-window reading is taken. Fire and forget: the push event already
+  // carries the window that matters, this only fills in the rest. The method is marked
+  // experimental upstream and may simply not be there, which is not an error.
+  captureUsage(run) {
+    if (!run || run.usagePulled) return
+    const pull=run.query?.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET
+    if (typeof pull!=='function') return
+    run.usagePulled=true
+    Promise.resolve(pull.call(run.query)).then(response=>this.usage.recordUsage(response)).catch(()=>{})
+  }
   // A tool call becomes its own conversation entry so the UI can render it as a command block.
   toolStarted(s,run,block) {
     if (!block.id || run.tools?.has(block.id)) return
@@ -441,13 +472,13 @@ class ManagedSessions extends EventEmitter {
     entry.result = block.is_error || !QUIET_RESULT.has(entry.tool) ? result.slice(0,MAX_TOOL_RESULT) : null
   }
   // A sub-agent's tool call becomes a step on its delegation rather than a conversation
-  // entry: name, target, status and timing only, so the operator can see what happened
+  // entry: bounded input/output, status and timing, so the operator can see what happened
   // without the console ever rendering it.
   stepStarted(d,block) {
     if (!block.id) return
     d.steps ||= []
     if (d.steps.some(step=>step.id===block.id)) return
-    d.steps.push({id:block.id,tool:block.name || 'Tool',target:toolTarget(block.name,block.input),status:'running',at:Date.now(),ms:null})
+    d.steps.push({id:block.id,tool:block.name || 'Tool',target:toolTarget(block.name,block.input),input:clampInput(block.input),result:null,status:'running',at:Date.now(),ms:null})
     if (d.steps.length > MAX_DELEGATION_STEPS) { d.steps=d.steps.slice(-MAX_DELEGATION_STEPS); d.stepsTruncated=true }
   }
   stepFinished(d,block) {
@@ -455,6 +486,26 @@ class ManagedSessions extends EventEmitter {
     if (!step || step.status!=='running') return
     step.status=block.is_error ? 'error' : 'done'
     step.ms=Date.now()-step.at
+    const result=resultText(block.content)
+    step.result=result.slice(0,MAX_TOOL_RESULT)
+    step.truncated=result.length>MAX_TOOL_RESULT
+  }
+  // The SDK can emit multiple blocks for the same assistant message. Count each
+  // usage counter only once, accepting later updates without double-counting.
+  delegationUsage(d,run,message) {
+    if (!message.id || !message.usage) return
+    run.delegationUsage ||= new Map()
+    const key=JSON.stringify([d.id,message.id])
+    const previous=run.delegationUsage.get(key) || {}
+    d.usage ||= {}
+    for (const field of ['input_tokens','output_tokens','cache_read_input_tokens','cache_creation_input_tokens']) {
+      const value=message.usage[field]
+      if (!Number.isFinite(value) || value<0) continue
+      const next=Math.max(previous[field] || 0,value)
+      d.usage[field]=(d.usage[field] || 0)+next-(previous[field] || 0)
+      previous[field]=next
+    }
+    run.delegationUsage.set(key,previous)
   }
   setLimits(id,body) {
     const s=this.get(id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sergeychuvayev/claude-fleet",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "A local control room for Claude Code sessions",
   "keywords": [
     "claude",
@@ -39,7 +39,8 @@
     "update.js",
     "worktree.js",
     "team-store.js",
-    "tasks.js"
+    "tasks.js",
+    "usage.js"
   ],
   "scripts": {
     "start": "node bin/claude-fleet.js start",

package/public/app.js

@@ -115,6 +115,68 @@ const childRowsHtml = s => {
   return (earlier ? `<div class="session-child-more">+${earlier} earlier</div>` : '') + shown.map(d => childRowHtml(s, d)).join('')
 }
 
+// ── Account usage ─────────────────────────────────────────────────────────────
+// The plan windows belong to the account, not to a session: every Claude process on
+// this machine draws on them, including the terminal sessions Fleet only watches. The
+// bar says so, and it uses the same thresholds and colours as context pressure so
+// "nearly full" reads the same way everywhere.
+const WINDOW_WORD = { five_hour:'five-hour', seven_day:'weekly', seven_day_opus:'weekly Opus', seven_day_sonnet:'weekly Sonnet', seven_day_oauth_apps:'weekly apps' }
+const BLOCK_REASON = {
+  org_spend_cap_reached:'organisation spend cap reached', out_of_credits:'out of credits',
+  overage_not_provisioned:'no overage configured', org_level_disabled:'overage off for this organisation',
+  member_level_disabled:'overage off for this member', no_limits_configured:'no overage limits set',
+  fetch_error:'usage lookup failed',
+}
+const clockAt = ms => new Date(ms).toLocaleTimeString([], {hour:'2-digit',minute:'2-digit'})
+const untilReset = (ms, now) => {
+  const left = ms - now
+  if (left <= 0) return 'any moment'
+  return left < 3600000 ? `${Math.max(1, Math.round(left / 60000))}m` : `${Math.floor(left / 3600000)}h ${Math.round(left % 3600000 / 60000)}m`
+}
+const blockReason = r => BLOCK_REASON[r] || (r ? String(r).replace(/_/g, ' ') : null)
+const windowWord = name => WINDOW_WORD[name] || String(name || '').replace(/_/g, ' ')
+function usageHtml(usage, now) {
+  // Unknown is not zero. With nothing measured, and on an API key or a third-party
+  // provider where plan limits do not apply at all, the cluster is simply absent.
+  if (!usage || !usage.available || !usage.known) return ''
+  const blocked = usage.blocked
+  if (blocked) return `<span class="usage-blocked hot" title="A request was refused by this window. Every Claude session on this machine is affected until it resets.">⊘ Rate limited · ${esc(windowWord(blocked.rateLimitType))} window · resets ${clockAt(blocked.resetsAt)} (${untilReset(blocked.resetsAt, now)})${blockReason(blocked.reason) ? ` · ${esc(blockReason(blocked.reason))}` : ''}</span>`
+  const binding = usage.windows.find(w => w.name === usage.binding) || usage.windows[0]
+  if (!binding) return ''
+  const cls = heat(binding.utilization)
+  // Past 90% the countdown is the decision and the percentage is trivia, so they swap.
+  const critical = binding.utilization >= 90
+  const reset = binding.resetsAt ? (critical ? `${untilReset(binding.resetsAt, now)} left` : `resets ${clockAt(binding.resetsAt)}`) : ''
+  const detail = [
+    usage.subscription ? `Plan: ${usage.subscription}.` : '',
+    'Account-wide, including the terminal sessions Fleet only watches.',
+    usage.observedAt ? `Last read ${clockAt(usage.observedAt)}.` : '',
+  ].filter(Boolean).join(' ')
+  // One bar, on whichever window is closest to stopping the fleet. The rest are bare
+  // numbers: a second bar would just be a second thing to look at.
+  const others = usage.windows.filter(w => w !== binding)
+    .map(w => `<span class="usage-other ${heat(w.utilization)}"><b>${esc(w.label)}</b> ${w.utilization}%</span>`).join('')
+  return `<span class="usage-window ${cls}${usage.stale ? ' is-stale' : ''}" title="${esc(detail)}"><b>${esc(binding.label)}</b>${critical ? `<em>${reset}</em><span class="usage-pct">${binding.utilization}%</span>` : `<span class="mini-bar"><i class="${cls}" style="width:${binding.utilization}%"></i></span><span class="usage-pct">${binding.utilization}%</span>${reset ? `<small>${reset}</small>` : ''}`}</span>${others}${usage.stale && usage.observedAt ? `<small class="usage-stale" title="Utilisation only updates while a Fleet agent is running.">as of ${clockAt(usage.observedAt)}</small>` : ''}`
+}
+function renderStatusbar(usage, sessions) {
+  const now = Date.now()
+  update('status-usage', usageHtml(usage, now))
+  const managed = sessions.filter(s => s.managed && !s.archived)
+  const waiting = managed.filter(s => s.managedStatus === 'approval').length
+  const working = sessions.filter(s => !s.archived && isWorkingRow(s)).length
+  const spend = managed.reduce((sum, s) => sum + (s.costUsd || 0), 0)
+  update('status-fleet', [
+    `<span>${working} working</span>`,
+    waiting ? `<span class="warn">${waiting} needs you</span>` : '',
+    money(spend) ? `<span title="Reported for Fleet’s own conversations only. Terminal sessions are not included, and a Claude subscription is not billed for this.">${esc(money(spend))}</span>` : '',
+  ].filter(Boolean).join('<span class="status-sep" aria-hidden="true">·</span>'))
+  // The same wall, said where it changes a decision: in the dialog that starts agents.
+  const banner = $('launch-blocked')
+  if (banner) {
+    banner.hidden = !usage?.blocked
+    if (usage?.blocked) banner.textContent = `Rate limited until ${clockAt(usage.blocked.resetsAt)} (${untilReset(usage.blocked.resetsAt, now)}). A new agent will not get past its first message until this window resets.`
+  }
+}
 function render() {
   if (!snapshot) return
   const {sessions, total} = snapshot
@@ -137,6 +199,7 @@ function render() {
   const shown = pool.filter(s => filter === 'all' || filter === 'background' || filter === 'archived' || s.state === filter)
   if (!shown.some(s => key(s) === selected)) selected = shown[0] ? key(shown[0]) : null
   $('shown-count').textContent = shown.length
+  renderStatusbar(snapshot.usage, live)
   update('filters', [['all','All sessions',foreground.length],...STATES.map(s => [s,LABELS[s],(visibleCounts[s] || 0)]),...(background.length ? [['background','Background',background.length]] : []),...(archived.length ? [['archived','Archived',archived.length]] : [])].map(([s,label,n]) => `<button class="filter" data-filter="${s}" aria-pressed="${filter === s}">${label}<span>${n}</span></button>`).join(''))
   renderArchiveBar(live.filter(s => s.state === 'dead'), archived.length)
   update('session-list', shown.length ? shown.map(s => {
@@ -234,12 +297,19 @@ function renderChildDetail(s, delegationId) {
   const cls = DELEGATION_BADGE[state] || ''
   const label = DELEGATION_LABEL[state] || state
   const steps = full?.steps || []
+  const openedSteps=new Set([...document.querySelectorAll('[data-child-step][open]')].map(el=>el.dataset.childStep))
+  const focusedStep=document.activeElement?.closest('[data-child-step]')?.dataset.childStep
+  const usage=full?.usage
+  const usageText=usage ? `${tokens(usage.input_tokens || 0)} input · ${tokens(usage.output_tokens || 0)} output · ${tokens(usage.cache_read_input_tokens || 0)} cache read · ${tokens(usage.cache_creation_input_tokens || 0)} cache write` : full?.runtimeUsage?.total_tokens != null ? `${tokens(full.runtimeUsage.total_tokens)} tokens reported` : 'Token usage not reported'
+  const duration=full?.startedAt ? elapsed((full.finishedAt || Date.now())-full.startedAt) : 'Duration unavailable'
+
   // Selecting a child tears down the console, so an approval sitting on the owning
   // session would otherwise wait in total silence. A notice only: nothing here can
   // answer it, so it just points the operator back to the row that can.
   const approvalNotice = s.managedStatus === 'approval' ? `<p class="note child-approval-notice">${esc(s.name || s.title || 'This session')} needs your approval to continue. Select its row above to respond — this read-only view can’t.</p>` : ''
-  const stepsHtml = steps.length ? `<ol class="child-steps">${steps.map(step => `<li class="child-step" data-status="${esc(step.status)}"><span class="child-step-tool">${esc(step.tool)}</span>${step.target ? `<span class="child-step-target">${esc(step.target)}</span>` : ''}<span class="child-step-state">${esc(STEP_LABEL[step.status] || step.status)}</span><span class="child-step-time">${step.ms != null ? elapsed(step.ms) : step.status === 'running' ? 'running…' : ''}</span></li>`).join('')}</ol>` : `<p class="note">${full ? 'No tool steps recorded.' : 'Loading steps…'}</p>`
-  update('detail-content', `<div class="detail-top"><span class="eyebrow">SUB-AGENT · READ ONLY</span><span class="badge ${cls}"><span class="dot"></span>${esc(label)}</span></div>${approvalNotice}<h2>⑂ ${esc(compact.role)}</h2><div class="detail-name">${esc(formatModel(full?.model || compact.model))}</div><section class="detail-section"><h3>Mandate</h3><div class="response">${esc(full ? (full.prompt || 'No mandate recorded.') : 'Loading…')}</div></section><section class="detail-section"><h3>Steps${full?.stepsTruncated ? ' <span>Showing the most recent 200</span>' : ''}</h3>${stepsHtml}</section><section class="detail-section"><h3>Report to the manager</h3><div class="response ${full?.report ? '' : 'missing'}">${esc(full ? (full.report || 'Waiting for this agent’s report.') : 'Loading…')}</div></section>${childDetailError ? `<p class="note">${esc(childDetailError)}</p>` : ''}<p class="note">A sub-agent is not addressable on its own. This is a read-only report back to the manager.</p>`)
+  const stepsHtml = steps.length ? `<ol class="child-steps">${steps.map(step => `<li class="child-step" data-status="${esc(step.status)}"><span class="child-step-tool">${esc(step.tool)}</span>${step.target ? `<span class="child-step-target">${esc(step.target)}</span>` : ''}<span class="child-step-state">${esc(STEP_LABEL[step.status] || step.status)}</span><span class="child-step-time">${step.ms != null ? elapsed(step.ms) : step.status === 'running' ? 'running…' : ''}</span>${step.input != null || step.result != null ? `<details class="child-step-detail" data-child-step="${esc(step.id)}" ${openedSteps.has(step.id) ? 'open':''}><summary>Input and output</summary><h4>Input</h4><pre>${esc(step.input == null ? 'Not recorded' : typeof step.input === 'string' ? step.input : JSON.stringify(step.input,null,2))}</pre><h4>Output${step.truncated ? ' · truncated':''}</h4><pre>${esc(step.result ?? 'No result reported yet.')}</pre></details>`:''}</li>`).join('')}</ol>` : `<p class="note">${full ? 'No tool steps recorded.' : 'Loading steps…'}</p>`
+  update('detail-content', `<div class="detail-top"><span class="eyebrow">SUB-AGENT · READ ONLY</span><span class="badge ${cls}"><span class="dot"></span>${esc(label)}</span></div>${approvalNotice}<h2>⑂ ${esc(compact.role)}</h2><div class="detail-name">${esc(formatModel(full?.model || compact.model))} · ${esc(duration)}${full?.attempt ? ` · attempt ${full.attempt}` : ''}</div><p class="note">${esc(usageText)}. ${full?.costUsd != null ? `Reported cost: ${esc(money(full.costUsd) || '$0.00')}` : 'Per-agent cost not reported'}.</p><section class="detail-section"><h3>Mandate</h3><div class="response">${esc(full ? (full.prompt || 'No mandate recorded.') : 'Loading…')}</div></section><section class="detail-section"><h3>Steps${full?.stepsTruncated ? ' <span>Showing the most recent 200</span>' : ''}</h3>${stepsHtml}</section><section class="detail-section"><h3>Report to the manager</h3><div class="response ${full?.report ? '' : 'missing'}">${esc(full ? (full.report || 'Waiting for this agent’s report.') : 'Loading…')}</div></section>${childDetailError ? `<p class="note">${esc(childDetailError)}</p>` : ''}<p class="note">A sub-agent is not addressable on its own. This is a read-only report back to the manager.</p>`)
+  if(focusedStep) document.querySelector(`[data-child-step="${CSS.escape(focusedStep)}"]>summary`)?.focus({preventScroll:true})
 }
 // The list payload only ever carries id/role/model/status for a delegation; its steps,
 // mandate and report live on the session detail route, fetched independently of the

package/public/index.html

@@ -1,10 +1,11 @@
 <!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="color-scheme" content="dark"><title>Fleet — Claude Code control room</title><link rel="manifest" href="/manifest.webmanifest"><link rel="icon" href="/icons/fleet-192.png" type="image/png"><link rel="apple-touch-icon" href="/icons/fleet-192.png"><meta name="apple-mobile-web-app-capable" content="yes"><meta name="apple-mobile-web-app-title" content="Fleet"><link rel="stylesheet" href="/theme.css"><link rel="stylesheet" href="/styles.css"><script src="/vendor/libs.js" defer></script><script src="/app.js" defer></script><script src="/blocks.js" defer></script><script src="/control.js" defer></script><script src="/teams.js" defer></script><script src="/ask.js" defer></script></head>
-<body><header class="topbar"><a class="brand" href="/" aria-label="Fleet home"><span class="brandmark">✳</span> fleet <span class="brand-sub">/ CLAUDE CODE</span></a><span class="app-version" id="app-version" title="The version of Fleet this server is running"></span><div class="connection"><span id="connection-dot" class="dot busy"></span><span id="connection">Connecting</span><span class="local">LOCAL CONTROL ROOM</span></div><div class="refresh-info"><button id="update-pill" class="button update-pill" hidden></button><span id="updated">Waiting for first snapshot</span><button id="refresh" class="button">↻ Refresh</button><button id="ask-sessions" class="button" aria-expanded="false" aria-controls="ask-backdrop" title="Ask a question across every session on this machine">⌕ Ask <kbd id="ask-shortcut">⌘K</kbd></button><button id="new-session" class="button resume" aria-expanded="false" aria-controls="launch-backdrop">＋ New agent</button></div></header>
+<body><header class="topbar"><a class="brand" href="/" aria-label="Fleet home"><span class="brandmark">✳</span> fleet <span class="brand-sub">/ CLAUDE CODE</span></a><span class="app-version" id="app-version" title="The version of Fleet this server is running"></span><div class="refresh-info"><button id="update-pill" class="button update-pill" hidden></button><button id="refresh" class="button">↻ Refresh</button><button id="ask-sessions" class="button" aria-expanded="false" aria-controls="ask-backdrop" title="Ask a question across every session on this machine">⌕ Ask <kbd id="ask-shortcut">⌘K</kbd></button><button id="new-session" class="button resume" aria-expanded="false" aria-controls="launch-backdrop">＋ New agent</button></div></header>
 <main>
 <div id="error" class="error" role="status" hidden></div>
 <section class="workspace" aria-label="Sessions"><div class="sessions-pane"><div class="section-heading"><h2>Sessions <span id="shown-count">0</span></h2></div><div class="filters" id="filters" aria-label="Filter sessions by status"></div><div class="archive-bar" id="archive-bar" role="group" aria-label="Archive" hidden></div><div class="list-head"><span>SESSION / PROJECT</span><span>CONTEXT</span></div><div id="session-list" class="session-list"><div class="empty">Loading your sessions…</div></div></div><div id="splitter" class="splitter" role="separator" aria-orientation="vertical" aria-label="Resize the session inspector" aria-valuemin="25" aria-valuemax="75" aria-valuenow="58" tabindex="0" title="Drag to resize · double-click to reset"></div><aside id="detail" class="detail" aria-label="Session details"><section id="control-panel" aria-label="Agent controls"></section><button type="button" id="details-toggle" class="details-toggle" aria-expanded="true" aria-controls="detail-content" hidden><span class="details-chevron" aria-hidden="true">›</span>Session details</button><div id="detail-content"></div></aside></section>
 </main>
+<footer class="statusbar" id="statusbar"><div class="status-usage" id="status-usage"></div><div class="status-fleet" id="status-fleet"></div><div class="status-conn"><span id="connection-dot" class="dot busy"></span><span id="connection">Connecting</span><span id="updated">Waiting for first snapshot</span><span class="local">LOCAL CONTROL ROOM</span></div></footer>
 <div class="modal-backdrop" id="ask-backdrop" hidden>
   <section class="modal modal-ask" role="dialog" aria-modal="true" aria-labelledby="ask-title">
     <header class="modal-head">
@@ -31,6 +32,7 @@
   <section class="modal modal-launch launch-panel" role="dialog" aria-modal="true" aria-labelledby="launch-title">
     <header class="modal-head"><div class="modal-heading"><span class="modal-spark" aria-hidden="true">✳</span><div><span class="modal-eyebrow">A FRESH PAIR OF HANDS</span><h2 id="launch-title">Give your next task a home.</h2><p>A little context. A clear task. Off you go.</p></div></div><button type="button" id="close-launch" class="modal-close" data-close-modal aria-label="Close new agent form">✕</button></header>
     <form id="launch-form" class="modal-body">
+      <p id="launch-blocked" class="rate-warning" role="status" hidden></p>
       <div class="launch-layout">
         <div class="launch-task"><label for="launch-prompt">What are we working on?</label><textarea id="launch-prompt" name="prompt" rows="8" placeholder="There’s something I’d love your help with…&#10;&#10;Describe the task, what a good result looks like, and anything your agent should know." required maxlength="16000"></textarea><p class="note launch-task-note">Big ideas, small fixes. Every task starts here.</p></div>
         <div class="launch-fields">

package/public/styles.css

@@ -463,7 +463,10 @@ body[data-modal]{overflow:hidden}
 .delegation-mandate .block-prose,.delegation-report .block-prose{padding:12px 0 0}
 .delegation-mandate .block-plain,.delegation-report .block-plain{white-space:pre-wrap;overflow-wrap:anywhere}
 
-.app-version{align-self:center;margin-left:8px;color:var(--muted);font-size:10px;letter-spacing:.04em;font-variant-numeric:tabular-nums}
+/* The version belongs to the wordmark. With connection state moved to the status bar
+   it is the only thing left between the brand and the buttons, so it is pinned here
+   rather than left to drift into the middle of the bar. */
+.app-version{align-self:center;margin-left:8px;margin-right:auto;color:var(--muted);font-size:10px;letter-spacing:.04em;font-variant-numeric:tabular-nums}
 .session-cost{font-variant-numeric:tabular-nums}
 
 /* Configurable teams share the launch dialog and the Warp console palette. */
@@ -516,3 +519,44 @@ body[data-modal]{overflow:hidden}
 /* Selecting a child hides the console, so a pending approval on the owning session
    would otherwise go unnoticed; this is the one visible sign it is still waiting. */
 .child-approval-notice{color:var(--text);background:color-mix(in srgb,var(--stale) 14%,transparent);border:1px solid var(--stale);border-radius:6px;padding:10px 12px;margin-bottom:17px}
+
+/* Drill into a tool without expanding every payload in the agent inspector. */
+.child-step-detail{grid-column:1/-1;min-width:0}
+.child-step-detail summary{cursor:pointer;color:var(--muted);padding:4px 0}
+.child-step-detail pre{white-space:pre-wrap;overflow-wrap:anywhere;max-height:320px;overflow:auto;font-size:12px}
+.child-step-detail h4{margin:10px 0 4px;font-size:12px}
+
+/* ── Status bar ────────────────────────────────────────────────────────────────
+   Ambient telemetry at the bottom, actions at the top. The plan windows belong to
+   the account rather than to any one session, so they are drawn once here and never
+   on a row: every Claude process on this machine spends the same five hours. */
+.statusbar{flex:none;display:flex;align-items:center;gap:14px;height:26px;padding:0 14px;border-top:1px solid var(--line);background:color-mix(in oklab,var(--w-bg) 96%,var(--w-fg));font:10.5px/1 var(--mono);color:var(--muted);font-variant-numeric:tabular-nums;white-space:nowrap;overflow:hidden}
+.status-usage{display:flex;align-items:center;gap:12px;min-width:0;overflow:hidden}
+.status-fleet{display:flex;align-items:center;gap:7px;margin-left:auto;flex:none}
+.status-conn{display:flex;align-items:center;gap:8px;flex:none;border-left:1px solid var(--line);padding-left:14px}
+.status-conn .local{border:0;margin:0;padding:0;font-size:9px}
+.status-sep{color:var(--line)}
+.usage-window{display:flex;align-items:center;gap:7px}
+.usage-window b,.usage-other b{font-weight:600;letter-spacing:.3px;color:var(--text)}
+.usage-window.warn b,.usage-window.hot b{color:currentColor}
+/* The countdown, shown instead of the bar once the window is nearly gone. */
+.usage-window em{font-style:normal;font-weight:600}
+.usage-window small,.usage-stale{color:var(--faint);font-size:10px}
+.status-usage .mini-bar{display:block;width:58px;height:4px;margin:0;flex:none}
+.usage-pct{color:var(--text)}
+.usage-window.warn .usage-pct,.usage-window.hot .usage-pct{color:currentColor}
+.usage-other{display:flex;align-items:center;gap:5px;color:var(--faint)}
+.usage-other b{font-weight:500;color:var(--muted)}
+/* A reading only refreshes while an agent runs. An idle hour must not look live, and
+   every window in the cluster shares the one timestamp, so they dim together. */
+.status-usage:has(.is-stale){opacity:.55}
+.usage-blocked{display:flex;align-items:center;gap:7px;font-weight:600}
+/* The same wall, repeated where it changes a decision rather than only informing one. */
+.rate-warning{font-size:12px;line-height:1.6;color:var(--stale);border:1px solid color-mix(in oklab,var(--stale) 45%,var(--line));background:color-mix(in oklab,var(--stale) 9%,var(--panel));border-radius:8px;padding:11px 14px;margin:0 32px 14px}
+@media(max-width:720px){.rate-warning{margin:0 20px 12px}}
+/* The form scrolls inside the dialog and was already within a few pixels of pushing its
+   own submit button out of sight. Anything added above the fields, this warning
+   included, would have hidden it, so the action bar now holds the bottom edge. */
+.modal-launch .launch-footer{position:sticky;bottom:0;z-index:1}
+@media(max-width:900px){.statusbar .local,.usage-other{display:none}}
+@media(max-width:720px){.statusbar{height:auto;flex-wrap:wrap;gap:8px;padding:8px 14px;white-space:normal}.status-fleet{margin-left:0}.status-conn{border:0;padding-left:0}}

package/server.js

@@ -92,7 +92,11 @@ function createApp({manager = new ManagedSessions({externalSessions:()=>collect(
       if(s.archived) archived++
       else counts[s.state]++
     }
-    return {...snap,sessions,counts,total:sessions.length-archived,archived,archiveRule:archive.rule,storageError}
+    // The transcript rejection is merged into the account view rather than shipped
+    // beside it: the dashboard should never have to reconcile two rate-limit stories.
+    const {rateLimit,...rest}=snap
+    const usage=manager.usage ? manager.usage.snapshot({rejection:rateLimit}) : null
+    return {...rest,sessions,counts,total:sessions.length-archived,archived,archiveRule:archive.rule,storageError,usage}
   }
   const authorized=(req)=>{
     const supplied=req.headers['x-fleet-token']

package/tasks.js

@@ -6,7 +6,18 @@ function ledger(s) {return s.taskBoard ||= {tasks:[],delegations:[]}}
 function taskFor(s,id) {const task=ledger(s).tasks.find(t=>t.id===id);if(!task)fail('Task not found. Read the Fleet task board.');return task}
 function act(s,input) {
   const board=ledger(s)
-  if (input.action==='list') return board
+  // The durable ledger also powers the inspector. Never send its full transcript
+  // back into the manager context on every list call.
+  if (input.action==='list') return {
+    tasks:board.tasks,
+    delegations:board.delegations.map(d=>({id:d.id,taskId:d.taskId,role:d.role,attempt:d.attempt,status:d.status,startedAt:d.startedAt,finishedAt:d.finishedAt})),
+    detailHint:'Use inspect with delegationId to read an assignment and report.',
+  }
+  if (input.action==='inspect') {
+    const d=board.delegations.find(d=>d.id===input.delegationId)
+    if (!d) fail('Delegation not found. Read the Fleet task board.')
+    return {id:d.id,taskId:d.taskId,role:d.role,status:d.status,prompt:d.prompt,report:d.report,output:d.report ? undefined:d.output}
+  }
   if (input.action==='create') {
     if (board.tasks.length>=100) fail('This initiative has reached its 100-task limit.')
     const owner=input.owner,team=s.teamSnapshot
@@ -91,8 +102,8 @@ function progress(s) {
 async function sdkServer(s,changed) {
   const {createSdkMcpServer,tool}=await import('@anthropic-ai/claude-agent-sdk')
   const {z}=require('zod/v4')
-  return createSdkMcpServer({name:'fleet',version:'1.0.0',tools:[tool('tasks','Read the durable task board; create scoped tasks with criteria and dependencies; record blockers. Fleet records verification from actual agent reports.',{
-    action:z.enum(['list','create','block']),title:z.string().optional(),owner:z.string().optional(),criteria:z.array(z.string()).optional(),dependencies:z.array(z.string()).optional(),taskId:z.string().optional(),reason:z.string().optional(),
+  return createSdkMcpServer({name:'fleet',version:'1.0.0',tools:[tool('tasks','Read a compact task board; inspect delegation assignments/reports by delegationId; create scoped tasks with criteria and dependencies; record blockers. Fleet records verification from actual agent reports.',{
+    action:z.enum(['list','inspect','create','block']),delegationId:z.string().optional(),title:z.string().optional(),owner:z.string().optional(),criteria:z.array(z.string()).optional(),dependencies:z.array(z.string()).optional(),taskId:z.string().optional(),reason:z.string().optional(),
   },async input=>{
     const before=structuredClone(s.taskBoard)
     try {const result=act(s,input);changed();return {content:[{type:'text',text:JSON.stringify(result)}]}}

package/teams.js

@@ -174,7 +174,7 @@ const TEAMS = {
 const READ_TOOLS = ['Read','Glob','Grep','WebSearch','WebFetch']
 TEAMS.delivery = {
   id:'delivery', name:'Software delivery',
-  description:'Turn a brief into scoped work, implementation, independent code review and QA.',
+  description:'Thorough workflow: scoped work, implementation, independent code review and QA.',
   manager:'manager',
   workflow:{reviewers:['reviewer','qa'],maxAttempts:3,budgetUsd:10},
   roles:{
@@ -185,9 +185,22 @@ TEAMS.delivery = {
     qa:{description:'Verifies acceptance criteria with reproducible evidence.',prompt:QA,model:'sonnet',tools:[...READ_TOOLS,'Bash']},
   },
 }
+// A lighter explicit choice, using the same durable gates and snapshot mechanism.
+TEAMS.quick = {
+  id:'quick',name:'Quick task',
+  description:'Small, clear changes: one developer and one independent verifier, with focused checks.',
+  manager:'manager',workflow:{reviewers:['qa'],maxAttempts:2,budgetUsd:3},
+  roles:{
+    manager:{...TEAMS.delivery.roles.manager,model:'sonnet',prompt:'Coordinate a small, clearly scoped task. Read only relevant instructions and files. Create one task unless the goal has independent deliverables. Give the developer file boundaries, acceptance criteria and exact checks. Use one QA verification. Avoid broad audits, speculative improvements and repeated repository exploration. Pass concise findings and test evidence between roles.'},
+    developer:{...TEAMS.delivery.roles.developer,prompt:DEVELOPER+'\nKeep investigation scoped to the acceptance criteria. Run relevant checks once after the final change; repeat only after a failure or further change.'},
+    qa:{...TEAMS.delivery.roles.qa,prompt:QA+'\nKeep verification proportional to this small task. Focus on acceptance criteria and directly affected behavior; stop once sufficient evidence exists.'},
+  },
+}
 const TASK_RULES = `
 
 Fleet owns the durable task board. Use mcp__fleet__tasks to read it and create tasks before delegating.
+List returns compact metadata; use inspect with delegationId when you need a prior assignment or report.
+Read the board on resume and when state is uncertain, not repeatedly between every action.
 Each task needs an owner, acceptance criteria and optional dependencies. All configured verification
 roles must verify each deliverable. Include a line "Fleet task: <task ID>" in EVERY Agent prompt.
 Invoke only the owner or a configured verification role. Work sequentially in this shared worktree.

package/usage.js

@@ -0,0 +1,111 @@
+'use strict'
+// Plan usage is an account fact, not a session one: the five-hour and weekly windows
+// are shared by every Claude process on this machine, including the terminal sessions
+// Fleet only watches. Three sources feed this, none of them available all of the time:
+//   - `rate_limit_event`, pushed by the SDK while a Fleet run is streaming
+//   - the runtime's own /usage data, pulled once at the end of a turn
+//   - a rejected `quotaLimits` record in any transcript, which is the only signal that
+//     survives Fleet being idle and the only one that says "you are blocked right now"
+// Nothing here spends a token to find out. A synthetic request would consume the very
+// window it claims to measure.
+const WINDOWS=['five_hour','seven_day','seven_day_opus','seven_day_sonnet','seven_day_oauth_apps']
+const LABELS={five_hour:'5h',seven_day:'week',seven_day_opus:'opus wk',seven_day_sonnet:'sonnet wk',seven_day_oauth_apps:'apps wk'}
+// A live reading only arrives while a run streams. Past this age the bar says "as of",
+// because presenting an hour-old number as current is the one thing it must never do.
+const STALE_MS=120000
+// Utilisation is a whole percentage. A value outside the range is discarded rather than
+// clamped: that far off is a change of shape, not a reading worth drawing.
+const valid=n=>typeof n==='number' && Number.isFinite(n) && n>=0 && n<=100
+// `resetsAt` is unix seconds on the push event and an ISO string on the pull.
+function resetTime(value) {
+  if (typeof value==='number' && Number.isFinite(value) && value>0) return Math.round(value<1e12 ? value*1000 : value)
+  if (typeof value==='string') {const parsed=Date.parse(value);return Number.isFinite(parsed) ? parsed:null}
+  return null
+}
+// A block with no reset time cannot be shown honestly and cannot expire on its own, so
+// it is dropped: a red bar that never clears is worse than no bar.
+const live=(block,now)=>block && block.resetsAt && block.resetsAt>now ? block:null
+
+class UsageTracker {
+  constructor() {
+    this.windows=new Map()
+    this.observedAt=null
+    this.subscription=null
+    // null until something says either way. Unknown is not "no limits": the bar stays
+    // empty rather than reporting a zero it never measured.
+    this.available=null
+    this.blocked=null
+  }
+  // The SDK's push event carries one window at a time and is the only source that
+  // updates mid-turn.
+  recordEvent(info,now=Date.now()) {
+    if (!info || typeof info!=='object') return false
+    const type=typeof info.rateLimitType==='string' ? info.rateLimitType:null
+    let changed=false
+    if (type && valid(info.utilization)) {
+      this.windows.set(type,{utilization:info.utilization,resetsAt:resetTime(info.resetsAt)})
+      this.observedAt=now
+      this.available=true
+      changed=true
+    }
+    if (info.status==='rejected' && type) {
+      this.blocked={rateLimitType:type,resetsAt:resetTime(info.resetsAt),reason:info.overageDisabledReason || null,at:now,source:'run'}
+      changed=true
+    } else if (info.status && this.blocked) {this.blocked=null;changed=true}
+    return changed
+  }
+  // The pull at turn end: every window at once, plus the plan behind them. Experimental
+  // upstream, so absence and malformed shapes are ordinary outcomes, never errors.
+  recordUsage(response,now=Date.now()) {
+    if (!response || typeof response!=='object') return false
+    if (response.rate_limits_available===false) {
+      const had=this.available!==false
+      this.available=false;this.windows.clear();this.observedAt=now
+      return had
+    }
+    let changed=false
+    const limits=response.rate_limits
+    if (limits && typeof limits==='object') for (const name of WINDOWS) {
+      const window=limits[name]
+      if (!window || typeof window!=='object' || !valid(window.utilization)) continue
+      this.windows.set(name,{utilization:window.utilization,resetsAt:resetTime(window.resets_at)})
+      changed=true
+    }
+    if (typeof response.subscription_type==='string' && response.subscription_type!==this.subscription) {
+      this.subscription=response.subscription_type
+      changed=true
+    }
+    if (changed) {this.observedAt=now;this.available=true}
+    return changed
+  }
+  // A rejection read out of a transcript. Any session on this machine can supply it,
+  // which is what makes a block visible while Fleet itself is driving nothing.
+  static rejection(record) {
+    if (!record || typeof record!=='object') return null
+    const resetsAt=resetTime(record.resetsAt)
+    if (!resetsAt) return null
+    return {rateLimitType:record.rateLimitType || null,resetsAt,reason:record.reason || null,at:record.at || null,source:'transcript'}
+  }
+  snapshot({now=Date.now(),rejection=null}={}) {
+    // Whichever block is newer wins; both expire by themselves at their reset time.
+    const blocks=[live(this.blocked,now),live(UsageTracker.rejection(rejection),now)].filter(Boolean)
+    const blocked=blocks.sort((a,b)=>(b.at || 0)-(a.at || 0))[0] || null
+    const windows=[...this.windows.entries()]
+      .map(([name,w])=>({name,label:LABELS[name] || name,utilization:Math.round(w.utilization),resetsAt:w.resetsAt}))
+      .sort((a,b)=>WINDOWS.indexOf(a.name)-WINDOWS.indexOf(b.name))
+    // One bar on screen, drawn for whichever window is closest to stopping the fleet.
+    const binding=windows.reduce((worst,w)=>!worst || w.utilization>worst.utilization ? w:worst,null)
+    return {
+      available:this.available!==false,
+      known:windows.length>0 || !!blocked,
+      windows,
+      binding:binding ? binding.name:null,
+      subscription:this.subscription,
+      observedAt:this.observedAt,
+      stale:this.observedAt ? now-this.observedAt>STALE_MS:true,
+      blocked,
+    }
+  }
+}
+
+module.exports={UsageTracker,WINDOWS,LABELS,STALE_MS}