@sergeychuvayev/claude-fleet 0.6.0 → 0.7.0

package/README.md

@@ -412,7 +412,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 +435,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 +446,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/managed.js

@@ -359,18 +359,30 @@ class ManagedSessions extends EventEmitter {
         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,9 +410,9 @@ 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()})
@@ -441,13 +453,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 +467,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.7.0",
   "description": "A local control room for Claude Code sessions",
   "keywords": [
     "claude",

package/public/app.js

@@ -234,12 +234,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/styles.css

@@ -516,3 +516,9 @@ 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}

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.