@hecer/yoke 1.12.0 → 1.14.0

package/dist/dashboard/panels.js

@@ -3,12 +3,64 @@ export function dashboardPanels() {
     return String.raw `
 function panel(title){return append(el('section',undefined,'panel'),el('h2',title))}
 function table(headers,rows){const wrap=el('div',undefined,'table-scroll'),t=el('table'),head=el('thead'),hr=el('tr');for(const title of headers)hr.append(el('th',title));head.append(hr);t.append(head);const body=el('tbody');for(const values of rows){const r=el('tr');for(const value of values)r.append(el('td',String(value)));body.append(r)}t.append(body);wrap.append(t);return wrap}
-function costText(t){return t.costState==='unknown'?'Unknown':'$'+t.reportedCostUsd.toFixed(3)+(t.costState==='partial'?' reported (partial)':' reported')}
+function metric(label,value,note){return append(el('div',undefined,'metric'),el('span',label,'label'),el('strong',value),el('p',note))}
+function safeMetricTotal(values){return values.every(Number.isFinite)?values.reduce((sum,value)=>sum+value,0):null}
+function chartValues(buckets,key){return buckets.map(bucket=>{if(key==='tokens')return bucket.tokens?.total??safeMetricTotal([bucket.inputTokens,bucket.outputTokens]);if(key==='calls')return bucket.calls?.total??(Number.isFinite(bucket.measuredCalls)&&Number.isFinite(bucket.unknownCalls)?bucket.measuredCalls+bucket.unknownCalls:null);if(key==='duration')return bucket.time?.attemptDurationMs??bucket.attemptDurationMs??null;if(key==='outcomes')return bucket.outcomes?.accepted??bucket.accepted??null;return bucket.cost?.reportedUsd??bucket.reportedCostUsd??null})}
+function dimensionLabel(value){if(value===undefined||value===null||value==='')return 'Not reported';if(String(value).toLowerCase()==='unknown')return 'Unknown';return String(value)}
+function rankRows(rows,key='tokens'){return [...rows].sort((left,right)=>{const a=Number.isFinite(left[key])?left[key]:null,b=Number.isFinite(right[key])?right[key]:null;if(a===null&&b!==null)return 1;if(a!==null&&b===null)return -1;if(a!==b)return (b??0)-(a??0);return dimensionLabel(left.name).localeCompare(dimensionLabel(right.name))})}
+function coverageMessages(data,project={}){const messages=[];if(project.unavailable||data?.projects?.some(value=>value.errors?.length&&!value.analytics))messages.push('Unavailable telemetry: this project could not be read.');if(data?.errors?.length)messages.push('Corrupt or partial history: '+data.errors.join(' · '));const total=data?.total||{};if(total.costState==='partial'||total.cost?.state==='partial'||total.unknownCalls>0||total.unmeasuredAttempts>0||total.incompleteCosts>0||total.cost?.incompleteCalls>0)messages.push('Partial telemetry: some calls or costs are not measured.');if(project.stale)messages.push('Stale telemetry: the latest active status is unconfirmed.');return messages}
+let lastSuccessfulSync='',composeFeedbackState=null;
+function liveFreshness(project,now=Date.now()){
+  const status=project.status||{},times=[status.updatedAt,...(status.supervision||[]).flatMap(value=>[value.heartbeatAt,value.lastProgressAt])].map(value=>Date.parse(value||'')).filter(Number.isFinite),latest=Math.max(...times);
+  if(!Number.isFinite(latest))return 'unknown';
+  if(now-latest<=20*60000)return 'fresh';
+  return ['running','active'].includes(status.state)?'unconfirmed':'stale'
+}
+function workerMetadata(worker){return [worker.provider?'Agent '+worker.provider:null,worker.selectedProvider&&worker.selectedProvider!==worker.provider?'Selected provider '+worker.selectedProvider:null,'Model '+(worker.selectedModel||worker.model||'provider default'),worker.selectedVariant?'Variant '+worker.selectedVariant:null,worker.role?'Role '+worker.role:null,'Phase '+(worker.phase||worker.lifecycle||'working')].filter(Boolean).join(' · ')}
+function timelineEvents(events,limit=100){return [...events].sort((left,right)=>String(left.timestamp).localeCompare(String(right.timestamp))).slice(-limit)}
+function composeFeedbackStatus(result){if(result?.status==='pending')return 'pending';if(['note-added','applied'].includes(result?.status))return 'applied';if(result?.status==='validation'||/invalid|validation|required|empty/iu.test(String(result?.error||'')))return 'validation';return 'failure'}
+function localAndUtc(timestamp){const date=new Date(timestamp);return 'Local time: '+date.toLocaleString()+' · UTC: '+date.toISOString()}
+function timelineDetail(title,value){const detail=el('details'),summary=el('summary',title);detail.append(summary,el('p',value||'Unknown'));return detail}
+function timelineItem(event){
+  const item=el('details'),data=event.data||{},input=data.inputTokens??event.inputTokens,output=data.outputTokens??event.outputTokens,usage=data.usageAvailable===false||event.usageAvailable===false?'unavailable':input!==undefined||output!==undefined?'reported':'not recorded';
+  item.append(el('summary',event.type+' · '+localAndUtc(event.timestamp)),timelineDetail('Run details',event.runId),timelineDetail('Story details',event.storyId),timelineDetail('Phase details',event.phase),timelineDetail('Agent details',[event.agent,event.provider,event.model,event.variant,event.role].filter(Boolean).join(' · ')),timelineDetail('Token details','Input '+(input===undefined?'Unknown':input)+' · output '+(output===undefined?'Unknown':output)+' · '+usage));
+  return item
+}
+function feedbackText(state){return state.status+': '+state.message}
+function feedbackNode(state){return el('p',feedbackText(state),'compose-feedback '+state.status)}
+function renderTimeline(project){
+  const view=panel('Event timeline');view.append(el('p','Bounded to the latest 100 events in chronological order. Each event expands run, story, phase, agent, and token details.','muted'));
+  const events=timelineEvents(project.events||[]);if(!events.length)view.append(el('p','No recorded events.','empty'));else{const list=el('div',undefined,'timeline');for(const event of events)list.append(timelineItem(event));view.append(list)}content.append(view)
+}
+function renderOperatorInput(project){
+  const view=panel('Operator input');if(composeFeedbackState)view.append(feedbackNode(composeFeedbackState));
+  const noteLabel=el('label','Add a note','field'),note=el('textarea');note.rows=3;note.placeholder='Record context for the next worker or handoff';note.setAttribute('aria-label','Operator note');noteLabel.append(note);view.append(noteLabel,button('Add note',()=>submitOperatorInput(project,'note',note.value,view)));
+  const changeLabel=el('label','Queue a change','field'),change=el('textarea');change.rows=3;change.placeholder='Describe a change for the pending inbox';change.setAttribute('aria-label','Change request');changeLabel.append(change);view.append(changeLabel,button('Queue change',()=>submitOperatorInput(project,'change',change.value,view)));content.append(view)
+}
+async function submitOperatorInput(project,kind,value,view){
+  const text=value.trim();if(!text){composeFeedbackState={status:'validation',message:kind==='note'?'Enter a note before adding it.':'Describe a change before queueing it.'};view.append(feedbackNode(composeFeedbackState));return}
+  try{
+    const data=await api('/api/projects/'+project.id+'/'+(kind==='note'?'notes':'changes'),{method:'POST',headers:{'content-type':'application/json','x-yoke-token':sessionToken},body:JSON.stringify(kind==='note'?{note:text}:{request:text})});
+    const status=composeFeedbackStatus(data),message=status==='pending'?'Change queued as '+data.requestId+'.': 'Note applied to the live timeline.';composeFeedbackState={status,message};await showProject(project.id)
+  }catch(error){composeFeedbackState={status:composeFeedbackStatus({error:error.message}),message:error.message};view.append(feedbackNode(composeFeedbackState))}
+}
+async function safeLiveControl(project,action){
+  try{const data=await api('/api/projects/'+project.id+'/'+action,{method:'POST',headers:{'content-type':'application/json','x-yoke-token':sessionToken},body:JSON.stringify({action})});composeFeedbackState={status:'pending',message:data.status==='pause-requested'?'Pause requested at the next safe boundary.':'Resume requested at the next safe boundary.'};await showProject(project.id)}
+  catch(error){composeFeedbackState={status:composeFeedbackStatus({error:error.message}),message:error.message};await showProject(project.id)}
+}
+function renderLive(project){
+  const status=project.status||{},goal=project.goal||{},workers=status.parallel?.workers||[],state=projectStatus(project),freshness=liveFreshness(project),tasks=project.stories||[],progress=status.progress||{passed:tasks.filter(task=>task.passes).length,total:tasks.length};
+  const view=panel('Live operations');view.append(row('Goal state',goal.status||'not reported',state.goal||'unknown'),row('Loop state',status.state||'not reported',state.loop||'unknown'),row('Freshness',freshness,'Last status '+(status.updatedAt||'unknown')),row('Objective progress',progress.total?progress.passed+'/'+progress.total+' tasks accepted':'Unknown','Saved acceptance state'),row('Last successful sync',lastSuccessfulSync?localAndUtc(lastSuccessfulSync):'Not synced yet','Dashboard refresh'));
+  const metadata=panel('Worker metadata');if(!workers.length)metadata.append(el('p','No current workers reported.','empty'));else for(const worker of workers)metadata.append(row(worker.storyTitle||worker.story,workerMetadata(worker),state.stale?'unconfirmed':worker.lifecycle||'running'));view.append(metadata);
+  const controls=panel('Safe controls');if(state.active)controls.append(button('Request pause',()=>safeLiveControl(project,'pause')));if(state.goal!=='complete'&&(!state.active||state.loop==='paused'||state.goal==='paused'))controls.append(button('Resume',()=>safeLiveControl(project,'resume'),true));if(!state.active&&!['paused','complete'].includes(state.goal||''))controls.append(el('p','Resume starts through the existing goal or loop boundary.','muted'));view.append(controls);content.append(view)
+  renderOperatorInput(project);renderTimeline(project)
+}
+function costText(t){const state=t.costState||t.cost?.state||'unknown',value=t.reportedCostUsd??t.cost?.reportedUsd??(Number.isFinite(t.cost)?t.cost:null);return !Number.isFinite(value)||state==='unknown'?'Unknown':'$'+value.toFixed(3)+(state==='partial'?' reported (partial)':' reported')}
 function historyCost(total,errors){return errors.length&&total.costState==='measured'?{...total,costState:'partial'}:total}
 function rate(value){return Number.isFinite(value)?value.toLocaleString('en-US',{maximumFractionDigits:1}):'Unknown'}
-function comparisonText(current,previous){if(previous===0)return current===0?'No change; both periods recorded 0':'New recorded activity; previous period recorded 0';const change=(current-previous)/previous*100;return (change>0?'+':'')+change.toFixed(1)+'% vs previous period'}
+function comparisonText(current,previous){if(!Number.isFinite(current)||!Number.isFinite(previous))return 'Comparison unavailable; one or both periods are not fully measured';if(previous===0)return current===0?'No change; both periods recorded 0':'New recorded activity; previous period recorded 0';const change=(current-previous)/previous*100;return (change>0?'+':'')+change.toFixed(1)+'% vs previous period'}
 function costComparisonText(current,previous){if(current.costState!=='measured'||previous.costState!=='measured')return 'Percentage unavailable because cost coverage is incomplete in one or both periods';return comparisonText(current.reportedCostUsd,previous.reportedCostUsd)}
-function usageCoverage(total){const missing=total.unknownCalls+total.unmeasuredAttempts;return missing?missing+' call'+(missing===1?'':'s')+' or attempt'+(missing===1?'':'s')+' missing usage; totals are recorded portions':'No missing usage recorded in this period'}
+function usageCoverage(total){const missing=(Number.isFinite(total.unknownCalls)?total.unknownCalls:0)+(Number.isFinite(total.unmeasuredAttempts)?total.unmeasuredAttempts:0);return missing?missing+' call'+(missing===1?'':'s')+' or attempt'+(missing===1?'':'s')+' missing usage; totals are recorded portions':'No missing usage recorded in this period'}
 function periodWindows(now=Date.now(),days=periodDays,from=customFrom,to=customTo){const end=to?Date.parse(to+'T00:00:00Z')+86400000:now,start=from?Date.parse(from+'T00:00:00Z'):end-days*86400000,duration=end-start;return {current:{from:start,to:end},previous:{from:start-duration,to:start}}}
 function queryPeriod(range){return new URLSearchParams({from:new Date(range.from).toISOString(),to:new Date(range.to).toISOString(),bucket}).toString()}
 async function mapLimited(items,limit,shouldContinue,worker){
@@ -17,12 +69,20 @@ async function mapLimited(items,limit,shouldContinue,worker){
   await Promise.all(Array.from({length:Math.min(limit,items.length)},run));
   return results.filter(value=>value!==undefined);
 }
-function usageChart(buckets){const data=buckets.slice(-31);const svg=document.createElementNS('http://www.w3.org/2000/svg','svg');svg.setAttribute('viewBox','0 0 800 220');svg.setAttribute('role','img');svg.setAttribute('aria-label','Recorded input and output tokens over the latest '+data.length+' non-empty periods; omitted periods mean no recorded activity, not measured zero');const max=Math.max(1,...data.map(d=>d.inputTokens+d.outputTokens));const step=760/Math.max(1,data.length);data.forEach((d,i)=>{let y=180;for(const [value,color] of [[d.inputTokens,'#29444b'],[d.outputTokens,'#c34c27']]){const h=value/max*160;y-=h;const r=document.createElementNS(svg.namespaceURI,'rect');for(const [k,v] of Object.entries({x:20+i*step,y,width:Math.max(1,step-4),height:h,fill:color}))r.setAttribute(k,String(v));const title=document.createElementNS(svg.namespaceURI,'title');title.textContent=d.label+': input '+d.inputTokens+', output '+d.outputTokens;r.append(title);svg.append(r)}if(i===0||i===data.length-1){const label=document.createElementNS(svg.namespaceURI,'text');label.setAttribute('x',String(i===0?20:780));label.setAttribute('y','205');label.setAttribute('text-anchor',i===0?'start':'end');label.setAttribute('font-size','12');label.textContent=d.label;svg.append(label)}});return svg}
+function numericChart(buckets,key,title){const data=(buckets||[]).slice(-31),values=chartValues(data,key),finiteValues=values.filter(Number.isFinite),max=Math.max(1,...finiteValues),svg=document.createElementNS('http://www.w3.org/2000/svg','svg');svg.setAttribute('viewBox','0 0 800 220');svg.setAttribute('role','img');svg.setAttribute('aria-label',title+' over the selected UTC period; unknown measurements are omitted, not plotted as zero');const step=760/Math.max(1,data.length);data.forEach((d,i)=>{const value=values[i];if(Number.isFinite(value)){const h=value/max*160,r=document.createElementNS(svg.namespaceURI,'rect');for(const [k,v] of Object.entries({x:20+i*step,y:180-h,width:Math.max(1,step-4),height:h,fill:'#29444b'}))r.setAttribute(k,String(v));const tip=document.createElementNS(svg.namespaceURI,'title');tip.textContent=d.label+': '+value;r.append(tip);svg.append(r)}if(i===0||i===data.length-1){const label=document.createElementNS(svg.namespaceURI,'text');label.setAttribute('x',String(i===0?20:780));label.setAttribute('y','205');label.setAttribute('text-anchor',i===0?'start':'end');label.setAttribute('font-size','12');label.textContent=d.label;svg.append(label)}});return svg}
+function usageChart(buckets){const data=buckets.slice(-31),svg=numericChart(data,'tokens','Recorded tokens');svg.setAttribute('aria-label','Recorded input and output tokens over the latest '+data.length+' non-empty periods; omitted periods mean no recorded activity, not measured zero');return svg}
+function renderAnalyticsCharts(data){const buckets=data.buckets||[],view=panel('Analytics over time'),grid=el('div',undefined,'analytics-chart-grid');for(const [key,title] of [['tokens','Tokens over time'],['calls','Calls over time'],['duration','Duration over time']]){const chart=append(el('div',undefined,'analytics-chart'),el('h3',title),numericChart(buckets,key,title));grid.append(chart)}const outcomes=append(el('div',undefined,'analytics-chart'),el('h3','Outcomes over time'),numericChart(buckets,'outcomes','Outcomes'),table(['UTC '+(data.bucket||'period'),'Attempts','Successful','Accepted'],buckets.map(value=>[value.label,rankingText(value.outcomes?.attempts??value.attempts),rankingText(value.outcomes?.successfulAttempts??value.successfulAttempts),rankingText(value.outcomes?.accepted??value.accepted)])));grid.append(outcomes);const cost=append(el('div',undefined,'analytics-chart'),el('h3','Cost state over time'),table(['UTC '+(data.bucket||'period'),'Cost state','Reported cost'],buckets.map(value=>[value.label,value.cost?.state||value.costState||'Unknown',costText(value)])));grid.append(cost);view.append(el('p','Each series uses recorded measurements for the selected UTC window. Unknown values are left blank and are never treated as zero.','muted'),grid);return view}
+function rowTotal(row){return row.total||row}
+function normalizedRankingRows(rows){return rows.map(row=>{const total=rowTotal(row),reportedCost=row.reportedCostUsd??(Number.isFinite(row.cost)?row.cost:total.cost?.reportedUsd??null);return {...row,name:dimensionLabel(row.name),reportedCostUsd:reportedCost,tokens:row.tokens??total.tokens?.total??null,calls:row.calls?.total??total.calls?.total??null,cost:row.cost??total.cost?.reportedUsd??null,outcomes:row.outcomes?.accepted??total.outcomes?.accepted??null,duration:row.duration??total.time?.attemptDurationMs??null,costState:row.costState||total.costState||total.cost?.state||'unknown'}})}
+function rankingText(value){return Number.isFinite(value)?String(value):'Unknown'}
+function renderDimensionTables(data){const view=panel('Analytics dimensions'),rankings=data.rankings||{};for(const [key,title] of [['agents','Agents'],['providers','Providers'],['models','Models'],['roles','Roles'],['phases','Phases'],['projects','Projects'],['runs','Runs']]){if(!rankings[key])continue;const rows=rankRows(normalizedRankingRows(rankings[key].tokens||rankings[key]),'tokens');view.append(el('h3',title),table(['Rank','Name','Tokens','Calls','Cost','Cost state','Accepted','Duration'],rows.map((row,index)=>[index+1,dimensionLabel(row.name),rankingText(row.tokens),rankingText(row.calls),costText(row),dimensionLabel(row.costState),rankingText(row.outcomes),duration(row.duration)])))}return view}
+function renderCoverage(data,project={}){const view=panel('Measurement coverage');view.append(el('p',data.coverage||'Recorded measurements only; missing telemetry is not estimated.'));for(const message of coverageMessages(data,project))view.append(el('p',message,'notice'));if(!coverageMessages(data,project).length)view.append(el('p','No telemetry gaps reported for this selected window.','muted'));return view}
+function renderAnalytics(data,project={}){const view=el('div',undefined,'analytics-view'),total=data.total||{};view.append(append(el('div',undefined,'metric-strip'),metric('Recorded tokens',tokenText(total.tokens?.total),'Input '+tokenText(total.tokens?.input)+' · output '+tokenText(total.tokens?.output)),metric('Calls',rankingText(total.calls?.total),'Measured '+rankingText(total.calls?.measured)+' · unknown '+rankingText(total.calls?.unknown)),metric('Cost state',dimensionLabel(total.cost?.state||total.costState),'Reported charges only'),metric('Duration',duration(total.time?.attemptDurationMs),'Summed recorded attempt time')),renderCoverage(data,project),renderAnalyticsCharts(data),renderDimensionTables(data));return view}
 async function showWorkspaceUsage(){
-  const request=beginRequest();selected=null;nav();heading('Compare project consumption','Recorded usage in the selected period; missing measurements remain unknown.');periodControls(null);const p=panel('Projects');p.append(el('p','Loading…','muted'));content.append(p);
-  const bounds=periodWindows(Date.now()),query=queryPeriod(bounds.current),valid=()=>currentRequest(request.version)&&navigationState.screen==='workspace'&&!request.signal.aborted;
-  const rows=await mapLimited(projects,3,valid,async project=>{try{const a=await api('/api/projects/'+project.id+'/analytics?'+query,{},request.signal);return [project.name,tokenText(a.total.inputTokens),tokenText(a.total.outputTokens),costText(a.total),a.total.accepted,a.total.unknownCalls+a.total.unmeasuredAttempts,a.errors.length?'Partial history':usageCoverage(a.total)]}catch(error){if(isAbort(error))return undefined;return [project.name,'Unknown','Unknown','Unknown','Unknown','Unknown',error.message]}});
-  if(valid())p.replaceChildren(el('h2','Projects'),table(['Project','Input','Output','Cost','Accepted','Missing usage','Coverage'],rows));
+  const request=beginRequest();selected=null;nav();heading('Workspace analytics','Time-bucketed recorded usage, outcomes, and coverage for the selected UTC window.');periodControls(null);const p=panel('Workspace analytics');p.append(el('p','Loading…','muted'));content.append(p);
+  const bounds=periodWindows(Date.now(),periodDays,customFrom,customTo),query=queryPeriod(bounds.current)+'&sort='+encodeURIComponent(overviewSort),valid=()=>currentRequest(request.version)&&navigationState.screen==='workspace'&&!request.signal.aborted;
+  try{const data=await api('/api/workspace/analytics?'+query,{},request.signal);if(valid())p.replaceChildren(el('h2','Workspace analytics'),renderAnalytics(data,{stale:projects.some(project=>projectStatus(project).stale)}));}
+  catch(error){if(valid()&&!isAbort(error))p.replaceChildren(el('h2','Workspace analytics'),el('p','Offline or unavailable: '+error.message,'notice'),el('p','Retry when the local Yoke process is available.','muted'))}
 }
 function periodControls(id){
   const p=panel('Period · UTC'),select=el('select');select.setAttribute('aria-label','Period');
@@ -45,50 +105,44 @@ function renderNow(p){
   if(goal.pendingAttempt)summary.append(row('Goal attempt',goal.pendingAttempt.provider+' · requested model '+(goal.pendingAttempt.model||'provider default')+' · started '+goal.pendingAttempt.startedAt,state.stale?'unconfirmed':'running'));
   if(status.execution&&status.state==='running')summary.append(el('p',state.stale?'Execution was reported but is now unconfirmed.':status.execution.provider+' · requested model '+(status.execution.requestedModel||'provider default')+' · elapsed '+duration(Date.now()-Date.parse(status.execution.startedAt))));
   if(status.story&&!workers.length)summary.append(row(status.storyTitle||status.story,status.phase||'Phase unknown',reportedState));
-  for(const worker of workers)summary.append(row(worker.storyTitle||worker.story,[worker.selectedProvider||worker.provider,'requested model '+(worker.selectedModel||worker.model||'provider default'),worker.phase||worker.lifecycle||'working',worker.startedAt?(state.stale?'last started '+worker.startedAt:'elapsed '+duration(Date.now()-Date.parse(worker.startedAt))):null,worker.quality?'repair '+worker.quality.usedRepairs:null].filter(Boolean).join(' · '),state.stale?'unconfirmed':worker.lifecycle||'running'));
+  for(const worker of workers)summary.append(row(worker.storyTitle||worker.story,[worker.provider+(worker.selectedProvider&&worker.selectedProvider!==worker.provider?' ('+worker.selectedProvider+')':''),'requested model '+(worker.selectedModel||worker.model||'provider default'),worker.selectedVariant?'variant '+worker.selectedVariant:null,worker.phase||worker.lifecycle||'working',worker.startedAt?(state.stale?'last started '+worker.startedAt:'elapsed '+duration(Date.now()-Date.parse(worker.startedAt))):null,worker.quality?'repair '+worker.quality.usedRepairs:null].filter(Boolean).join(' · '),state.stale?'unconfirmed':worker.lifecycle||'running'));
   if(status.parallel?.integrator){const worker=status.parallel.integrator;summary.append(row('Integration: '+(worker.storyTitle||worker.story),worker.phase||'checking',state.stale?'unconfirmed':'integrating'))}
   if(!workers.length&&!status.story&&!goal.pendingAttempt)summary.append(el('p','No task currently reported.','empty'));
   summary.append(el('p','Status refreshes every 5 seconds. Requested models are not proof of the model actually used; reported model identities appear under Usage & time.','muted'));content.append(summary);
   const tasks=panel('Tasks');for(const task of p.stories||[])tasks.append(row(task.title,task.id+(task.needs?.length?' · after '+task.needs.join(', '):'')+' · '+taskTiming(task,p.estimate),task.passes?'passed':workers.some(worker=>worker.story===task.id)?state.stale?'unconfirmed':'running':'open'));content.append(tasks);
-  const routing=panel('Model selection');for(const [id,decision] of Object.entries(status.routingDecisions||{})){routing.append(row(id,decision.provider+' / '+(decision.model||'provider default')+(decision.reasoningEffort?' · '+decision.reasoningEffort:''),decision.profile));routing.append(el('p',decision.reason));routing.append(el('p','Next escalation: '+decision.next,'muted'))}if(!Object.keys(status.routingDecisions||{}).length)routing.append(el('p','No recorded model selection for this run.','empty'));content.append(routing);
-  const activity=panel('Recent activity');for(const event of (p.events||[]).slice(-16).reverse())activity.append(row(event.storyId||event.type,event.timestamp+(event.phase?' · '+event.phase:'')+(Number.isFinite(event.durationMs)?' · '+duration(event.durationMs):''),event.outcome||event.type));content.append(activity);
+  const routing=panel('Model selection');for(const [id,decision] of Object.entries(status.routingDecisions||{})){routing.append(row(id,decision.provider+(decision.providerModel?' ('+decision.providerModel+')':'')+' / '+(decision.model||'provider default')+(decision.reasoningEffort?' · '+decision.reasoningEffort:'')+(decision.variant?' · variant '+decision.variant:''),decision.profile));routing.append(el('p',decision.reason));routing.append(el('p','Next escalation: '+decision.next,'muted'))}if(!Object.keys(status.routingDecisions||{}).length)routing.append(el('p','No recorded model selection for this run.','empty'));content.append(routing);
+  renderLive(p);
 }
-function renderUsageHistory(current,previous){
-  const total=current.total,prior=previous.total,currentTokens=total.inputTokens+total.outputTokens,previousTokens=prior.inputTokens+prior.outputTokens;
-  const currentCoverage=usageCoverage(total)+(current.errors.length?' · measurement history is incomplete':''),previousCoverage=usageCoverage(prior)+(previous.errors.length?' · measurement history is incomplete':'');
-  const currentCost=historyCost(total,current.errors),previousCost=historyCost(prior,previous.errors);
-  const comparison=panel('Compared with the immediately preceding equal period');
-  const boundary=value=>new Date(value).toISOString().slice(0,16).replace('T',' ');
+function renderUsageHistory(current,previous,project={}){
+  const total=current.total,prior=previous.total,currentTokens=total.tokens?.total??safeMetricTotal([total.inputTokens,total.outputTokens]),previousTokens=prior.tokens?.total??safeMetricTotal([prior.inputTokens,prior.outputTokens]);
+  const currentCoverage=usageCoverage(total)+(current.errors.length?' · measurement history is incomplete':''),previousCoverage=usageCoverage(prior)+(previous.errors.length?' · measurement history is incomplete':''),currentCost=historyCost(total,current.errors),previousCost=historyCost(prior,previous.errors);
+  const comparison=panel('Compared with the immediately preceding equal period'),boundary=value=>new Date(value).toISOString().slice(0,16).replace('T',' ');
   comparison.append(el('p','Selected: '+boundary(current.from)+' → '+boundary(current.to)+' UTC','muted'),el('p','Previous: '+boundary(previous.from)+' → '+boundary(previous.to)+' UTC · end boundaries excluded','muted'));
-  comparison.append(append(el('div',undefined,'metrics'),metric('Recorded tokens',tokenText(currentTokens),'Previous: '+tokenText(previousTokens)+' · '+comparisonText(currentTokens,previousTokens)+' · '+currentCoverage),metric('Accepted tasks',tokenText(total.accepted),'Previous: '+tokenText(prior.accepted)+' · '+comparisonText(total.accepted,prior.accepted)+' · recorded acceptance events'),metric('Reported cost',costText(currentCost),'Previous: '+costText(previousCost)+' · '+costComparisonText(currentCost,previousCost))));
-  comparison.append(el('p','Current coverage: '+currentCoverage+'. Previous coverage: '+previousCoverage+'. Missing measurements are not estimated and recorded totals are not treated as complete totals.','muted'));for(const error of previous.errors)comparison.append(el('p','Previous period: '+error,'notice'));content.append(comparison);
-  content.append(append(el('div',undefined,'metrics'),metric('Recorded input',tokenText(total.inputTokens),'Output: '+tokenText(total.outputTokens)),metric('Reported cost',costText(currentCost),'Missing charges are not estimated'),metric('Tokens / elapsed minute',rate(total.tokensPerElapsedMinute),'Input + output / entire selected period')));
-  const notes=panel('Measurement coverage');notes.append(el('p',current.coverage));notes.append(el('p','First record in period: '+(current.earliest||'none')+' · latest: '+(current.latest||'none'),'muted'));notes.append(el('p','Measured calls: '+total.measuredCalls+' · calls with unknown usage: '+total.unknownCalls+' · unmeasured attempts: '+total.unmeasuredAttempts));notes.append(el('p','Tokens / recorded call minute: '+rate(total.tokensPerCallMinute)+' · summed call time: '+duration(total.callDurationMs)+'. Parallel calls overlap; this is consumption intensity, not generation speed.'));notes.append(el('p','Cache reads: '+tokenText(total.cachedInputTokens)+' · cache writes: '+tokenText(total.cacheWriteInputTokens)+'. These are reported categories and are not added again to input totals.','muted'));for(const error of current.errors)notes.append(el('p',error,'notice'));content.append(notes);
-  const series=panel('Consumption over time');series.append(usageChart(current.buckets));series.append(el('p','Dark: input · orange: output. Chart shows up to 31 latest non-empty periods; the table includes every recorded period. Periods with no recorded events are omitted, so calendar gaps mean no recorded activity and do not assert a measured zero.','muted chart-gap-note'));series.append(table(['UTC '+current.bucket,'Input','Output','Cache reads','Reported cost'],current.buckets.map(value=>[value.label,tokenText(value.inputTokens),tokenText(value.outputTokens),tokenText(value.cachedInputTokens),costText(value)])));if(!current.buckets.length)series.append(el('p','No recorded activity in this period; measurement coverage may still be incomplete.','empty'));content.append(series);
-  const models=panel('Reported models in this period');models.append(table(['Provider','Actual model','Role','Input','Output','Call time','Cost'],current.models.map(value=>[value.provider,value.model,value.role,tokenText(value.inputTokens),tokenText(value.outputTokens),duration(value.callDurationMs),costText(value)])));content.append(models);
-  const modelTimeline=panel('Models over time');modelTimeline.append(table(['UTC '+current.bucket,'Provider','Actual model','Role','Input','Output'],current.modelBuckets.map(value=>[value.label,value.provider,value.model,value.role,tokenText(value.inputTokens),tokenText(value.outputTokens)])));content.append(modelTimeline);
-  const tasks=panel('Consumption by task');tasks.append(table(['Task','Input','Output','Attempt time','Cost'],current.tasks.map(value=>[value.storyId,tokenText(value.inputTokens),tokenText(value.outputTokens),duration(value.attemptDurationMs),costText(value)])));content.append(tasks);
-  const phases=panel('Recorded phase time');phases.append(table(['Phase','Summed duration'],current.phases.map(value=>[value.phase,duration(value.durationMs)])));phases.append(el('p','Overlapping worker time is summed. Unrecorded queue time and human waiting time remain unknown.','muted'));content.append(phases);
+  comparison.append(append(el('div',undefined,'metrics'),metric('Recorded tokens',tokenText(currentTokens),'Previous: '+tokenText(previousTokens)+' · '+comparisonText(currentTokens,previousTokens)+' · '+currentCoverage),metric('Accepted tasks',tokenText(total.accepted),'Previous: '+comparisonText(total.accepted,prior.accepted)+' · recorded acceptance events'),metric('Reported cost',costText(currentCost),'Previous: '+costText(previousCost)+' · '+costComparisonText(currentCost,previousCost))));
+  comparison.append(el('p','Current coverage: '+currentCoverage+'. Previous coverage: '+previousCoverage+'. Missing measurements are not estimated and recorded totals are not treated as complete totals.','muted'));for(const error of previous.errors)comparison.append(el('p','Previous period: '+error,'notice'));content.append(comparison,renderAnalytics(current,project));
 }
 function renderResults(p,a){const t=a.total;content.append(append(el('div',undefined,'metrics'),metric('Accepted in period',t.accepted,'Recorded acceptance events'),metric('Repair phases',t.repairs,'Routing escalations: '+t.escalations),metric('Tokens / acceptance',rate(t.tokensPerAccepted),'Reported input + output, including failed work')));const attempts=panel('Measured outcomes');attempts.append(el('p','Ended attempts: '+t.attempts+' · explicitly successful attempts: '+t.successfulAttempts+' · average summed attempt time per acceptance: '+duration(t.timePerAcceptedMs)));attempts.append(el('p','Worker termination alone is not counted as successful acceptance. Rates only describe recorded activity in the selected period.','muted'));attempts.append(table(['Task','Attempts','Accepted','Repairs','Escalations','Tokens / acceptance'],a.tasks.map(v=>[v.storyId,v.attempts,v.accepted,v.repairs,v.escalations,rate(v.tokensPerAccepted)])));content.append(attempts);const checks=panel('Latest saved acceptance evidence');if(p.check){checks.append(el('p',p.check.summary));for(const c of p.check.criteria){const item=row(c.text,c.id,c.status);item.firstChild.append(append(el('details'),el('summary','View evidence'),el('p',c.summary)));checks.append(item)}checks.append(el('p','Checked '+p.check.generatedAt+' · historical evidence; independent of the selected statistics period.','muted'))}else checks.append(el('p','No saved independent check.','empty'));content.append(checks);const goals=panel('Saved goal attempts');for(const attempt of p.goal?.attempts||[])goals.append(row(attempt.provider||'Agent',(attempt.summary||'')+' · '+duration(attempt.durationMs)+' · input '+tokenText(attempt.inputTokens)+' / output '+tokenText(attempt.outputTokens),attempt.success?'finished':'failed'));content.append(goals)}
+function renderHistoryExplorer(project,history){const state=projectStatus(project),view=panel('History explorer');view.append(el('p','Recorded events and completed runs in the selected UTC window. The list is bounded to the latest 100 events.','muted'));const events=timelineEvents(history.events||[]);if(!events.length)view.append(el('p','No recorded history in this period.','empty'));else{const list=el('div',undefined,'timeline');for(const event of events)list.append(timelineItem(event));view.append(list)}const runs=panel('Run history');if(!(history.runs||[]).length)runs.append(el('p','No recorded runs in this period.','empty'));else runs.append(table(['Run','Started','Ended','Agent','Provider','Model','Tokens','Accepted','Outcome'],history.runs.map(run=>[dimensionLabel(run.runId),run.startedAt||'Not reported',run.endedAt||'Not reported',dimensionLabel(run.agent),dimensionLabel(run.provider),dimensionLabel(run.model),rankingText(run.total?.tokens?.total),rankingText(run.total?.outcomes?.accepted),rankingText(run.total?.outcomes?.successfulAttempts)])));content.append(renderCoverage(history,{stale:state.stale,unavailable:false}),runs,view)}
 async function showProject(id){
   const request=beginRequest();selected=id;nav();
   try{
-    const bounds=periodWindows(Date.now()),detailRequest=api('/api/projects/'+id,{},request.signal);
-    let project,current=null,previous=null;
+    const bounds=periodWindows(Date.now(),periodDays,customFrom,customTo),detailRequest=api('/api/projects/'+id,{},request.signal);
+    let project,current=null,previous=null,history=null;
     if(projectView==='usage'){
       [project,current,previous]=await Promise.all([detailRequest,api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.current),{},request.signal),api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.previous),{},request.signal)]);
     }else if(projectView==='results'){
       [project,current]=await Promise.all([detailRequest,api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.current),{},request.signal)]);
+    }else if(projectView==='history'){
+      [project,history]=await Promise.all([detailRequest,api('/api/projects/'+id+'/history?'+queryPeriod(bounds.current)+'&limit=100',{},request.signal)]);
     }else project=await detailRequest;
     if(!currentRequest(request.version)||navigationState.screen!=='project'||selected!==id)return;
-    heading(project.name,project.goal?.objective||'Saved project work');content.append(el('p',project.root,'path'));for(const error of project.errors)content.append(el('p',error,'notice'));
-    const tabs=el('div',undefined,'actions');for(const [view,label] of [['now','Now'],['usage','Usage & time'],['results','Results']]){const control=button(label,()=>setNavigation({view}),projectView===view);control.setAttribute('aria-pressed',String(projectView===view));tabs.append(control)}
-    if(project.goal&&!['complete','paused'].includes(project.goal.status))tabs.append(button('Request pause',async()=>{await api('/api/projects/'+id+'/pause',{method:'POST',headers:{'x-yoke-token':sessionToken}},request.signal);await refresh()}));content.append(tabs);
+    lastSuccessfulSync=new Date().toISOString();heading(project.name,project.goal?.objective||'Saved project work');content.append(el('p',project.root,'path'));for(const error of project.errors)content.append(el('p',error,'notice'));
+    const tabs=el('div',undefined,'actions');for(const [view,label] of [['now','Now'],['usage','Usage & time'],['results','Results'],['history','History']]){const control=button(label,()=>setNavigation({view}),projectView===view);control.setAttribute('aria-pressed',String(projectView===view));tabs.append(control)}
+    content.append(tabs);
     if(projectView==='now'){
       const tasks=project.stories||[],state=projectStatus(project);content.append(append(el('div',undefined,'metrics'),metric('Accepted tasks',tasks.filter(task=>task.passes).length+' / '+tasks.length,'Saved acceptance state'),metric('Remaining time',project.estimate?.available?duration(project.estimate.lowerMs)+' – '+duration(project.estimate.upperMs):'Unknown',project.estimate?.available?project.estimate.sampleCount+' samples · empirical range':'No reliable duration history'),metric('Project status',state.primary,state.goal&&state.loop&&state.goal!==state.loop?'Goal '+state.goal+' · loop '+(state.stale?'unconfirmed':state.loop):'Latest reported state')));renderNow(project);
-    }else{periodControls(id);if(projectView==='usage')renderUsageHistory(current,previous);else renderResults(project,current)}
-  }catch(error){if(currentRequest(request.version)&&navigationState.screen==='project'&&selected===id&&!isAbort(error))heading('Project unavailable',error.message)}
+    }else{periodControls(id);if(projectView==='usage')renderUsageHistory(current,previous,projectStatus(project));else if(projectView==='history')renderHistoryExplorer(project,history);else renderResults(project,current)}
+  }catch(error){if(currentRequest(request.version)&&navigationState.screen==='project'&&selected===id&&!isAbort(error)){heading('Project unavailable','Offline or unavailable: '+error.message);content.append(renderCoverage({errors:[],coverage:'Historical analytics are unavailable for this project.'},{unavailable:true}))}}
 }
 if(typeof setInterval==='function')setInterval(()=>{if(selected&&projectView==='now'&&typeof document.hidden!=='undefined'&&!document.hidden&&!['INPUT','SELECT','TEXTAREA'].includes(document.activeElement?.tagName)&&!document.activeElement?.matches?.(':focus-visible'))showProject(selected)},5000);
 `;

package/dist/dashboard/server.js

@@ -1,6 +1,6 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-import { lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse } from 'yaml';
 import { z } from 'zod';
@@ -8,8 +8,14 @@ import { listProjects } from './registry.js';
 import { dashboardPage } from './page.js';
 import { readEvents } from '../observability/events.js';
 import { estimateSchedule } from '../estimation/schedule.js';
-import { pauseProjectGoal } from '../goals/command.js';
-import { parsePeriod, projectAnalytics } from './analytics.js';
+import { pauseProjectGoal, runProjectGoal } from '../goals/command.js';
+import { runLoopCommand } from '../loop/run-command.js';
+import { isPidAlive, readLock } from '../loop/lock.js';
+import { appendEvent } from '../observability/events.js';
+import { queueChange } from '../change/inbox.js';
+import { statePath } from '../workspace/state.js';
+import { parsePeriod, parseRanking, projectAnalytics, projectHistory, workspaceAnalytics } from './analytics.js';
+import { DASHBOARD_LIMITS, DashboardChangePayloadSchema, DashboardControlPayloadSchema, DashboardNotePayloadSchema, DashboardResumePayloadSchema, parseDashboardLimit, } from './contracts.js';
 const text = z.string().max(16000);
 const number = z.number().finite().nonnegative();
 const Goal = z.object({ objective: text, status: z.enum(['active', 'running', 'paused', 'blocked', 'complete']), reason: text.optional(), pendingAttempt: z.object({ provider: text, model: text.optional(), startedAt: text }).optional(), attempts: z.array(z.object({ durationMs: number.optional(), provider: text.optional(), success: z.boolean().optional(), summary: text.optional(), inputTokens: number.optional(), outputTokens: number.optional() })).max(200).default([]) });
@@ -17,8 +23,11 @@ const Status = z.object({ state: text, phase: text.optional(), reason: text.opti
 const Stories = z.array(z.object({ id: text, title: text, passes: z.boolean(), priority: number.optional(), area: text.optional(), writes: z.array(text).optional(), needs: z.array(text).optional() })).max(2000);
 const Check = z.object({ id: text, status: z.enum(['passed', 'failed', 'unverified']), generatedAt: text, summary: text, criteria: z.array(z.object({ id: text, text, status: z.enum(['passed', 'failed', 'unverified']), summary: text })).max(500) });
 const Durations = z.array(z.object({ storyId: text, ms: number.positive() })).max(5000);
-const MAX_FILE = 1_048_576;
+const MAX_FILE = DASHBOARD_LIMITS.fileBytes;
+const activeResumes = new Set();
 function safeFile(root, relative) {
+    if (!relative || relative.startsWith('/') || relative.includes('\\') || relative.split('/').some(part => !part || part === '.' || part === '..'))
+        throw new Error('Unsafe project path');
     let file = root;
     try {
         for (const part of relative.split('/')) {
@@ -39,6 +48,62 @@ function safeFile(root, relative) {
         throw error;
     }
 }
+function requestBody(req, empty = { action: 'pause' }) {
+    const length = req.headers['content-length'];
+    if (typeof length === 'string' && Number.isFinite(Number(length)) && Number(length) > DASHBOARD_LIMITS.requestBytes) {
+        req.resume();
+        return Promise.reject(new Error('Dashboard request body too large'));
+    }
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let rejected = false;
+        req.on('data', chunk => {
+            size += Buffer.byteLength(chunk);
+            if (size > DASHBOARD_LIMITS.requestBytes) {
+                rejected = true;
+                req.resume();
+                reject(new Error('Dashboard request body too large'));
+                return;
+            }
+            chunks.push(Buffer.from(chunk));
+        });
+        req.on('end', () => {
+            if (rejected)
+                return;
+            const body = Buffer.concat(chunks).toString('utf8').trim();
+            if (!body) {
+                resolve(empty);
+                return;
+            }
+            try {
+                resolve(JSON.parse(body));
+            }
+            catch {
+                reject(new Error('Invalid dashboard request body'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function writePauseSignal(root) {
+    const directory = statePath(root);
+    const path = statePath(root, 'loop.pause');
+    mkdirSync(directory, { recursive: true });
+    try {
+        writeFileSync(path, 'pause\n', { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+}
+function projectIsRunning(root) {
+    if (activeResumes.has(root))
+        return true;
+    const lock = readLock(root);
+    return Boolean(lock && isPidAlive(lock.pid));
+}
 function snapshot(project, detail) {
     const errors = project.error ? [project.error] : [];
     const read = (file, schema, yaml = false) => {
@@ -75,13 +140,13 @@ function snapshot(project, detail) {
                 errors.push(error.message);
         }
     }
-    return { ...project, goal, status, errors, ...(detail ? { stories, check, events: project.error ? [] : readEvents(project.root, 100), estimate: estimateSchedule(stories, Math.max(1, status?.parallel?.maxConcurrency ?? 1), history) } : {}) };
+    return { ...project, goal, status, errors, ...(detail ? { stories, check, events: project.error ? [] : readEvents(project.root, DASHBOARD_LIMITS.events), estimate: estimateSchedule(stories, Math.max(1, status?.parallel?.maxConcurrency ?? 1), history) } : {}) };
 }
 export async function startDashboard(options = {}) {
     const token = randomBytes(32).toString('hex');
     const nonce = randomBytes(24).toString('base64');
     let origin = '';
-    const server = createServer((req, res) => {
+    const server = createServer(async (req, res) => {
         res.setHeader('Cache-Control', 'no-store');
         res.setHeader('X-Content-Type-Options', 'nosniff');
         res.setHeader('Referrer-Policy', 'no-referrer');
@@ -91,14 +156,19 @@ export async function startDashboard(options = {}) {
             send(403, { error: 'Untrusted request origin' });
             return;
         }
-        let path;
+        let requested;
         try {
-            path = new URL(req.url ?? '/', origin).pathname;
+            requested = new URL(req.url ?? '/', origin);
         }
         catch {
             send(400, { error: 'Invalid URL' });
             return;
         }
+        if (requested.origin !== origin) {
+            send(403, { error: 'Untrusted request origin' });
+            return;
+        }
+        const path = requested.pathname;
         if (req.method === 'POST') {
             const supplied = req.headers['x-yoke-token'];
             if (req.headers.origin !== origin || typeof supplied !== 'string' || Buffer.byteLength(supplied) !== token.length || !timingSafeEqual(Buffer.from(supplied), Buffer.from(token))) {
@@ -121,7 +191,20 @@ export async function startDashboard(options = {}) {
                 send(200, listProjects().map(project => snapshot(project, false)));
                 return;
             }
-            const match = /^\/api\/projects\/([a-f0-9]{32})(\/pause|\/analytics)?$/u.exec(path);
+            if (req.method === 'GET' && path === '/api/workspace/analytics') {
+                let period, sort;
+                try {
+                    period = parsePeriod(requested.searchParams);
+                    sort = parseRanking(requested.searchParams);
+                }
+                catch (error) {
+                    send(400, { error: error.message });
+                    return;
+                }
+                send(200, workspaceAnalytics(listProjects(), period, sort));
+                return;
+            }
+            const match = /^\/api\/projects\/([a-f0-9]{32})(\/pause|\/resume|\/notes|\/changes|\/analytics|\/history|\/events)?$/u.exec(path);
             if (match) {
                 const project = listProjects().find(project => project.id === match[1]);
                 if (!project) {
@@ -135,7 +218,7 @@ export async function startDashboard(options = {}) {
                     }
                     let period;
                     try {
-                        period = parsePeriod(new URL(req.url, origin).searchParams);
+                        period = parsePeriod(requested.searchParams);
                     }
                     catch (error) {
                         send(400, { error: error.message });
@@ -144,18 +227,110 @@ export async function startDashboard(options = {}) {
                     send(200, projectAnalytics(project.root, period));
                     return;
                 }
+                if (req.method === 'GET' && (match[2] === '/history' || match[2] === '/events')) {
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    let period, limit;
+                    try {
+                        period = parsePeriod(requested.searchParams);
+                        limit = parseDashboardLimit(requested.searchParams.get('limit'));
+                    }
+                    catch (error) {
+                        send(400, { error: error.message });
+                        return;
+                    }
+                    send(200, projectHistory(project.root, period, limit));
+                    return;
+                }
                 if (req.method === 'GET' && !match[2]) {
                     send(200, snapshot(project, true));
                     return;
                 }
                 if (req.method === 'POST' && match[2] === '/pause') {
-                    if (project.error || !snapshot(project, false).goal) {
-                        send(409, { error: 'No readable project goal' });
+                    try {
+                        DashboardControlPayloadSchema.parse(await requestBody(req, { action: 'pause' }));
+                    }
+                    catch (error) {
+                        send(error.message === 'Dashboard request body too large' ? 413 : 400, { error: error.message === 'Dashboard request body too large' ? error.message : 'Invalid dashboard control payload' });
+                        return;
+                    }
+                    const current = snapshot(project, false);
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    if (current.goal)
+                        pauseProjectGoal(project.root);
+                    writePauseSignal(project.root);
+                    const response = { status: 'pause-requested' };
+                    send(200, response);
+                    return;
+                }
+                if (req.method === 'POST' && match[2] === '/resume') {
+                    try {
+                        DashboardResumePayloadSchema.parse(await requestBody(req, { action: 'resume' }));
+                    }
+                    catch (error) {
+                        send(error.message === 'Dashboard request body too large' ? 413 : 400, { error: error.message === 'Dashboard request body too large' ? error.message : 'Invalid dashboard resume payload' });
+                        return;
+                    }
+                    const current = snapshot(project, false);
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    if (projectIsRunning(project.root)) {
+                        send(409, { status: 'already-running', error: 'Project is already running' });
+                        return;
+                    }
+                    const goal = current.goal !== null && current.goal.status !== 'complete';
+                    activeResumes.add(project.root);
+                    void Promise.resolve().then(async () => {
+                        if (goal)
+                            await runProjectGoal(project.root);
+                        else
+                            await runLoopCommand(project.root, {});
+                    }).catch(() => undefined).finally(() => { activeResumes.delete(project.root); });
+                    const response = { status: 'resume-requested' };
+                    send(202, response);
+                    return;
+                }
+                if (req.method === 'POST' && match[2] === '/notes') {
+                    let payload;
+                    try {
+                        payload = DashboardNotePayloadSchema.parse(await requestBody(req, {}));
+                    }
+                    catch (error) {
+                        send(error.message === 'Dashboard request body too large' ? 413 : 400, { error: error.message === 'Dashboard request body too large' ? error.message : 'Invalid dashboard note payload' });
+                        return;
+                    }
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    appendEvent(project.root, { runId: 'dashboard', timestamp: new Date().toISOString(), type: 'operator-note', data: { note: payload.note } });
+                    const response = { status: 'note-added' };
+                    send(200, response);
+                    return;
+                }
+                if (req.method === 'POST' && match[2] === '/changes') {
+                    let payload;
+                    try {
+                        payload = DashboardChangePayloadSchema.parse(await requestBody(req, {}));
+                    }
+                    catch (error) {
+                        send(error.message === 'Dashboard request body too large' ? 413 : 400, { error: error.message === 'Dashboard request body too large' ? error.message : 'Invalid dashboard change payload' });
+                        return;
+                    }
+                    if (project.error) {
+                        send(409, { error: project.error });
                         return;
                     }
-                    safeFile(project.root, '.yoke/goal.pause');
-                    pauseProjectGoal(project.root);
-                    send(200, { status: 'pause-requested' });
+                    const change = queueChange(project.root, payload.request);
+                    const response = { status: 'pending', requestId: change.id };
+                    send(200, response);
                     return;
                 }
             }

package/dist/goals/command.js

@@ -10,10 +10,11 @@ import { acquireLock, releaseLock, isPidAlive } from '../loop/lock.js';
 import { reapProviderProcesses, isProviderTreeAlive } from '../loop/cleanup.js';
 import { killProcessTreeForCleanup } from '../loop/watchdog.js';
 import { buildProviderInvocation, startProviderProcess } from '../agents/providers.js';
+import { AgentSchema } from '../agents/contracts.js';
 import { appendEvent } from '../observability/events.js';
 import { statePath } from '../workspace/state.js';
-const Attempt = z.object({ provider: z.enum(['codex', 'claude', 'gemini', 'qwen']), model: z.string().optional(), startedAt: z.string(), durationMs: z.number().nonnegative(), success: z.boolean(), summary: z.string(), checkId: z.string(), inputTokens: z.number().nonnegative().optional(), outputTokens: z.number().nonnegative().optional() });
-const Goal = z.object({ version: z.literal(1), id: z.string().uuid(), objective: z.string().trim().min(1).max(16000), status: z.enum(['active', 'running', 'paused', 'blocked', 'complete']), createdAt: z.string(), updatedAt: z.string(), maxAttempts: z.number().int().min(1).max(20), maxMinutes: z.number().positive().max(1440), tokenBudget: z.number().int().positive().optional(), attempts: z.array(Attempt), reason: z.string().optional(), lastCheck: z.string().optional(), pendingAttempt: z.object({ provider: z.enum(['codex', 'claude', 'gemini', 'qwen']), model: z.string().optional(), startedAt: z.string().datetime() }).optional() }).strict();
+const Attempt = z.object({ provider: AgentSchema, model: z.string().optional(), startedAt: z.string(), durationMs: z.number().nonnegative(), success: z.boolean(), summary: z.string(), checkId: z.string(), inputTokens: z.number().nonnegative().optional(), outputTokens: z.number().nonnegative().optional() });
+const Goal = z.object({ version: z.literal(1), id: z.string().uuid(), objective: z.string().trim().min(1).max(16000), status: z.enum(['active', 'running', 'paused', 'blocked', 'complete']), createdAt: z.string(), updatedAt: z.string(), maxAttempts: z.number().int().min(1).max(20), maxMinutes: z.number().positive().max(1440), tokenBudget: z.number().int().positive().optional(), attempts: z.array(Attempt), reason: z.string().optional(), lastCheck: z.string().optional(), pendingAttempt: z.object({ provider: AgentSchema, model: z.string().optional(), startedAt: z.string().datetime() }).optional() }).strict();
 const goalPath = (root) => statePath(root, 'goal.json');
 function save(root, goal) {
     const parsed = Goal.parse({ ...goal, updatedAt: new Date().toISOString() });

package/dist/loop/claims.js

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import { isPidAlive } from './lock.js';
 import { publishClaimFile, replaceClaimFile, withClaimOperations } from './claim-lease.js';
 import { storyPathSegment } from './prd.js';
+import { AgentSchema } from '../agents/contracts.js';
 export const CLAIM_SCHEMA_VERSION = 2;
 const LegacyClaimSchema = z.object({
     storyId: z.string().min(1),
@@ -18,7 +19,7 @@ const RichClaimSchema = LegacyClaimSchema.extend({
     heartbeatAt: z.string().min(1),
     baseCommit: z.string().min(1).optional(),
     worktree: z.string().min(1).optional(),
-    provider: z.enum(['claude', 'codex', 'gemini', 'qwen']).optional(),
+    provider: AgentSchema.optional(),
     model: z.string().min(1).optional(),
     role: z.enum(['implementation', 'quality', 'repair', 'review']).optional(),
     cancellation: z.object({

package/dist/loop/decision.js

@@ -10,6 +10,7 @@ import { resolveCommitIdentity } from './identity.js';
 import { commitPaths, realGitOps } from './git.js';
 import { acquireLock, releaseLock } from './lock.js';
 import { loadPrd, selectNextStory } from './prd.js';
+import { AgentSchema } from '../agents/contracts.js';
 const singleLine = (max) => z.string().trim().min(1).max(max).refine(value => !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value), 'must be a single line without control or bidi-formatting characters');
 const MAX_STATE_BYTES = 256 * 1024;
 const DecisionOptionSchema = z.object({
@@ -60,9 +61,9 @@ export const DecisionResumeSchema = z.object({
     answered: z.boolean().optional(),
     /** Absent preserves the default unlimited run across a critical-decision resume. */
     maxIterations: z.number().int().positive().optional(),
-    agent: z.enum(['claude', 'codex', 'gemini', 'qwen']).optional(),
+    agent: AgentSchema.optional(),
     isolate: z.boolean().optional(),
-    reviewer: z.enum(['claude', 'codex', 'gemini', 'qwen']).optional(),
+    reviewer: AgentSchema.optional(),
     review: z.boolean().optional(),
     allowSelfReview: z.boolean().optional(),
     timeoutMinutes: z.number().nonnegative().optional(),

package/dist/loop/parallel-command.js

@@ -255,7 +255,7 @@ function asyncRunner(input, provider, signal, workerId) {
     if (input.routing) {
         const routed = makeAsyncAdaptiveRunner({
             parent: input.routing.strategy === 'capability' ? input.runnerAgent : provider.provider,
-            parentSelection: input.routing.strategy === 'capability' ? input.selection : { ...input.selection, model: provider.model, reasoningEffort: provider.reasoningEffort, nativeMultiAgent: false },
+            parentSelection: input.routing.strategy === 'capability' ? input.selection : { ...input.selection, provider: provider.providerModel, model: provider.model, reasoningEffort: provider.reasoningEffort, variant: provider.variant, nativeMultiAgent: false },
             projectRoot: input.targetDir,
             workers: input.routing.workers,
             rules: input.routing.rules,
@@ -276,7 +276,7 @@ function asyncRunner(input, provider, signal, workerId) {
             makeWorker: (agent, selection) => async (context) => {
                 if (signal?.aborted)
                     return { success: false, summary: 'Routing cancelled before worker start' };
-                input.reporter.parallelWorker?.({ story: context.story.id, storyTitle: context.story.title, provider: agent, selectedProvider: agent, selectedModel: selection.model, phase: 'implementing' });
+                input.reporter.parallelWorker?.({ story: context.story.id, storyTitle: context.story.title, provider: agent, selectedProvider: selection.provider ?? agent, selectedModel: selection.model, selectedVariant: selection.variant, phase: 'implementing' });
                 const run = makeAsyncRunner(agent, { onAmbiguity: input.onAmbiguity, permissions: input.permissions, selection,
                     process: { idleTimeoutMs: input.idleMs, signal, workerId } });
                 return providerProcessResultToAgentResult(agent, context.story.id, await run(context).completion);
@@ -292,10 +292,12 @@ function asyncRunner(input, provider, signal, workerId) {
         permissions: input.permissions,
         selection: {
             ...selection,
+            ...(provider.providerModel ? { provider: provider.providerModel } : {}),
             ...(provider.provider !== 'gemini' && globalBare !== undefined ? { bare: globalBare } : {}),
             nativeMultiAgent: false,
             ...(provider.model ? { model: provider.model } : {}),
             ...(provider.reasoningEffort ? { reasoningEffort: provider.reasoningEffort } : {}),
+            ...(provider.variant ? { variant: provider.variant } : {}),
         },
         process: { idleTimeoutMs: input.idleMs, signal, workerId },
     });