@aiwuk/team 0.0.0-stage → 5.0.8

package/client/05-policy.js

@@ -0,0 +1,217 @@
+    // ---------- right sidebar: team overview ----------
+    const TIER_ORDER = ['high', 'upper', 'medium', 'low'];
+    const PAGE = 40;
+    const isRule = entry => entry.endsWith('*');
+    /** Same semantics as the host: exact provider/model keys, or "prefix*" on the full key or the bare model id. */
+    const ruleMatcher = list => {
+      const exact = new Set(), prefixes = [];
+      for (const entry of list) (isRule(entry) ? prefixes.push(entry.slice(0, -1)) : exact.add(entry));
+      return key => exact.has(key) || prefixes.some(p => key.startsWith(p) || key.slice(key.indexOf('/') + 1).startsWith(p));
+    };
+    const ruleCovers = (rule, key) => ruleMatcher([rule])(key);
+    /** User input → normalized prefix rule, or null when it is not a usable prefix. */
+    const toRule = text => {
+      const base = String(text ?? '').trim().replace(/\*+$/, '');
+      return base.length >= 2 && !/[*\s]/.test(base) ? base + '*' : null;
+    };
+    const tierRank = tier => { const i = TIER_ORDER.indexOf(tier); return i === -1 ? (tier === 'unknown' ? 99 : 50) : i; };
+    const routeText = route => typeof route === 'string' ? route : route?.provider ? `${route.provider}/${route.model}` : '';
+    const when = value => {
+      if (value == null) return '';
+      const date = new Date(value);
+      return Number.isNaN(date.getTime()) ? '' : date.toLocaleString(undefined, { hour12: false, month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    };
+    const timeOfDay = value => {
+      if (value == null) return '';
+      const date = new Date(value);
+      return Number.isNaN(date.getTime()) ? '' : date.toLocaleTimeString(undefined, { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    };
+    /** Labelled translation that falls back to the raw value when no dictionary entry exists. */
+    const label = (t, key, fallback) => { const text = t(key); return text === key ? fallback : text; };
+    const stat = (value, text, tone, key) => h('div', { className: 'ctm-ov-stat', 'data-tone': tone, key }, h('strong', null, value), h('span', null, text));
+
+    function ModelPolicyEditor({ sessionId, policy, save, t }) {
+      const [draft, setDraft] = React.useState(policy.disabledRoutes ?? []);
+      const [status, setStatus] = React.useState({});
+      const [revision, setRevision] = React.useState(policy.revision);
+      const [saved, setSaved] = React.useState(policy.disabledRoutes ?? []);
+      const [query, setQuery] = React.useState('');
+      const [tierTab, setTierTab] = React.useState(null);
+      const [limit, setLimit] = React.useState(PAGE);
+      const [prefix, setPrefix] = React.useState('');
+      const isOff = ruleMatcher(draft);
+      const rules = draft.filter(isRule);
+      const ruleFor = key => draft.includes(key) ? null : rules.find(rule => ruleCovers(rule, key));
+      const pending = draft.filter(key => !saved.includes(key)).length + saved.filter(key => !draft.includes(key)).length;
+      const rows = policy.rows ?? [];
+      const names = new Map((policy.allocations ?? []).map(a => [a.id, a.displayName]));
+      const who = ids => ids.map(id => names.get(id) ?? id).join(t('common.listSep'));
+      const needle = query.trim().toLowerCase();
+      const matches = row => !needle || [row.key, who(row.primaryFor ?? []), who(row.fallbackFor ?? [])].join(' ').toLowerCase().includes(needle);
+      const groups = new Map();
+      for (const row of rows) {
+        const tier = row.tiers?.[0] ?? 'unknown';
+        if (!groups.has(tier)) groups.set(tier, []);
+        groups.get(tier).push(row);
+      }
+      const toggle = (key, enabled) => {
+        setDraft(old => enabled ? old.filter(k => k !== key) : [...new Set([...old, key])]);
+        setStatus({});
+      };
+      const submit = async () => {
+        setStatus({ busy: true });
+        try {
+          const result = await save(sessionId, draft, revision);
+          setRevision(result.revision); setSaved(result.disabledRoutes); setDraft(result.disabledRoutes);
+          setStatus({ success: true });
+        } catch (error) { setStatus({ error: String(error.message ?? error) }); }
+      };
+      const modelRow = (row, showTier) => {
+        const enabled = !isOff(row.key);
+        const rule = enabled ? null : ruleFor(row.key);
+        const usage = [
+          row.primaryFor?.length ? chip(t('models.primary'), who(row.primaryFor), 'p') : null,
+          row.fallbackFor?.length ? chip(t('models.fallback'), who(row.fallbackFor), 'f') : null,
+        ].filter(Boolean);
+        return h('label', { key: row.key, className: 'ctm-ov-model', ...(enabled ? {} : { 'data-off': '' }) },
+          h('input', { type: 'checkbox', className: 'ctm-switch', role: 'switch', checked: enabled, disabled: status.busy || !!rule, title: rule ? fmt(t('models.byRule'), { rule }) : undefined, 'aria-label': `${t('models.enabled')} ${row.key}`,
+            onChange: e => toggle(row.key, e.target.checked) }),
+          h('div', { className: 'ctm-ov-model-main' },
+            h('div', { className: 'ctm-ov-model-name' },
+              h('span', { className: 'ctm-name' }, row.model ?? row.key),
+              row.provider ? h('span', { className: 'ctm-sub' }, row.provider) : null,
+              showTier && row.tiers?.[0] ? badge(label(t, `tier.${row.tiers[0]}`, row.tiers[0]), undefined, 'tier') : null,
+              enabled ? null : badge(rule ? fmt(t('models.byRule'), { rule }) : t('models.disabledBadge'), 'warn', 'off')),
+            usage.length ? h('div', { className: 'ctm-chips' }, ...usage) : h('span', { className: 'ctm-sub' }, t('models.unused'))));
+      };
+      const orphans = draft.filter(key => !isRule(key) && !rows.some(row => row.key === key));
+      const candidate = toRule(prefix);
+      const preview = candidate ? rows.filter(row => ruleCovers(candidate, row.key)) : [];
+      const addRule = () => {
+        if (!candidate || draft.includes(candidate)) return;
+        setDraft(old => [...new Set([...old, candidate])]); setPrefix(''); setStatus({});
+      };
+      const removeRule = rule => { setDraft(old => old.filter(k => k !== rule)); setStatus({}); };
+      const tiers = [...groups.keys()].sort((a, b) => tierRank(a) - tierRank(b));
+      // Large catalogs (hundreds of routes): open on one tier, list routes in use first, render in pages.
+      const activeTier = tierTab === 'all' || groups.has(tierTab) ? tierTab : tiers[0] ?? 'all';
+      const scoped = activeTier === 'all' ? tiers.flatMap(tier => groups.get(tier)) : groups.get(activeTier);
+      const wasOff = ruleMatcher(saved);
+      const weight = row => row.primaryFor?.length ? 0 : row.fallbackFor?.length ? 1 : wasOff(row.key) ? 2 : 3;
+      const shown = scoped.filter(matches).map((row, index) => ({ row, index })).sort((a, b) => weight(a.row) - weight(b.row) || a.index - b.index).map(x => x.row);
+      const visible = shown.slice(0, limit);
+      const tierTabButton = (id, text, list) => {
+        const count = list.filter(row => isOff(row.key)).length;
+        return h('button', { key: id, type: 'button', role: 'tab', className: 'ctm-ov-tier', 'aria-selected': activeTier === id, onClick: () => { setTierTab(id); setLimit(PAGE); } },
+          text, h('span', { className: 'ctm-ov-count' }, String(list.length)), count ? h('span', { className: 'ctm-ov-offdot', title: fmt(t('models.tierCount'), { n: list.length, d: count }) }) : null);
+      };
+      return h('div', { className: 'ctm-ov-editor' },
+        h('div', { className: 'ctm-ov-toolbar' },
+          h('button', { type: 'button', className: 'ctm-btn', 'data-primary': '', disabled: !pending || status.busy, onClick: submit }, t(status.busy ? 'models.saving' : 'models.save')),
+          pending && !status.busy ? h('button', { type: 'button', className: 'ctm-btn', onClick: () => { setDraft(saved); setStatus({}); } }, t('models.reset')) : null,
+          status.error ? h('span', { role: 'alert', className: 'ctm-ov-note ctm-error' }, status.error)
+            : status.success ? h('span', { role: 'status', className: 'ctm-ov-note ctm-success' }, t('models.saved'))
+            : pending ? h('span', { className: 'ctm-ov-note ctm-warn' }, fmt(t('models.dirty'), { n: pending })) : null),
+        h('p', { className: 'ctm-sub ctm-ov-help' }, t('models.help')),
+        h('div', { className: 'ctm-ov-block' },
+          h('div', { className: 'ctm-label' }, t('models.preview')),
+          revision === policy.revision
+            ? h('div', { className: 'ctm-ov-allocs' }, ...(policy.allocations ?? []).map(role => h('div', { key: role.id, className: 'ctm-ov-alloc', 'data-status': role.status, title: role.reason ?? '' },
+                h('span', { className: 'ctm-name' }, role.displayName),
+                role.primary ? h('div', { className: 'ctm-ov-chain' },
+                  h('span', { className: 'ctm-ov-hop', 'data-primary': '', title: role.primary }, role.primary),
+                  ...(role.fallbacks ?? []).flatMap((route, i) => [h('span', { key: 'a' + i, className: 'ctm-ov-arrow', 'aria-hidden': true }, '›'), h('span', { key: 'r' + i, className: 'ctm-ov-hop', title: route }, route)]))
+                  : h('span', { className: 'ctm-ov-route ctm-warn' }, t('models.' + role.status)))))
+            : h('p', { className: 'ctm-sub' }, t('models.refreshPreview'))),
+        rows.length > 6 ? h('input', { type: 'search', className: 'ctm-ov-search', placeholder: t('models.filter'), value: query, onChange: e => { setQuery(e.target.value); setLimit(PAGE); } }) : null,
+        h('div', { className: 'ctm-ov-block ctm-ov-rules' },
+          h('div', { className: 'ctm-label' }, t('models.prefixTitle')),
+          h('div', { className: 'ctm-ov-rule-input' },
+            h('input', { type: 'text', className: 'ctm-ov-search', placeholder: t('models.prefixPlaceholder'), value: prefix, disabled: status.busy, 'aria-label': t('models.prefixTitle'),
+              onChange: e => setPrefix(e.target.value), onKeyDown: e => { if (e.key === 'Enter') { e.preventDefault(); addRule(); } } }),
+            h('button', { type: 'button', className: 'ctm-btn', disabled: !candidate || draft.includes(candidate) || status.busy, onClick: addRule }, t('models.prefixAdd'))),
+          prefix.trim() ? h('p', { className: candidate && preview.length ? 'ctm-sub' : 'ctm-sub ctm-warn' },
+            !candidate ? t('models.prefixInvalid')
+              : draft.includes(candidate) ? t('models.prefixExists')
+              : fmt(t('models.prefixPreview'), { rule: candidate, n: preview.length, list: preview.slice(0, 3).map(row => row.key).join(t('common.listSep')) + (preview.length > 3 ? '…' : '') })) : null,
+          rules.length ? h('div', { className: 'ctm-chips' }, ...rules.map(rule => h('span', { key: rule, className: 'ctm-chip ctm-ov-rule' },
+            h('span', null, rule), h('span', null, fmt(t('models.ruleCount'), { n: rows.filter(row => ruleCovers(rule, row.key)).length })),
+            h('button', { type: 'button', className: 'ctm-ov-rule-x', disabled: status.busy, 'aria-label': fmt(t('models.ruleRemove'), { rule }), onClick: () => removeRule(rule) }, '×'))))
+            : h('p', { className: 'ctm-sub' }, t('models.prefixHelp'))),
+        tiers.length ? h('div', { className: 'ctm-ov-tiers', role: 'tablist', 'aria-label': t('models.tiers') },
+          tierTabButton('all', t('models.allTiers'), rows), ...tiers.map(tier => tierTabButton(tier, label(t, `tier.${tier}`, tier), groups.get(tier)))) : null,
+        shown.length ? h('div', { className: 'ctm-ov-group' }, h('div', { className: 'ctm-ov-list ctm-ov-list-flat' }, ...visible.map(row => modelRow(row, activeTier === 'all'))))
+          : rows.length ? h('p', { className: 'ctm-sub' }, t('models.noMatch')) : null,
+        shown.length > visible.length ? h('button', { type: 'button', className: 'ctm-btn ctm-ov-more', onClick: () => setLimit(n => n + PAGE * 2) },
+          fmt(t('models.more'), { n: shown.length - visible.length })) : null,
+        orphans.length ? h('details', { className: 'ctm-ov-group', open: true },
+          h('summary', null, h('span', { className: 'ctm-name' }, t('models.orphans')), h('span', { className: 'ctm-sub' }, String(orphans.length))),
+          h('div', { className: 'ctm-ov-list' }, ...orphans.map(key => modelRow({ key })))) : null);
+    }
+
+    // Live polling re-renders the overview every few seconds; the editor only changes with its own data.
+    const PolicyEditor = React.memo ? React.memo(ModelPolicyEditor, (a, b) => a.sessionId === b.sessionId && a.policy === b.policy
+      && a.save === b.save && (a.t === b.t || a.t('models.save') === b.t('models.save'))) : ModelPolicyEditor;
+
+    function RoleCards({ roles, live, t }) {
+      return h('div', { className: 'ctm-ov-roles' }, ...localizeRoles(roles, t).map(r => {
+        const fallbacks = (Array.isArray(r.fallbacks) ? r.fallbacks : []).map(routeText).filter(Boolean);
+        return h('div', { key: r.id, className: 'ctm-ov-role' },
+          h('div', { className: 'ctm-ov-role-head' },
+            h('span', { className: 'ctm-name' }, r.displayName ?? r.id),
+            r.tier ? badge(label(t, `tier.${r.tier}`, r.tier), r.tier === 'high' ? 'brand' : undefined, 'tier') : null,
+            r.singleModel ? h('span', { className: 'ctm-badge', 'data-tone': 'warn', 'data-single-model': '', title: t('roles.singleModelHint') }, t('roles.singleModel')) : null),
+          h('span', { className: 'ctm-sub' }, [r.id, r.capability].filter(Boolean).join(' · ')),
+          r.description ? h('span', { className: 'ctm-ov-desc' }, r.description) : null,
+          r.whenToUse ? h('span', { className: 'ctm-sub' }, fmt(t('roles.whenToUse'), { text: r.whenToUse })) : null,
+          h('span', { className: r.provider ? 'ctm-ov-route' : 'ctm-ov-route ctm-warn', title: r.blocked },
+            r.provider ? `${r.provider}/${r.model}` : t(r.blocked ? 'models.blocked' : 'team.unassigned')),
+          liveRoleLine(live?.get(r.id), t, r),
+          fallbacks.length ? h('span', { className: 'ctm-sub', title: fallbacks.join('\n') }, fmt(t('roles.fallbackList'), { list: fallbacks.join(t('common.listSep')) })) : null,
+          r.maxTokens || r.longContext || r.planFirst ? h('div', { className: 'ctm-chips' },
+            r.planFirst ? badge(t('roles.planFirst'), 'brand', 'p') : null,
+            r.maxTokens ? badge(fmt(t('roles.maxTokens'), { n: compact(r.maxTokens) }), undefined, 'm') : null,
+            r.longContext ? badge(fmt(t('roles.longContext'), { n: compact(r.longContext.thresholdTokens), route: `${r.longContext.provider}/${r.longContext.model}` }), undefined, 'l') : null) : null,
+          accessBadges(r.access, t));
+      }));
+    }
+    /** The member currently filling this role: live status and the model of its latest request. */
+    function liveRoleLine(member, t, role) {
+      if (!member) return null;
+      const route = member.model ? [member.provider, member.model].filter(Boolean).join('/') : null;
+      return h('div', { className: 'ctm-chips' },
+        badge(label(t, `live.${member.status}`, member.status), LIVE[member.status], 's'),
+        route ? h('span', { className: 'ctm-sub', title: t('roles.liveModel') }, fmt(t('roles.current'), { route })) : null,
+        route && routeOutsideConfig(route, role) ? routeWarnBadge(t) : null);
+    }
+    /** Permission chips for one role; nothing when the capability has no access policy. */
+    function accessBadges(access, t) {
+      if (!access || typeof access !== 'object') return null;
+      const items = [];
+      if (Array.isArray(access.editPaths)) items.push(access.editPaths.length ? fmt(t('roles.editOnly'), { list: access.editPaths.join(t('common.listSep')) }) : t('roles.noEdit'));
+      if (access.preset) items.push(fmt(t('roles.preset'), { name: access.preset }));
+      else if (access.shell === false) items.push(t('roles.noShell'));
+      if (access.deny?.length) items.push(fmt(t('roles.deny'), { list: access.deny.join(t('common.listSep')) }));
+      return items.length ? h('div', { className: 'ctm-chips', title: t('roles.accessHint') }, ...items.map((text, i) => badge(text, 'warn', 'a' + i))) : null;
+    }
+
+    function WorkflowList({ workflow, t }) {
+      if (!workflow || typeof workflow !== 'object') return h('span', { className: 'ctm-sub' }, '—');
+      const value = (key, v) => {
+        if (key === 'mode') return label(t, `workflow.mode.${v}`, String(v));
+        if (key === 'freeTools') return label(t, `tools.${v}`, String(v));
+        if (key === 'analysisBudget' || key === 'directBudget') return fmt(t('workflow.times'), { n: v });
+        if (key === 'freeModels' && Array.isArray(v) && !v.length) return t('workflow.allFree');
+        if (key === 'tokens') return v ? fmt(t('workflow.tokens.value'), { ratio: Math.round(v.idleCompactRatio * 100), chars: v.trimToolOutputChars }) : t('workflow.fileLimits.off');
+        if (key === 'enforceWriteScopes') return t(v ? 'workflow.enforceWriteScopes.on' : 'workflow.enforceWriteScopes.off');
+        if (key === 'confirmDispatch') return label(t, `workflow.confirmDispatch.${v}`, String(v));
+        if (key === 'rotation') return v ? fmt(t('workflow.rotation.value'), { soft: v.softCompactions, hard: v.hardCompactions, ratio: Math.round(v.hardRatio * 100), turns: v.hardTurns }) : t('workflow.fileLimits.off');
+        if (key === 'fileLimits') return v ? fmt(t('workflow.fileLimits.value'), { source: v.sourceMax, test: v.testMax, read: v.readMax, report: v.reportMax }) : t('workflow.fileLimits.off');
+        if (Array.isArray(v)) return h('div', { className: 'ctm-chips' }, ...v.map(item => h('span', { key: String(item), className: 'ctm-chip' }, String(item))));
+        return typeof v === 'object' ? h('pre', { className: 'ctm-pre', 'data-short': '' }, JSON.stringify(v, null, 2)) : String(v);
+      };
+      return h('div', { className: 'ctm-grid ctm-ov-kv' }, ...Object.entries(workflow).flatMap(([key, v]) => [
+        h('span', { key: `k${key}`, className: 'ctm-sub' }, label(t, `workflow.${key}`, key)),
+        h('div', { key: `v${key}`, className: 'ctm-text' }, value(key, v)),
+      ]));
+    }

package/client/06-usage.js

@@ -0,0 +1,195 @@
+    const billable = u => (u?.uncachedInputTokens ?? 0) + (u?.cacheWriteTokens ?? 0) + (u?.outputTokens ?? 0);
+    const isUnknownUsage = row => !row || !row.totals || row.coverage === 'unknown' || row.reportedSamples === 0;
+    const usageTotal = rows => {
+      const known = (rows ?? []).filter(r => !isUnknownUsage(r));
+      return known.length ? known.reduce((n, row) => n + billable(row.totals), 0) : null;
+    };
+    const compact = n => n >= 1e6 ? `${(n / 1e6).toFixed(n >= 1e7 ? 0 : 1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(n >= 1e4 ? 0 : 1)}k` : String(n);
+    const splitRoute = route => { const i = route.indexOf('/'); return i > 0 ? { provider: route.slice(0, i), model: route.slice(i + 1) } : {}; };
+    const PHASE = { provisioning: 'provisioning', failed: 'failed' };
+    /** Roster and board tasks from the Lead's live `agentTeam` projection. Models are attached later by withTrustedRoutes. */
+    function teamActivityFrom(team, live) {
+      return {
+        members: (team.members ?? []).map(m => ({ id: m.id, name: m.name, role: m.role,
+          status: PHASE[m.phase] ?? (m.phase === 'active' ? (live.running(m.id) ? 'running' : 'idle') : 'inactive'),
+          diagnostics: m.error ? [String(m.error.message ?? m.error)] : [] })),
+        tasks: (team.tasks ?? []).map(task => ({
+          id: task.id,
+          subject: task.subject,
+          status: task.status,
+          ...(task.ownerName ? { ownerName: task.ownerName } : {}),
+          ...(Array.isArray(task.blockedBy) ? { blockedBy: task.blockedBy } : task.blockedBy ? { blockedBy: [task.blockedBy] } : {}),
+          ...(task.revision != null ? { revision: task.revision } : {}),
+        })),
+      };
+    }
+    /**
+     * One usage row per member from DSH's own live projections: totals from token-meter's `tokenUsage`, timing from
+     * `sessionStats`, the current model from trustedRoute (own usage routes). Per-model token splits come from the last refresh.
+     */
+    function usageRows(d, liveTeam, live) {
+      const snapshot = new Map((d?.memberEvidence?.length ? d.memberEvidence : d ? [{ sessionId: d.sessionId, name: 'lead', ...(d.requestEvidence ?? {}) }] : [])
+        .filter(m => m.usage).map(m => [m.sessionId, m]));
+      const members = liveTeam?.members ?? [...snapshot.values()].map(m => ({ id: m.sessionId, name: m.name }));
+      const refreshedAt = d?.at;
+      return members.map(m => {
+        const values = liveTeam ? live.projections(m.id) : undefined;
+        const before = snapshot.get(m.id)?.usage;
+        const route = trustedRoute(values, before);
+        const ownUsage = values?.capabilityTeamUsage;
+        // Follow the backend usage contract: read capabilityTeamUsage / snapshot own usage, never host tokenUsage (fork skew)
+        const totals = ownUsage?.totals ?? before?.totals;
+        const routes = (ownUsage?.routes?.length ? ownUsage.routes : before?.routes) ?? [];
+        const coverage = ownUsage?.coverage ?? (before?.coverage ?? (totals ? 'complete' : 'unknown'));
+        const reportedSamples = ownUsage?.reportedSamples ?? before?.reportedSamples ?? (totals ? 1 : 0);
+        const attemptsWithoutUsage = ownUsage?.attemptsWithoutUsage ?? before?.attemptsWithoutUsage ?? 0;
+        return {
+          id: m.id, name: m.name, totals, routes, coverage, reportedSamples, attemptsWithoutUsage,
+          refreshedAt: before ? refreshedAt : undefined,
+          ...(route ? { model: route } : {}),
+          ...(values?.sessionStats ? { stats: values.sessionStats } : {})
+        };
+      }).filter(row => row.totals || row.routes.length || row.stats || row.model);
+    }
+    /** Average model seconds per step, time to first token, and decode speed from one session's `sessionStats`. */
+    function statsLine(stats, t) {
+      if (!stats?.steps) return null;
+      const parts = [fmt(t('usage.step'), { n: stats.steps, s: (stats.llmMs / stats.steps / 1000).toFixed(1) })];
+      if (stats.ttftSteps) parts.push(fmt(t('usage.ttft'), { s: (stats.ttftMs / stats.ttftSteps / 1000).toFixed(1) }));
+      if (stats.decodeMs) parts.push(fmt(t('usage.decode'), { n: Math.round(stats.decodeTokens / (stats.decodeMs / 1000)) }));
+      return parts.join(' · ');
+    }
+    const STEP_CONTEXT_WARN = 80000; // average prompt per step above this usually means the session should rotate
+    /** Average prompt tokens per step and the cache-read share of the prompt, from own usage and step stats. */
+    function contextMetrics(totals, stats) {
+      if (!totals || !stats?.steps) return null;
+      const prompt = (totals.uncachedInputTokens ?? 0) + (totals.cacheReadTokens ?? 0) + (totals.cacheWriteTokens ?? 0);
+      if (!prompt) return null;
+      return { avgPrompt: Math.round(prompt / stats.steps), cacheShare: (totals.cacheReadTokens ?? 0) / prompt, heavy: prompt / stats.steps >= STEP_CONTEXT_WARN };
+    }
+    /** Per-member token usage, each role's budget when its capability sets maxTokens, and model time per step. */
+    function UsageGroups({ rows: members, roles, t }) {
+      const byId = new Map(roles.map(r => [r.id, r]));
+      const top = Math.max(1, ...members.map(m => isUnknownUsage(m) ? 0 : billable(m.totals)));
+      return h('div', { className: 'ctm-ov-block' },
+        h('p', { className: 'ctm-sub ctm-ov-help' }, t('usage.hint')),
+        members.length ? h('span', { className: 'ctm-label' }, fmt(t('usage.total'), { n: usageTotal(members) == null ? t('usage.unknown') : compact(usageTotal(members)) })) : null,
+        ...(members.length ? members.map((m, index) => {
+          const role = byId.get(m.name) ?? byId.get(baseName(m.name));
+          // Same contract as usageTotal and cardMeters: the server sends zeroed totals with coverage 'unknown'.
+          const used = isUnknownUsage(m) ? null : billable(m.totals);
+          const max = role?.maxTokens;
+          const ratio = max && used !== null ? Math.min(1, used / max) : (used !== null ? used / top : 0);
+          const tone = max && used !== null && used >= max ? 'error' : max && ratio >= 0.8 ? 'warn' : undefined;
+          const timing = statsLine(m.stats, t);
+          const ctxm = used === null ? null : contextMetrics(m.totals, m.stats);
+          const freshness = m.refreshedAt ? fmt(t('usage.asOf'), { time: timeOfDay(m.refreshedAt) }) : null;
+          return h('details', { key: m.id ?? index, className: 'ctm-ov-group', open: index === 0 },
+            h('summary', null,
+              h('span', { className: 'ctm-name' }, role?.displayName ?? m.name),
+              used !== null
+                ? h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('usage.billable'), { n: compact(used) }))
+                : h('span', { className: 'ctm-sub ctm-us-num' }, t('usage.unknown')),
+              m.coverage === 'partial' ? badge(t('usage.partialLow'), 'warn', 'partial') : null,
+              max ? badge(fmt(t('usage.budget'), { used: used !== null ? compact(used) : t('usage.unknown'), max: compact(max) }), tone ?? 'brand', 'b') : null),
+            used !== null
+              ? h('div', { className: 'ctm-us-meter', 'data-tone': tone, role: 'presentation' }, h('i', { style: { width: `${(ratio * 100).toFixed(1)}%` } }))
+              : null,
+            tone === 'error' ? h('p', { className: 'ctm-ov-note ctm-error' }, t('usage.over')) : null,
+            ctxm ? h('div', { className: 'ctm-ov-log', title: t('usage.contextHint') },
+              h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('usage.avgPrompt'), { n: compact(ctxm.avgPrompt) })),
+              h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('usage.cacheShare'), { p: Math.round(ctxm.cacheShare * 100) })),
+              ctxm.heavy ? badge(t('usage.heavyContext'), 'warn', 'heavy') : null) : null,
+            m.model || m.stats ? h('div', { className: 'ctm-ov-log' },
+              m.model ? h('span', { className: 'ctm-ov-route', title: m.model }, m.model) : null,
+              timing ? h('span', { className: 'ctm-sub ctm-us-num', title: t('usage.stepHint') }, timing) : null) : null,
+            freshness ? h('div', { className: 'ctm-sub ctm-freshness' }, freshness) : null,
+            m.routes.length ? h('div', { className: 'ctm-ov-logs' }, ...m.routes.map(r => h('div', { key: r.route, className: 'ctm-ov-log' },
+              h('span', { className: 'ctm-ov-route', title: r.route }, r.route),
+              h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('usage.io'), { i: compact(r.uncachedInputTokens + r.cacheWriteTokens), o: compact(r.outputTokens) })),
+              r.cacheReadTokens ? h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('usage.cacheRead'), { n: compact(r.cacheReadTokens) })) : null)))
+              : m.model || m.stats ? null : h('p', { className: 'ctm-sub' }, t('usage.none')));
+        }) : [h('p', { key: 'none', className: 'ctm-sub' }, t('usage.none'))]));
+    }
+
+    /** Live per-member request summary: the model of the latest request and how many steps it took so far. */
+    function LiveRequests({ rows, t }) {
+      const list = rows.filter(row => row.model || row.stats);
+      if (!list.length) return null;
+      return h('div', { className: 'ctm-ov-block' },
+        h('span', { className: 'ctm-label' }, t('logs.live')),
+        h(CollapsibleList, {
+          items: list,
+          limit: 5,
+          className: 'ctm-ov-logs',
+          t,
+          renderItem: row => h('div', { key: row.id, className: 'ctm-ov-log' },
+            h('span', { className: 'ctm-name' }, row.name),
+            row.model ? h('span', { className: 'ctm-ov-route', title: row.model }, row.model) : null,
+            row.stats?.steps ? h('span', { className: 'ctm-sub ctm-us-num' }, fmt(t('logs.steps'), { n: row.stats.steps })) : null),
+        }));
+    }
+
+    function EvidenceGroups({ d, sessionId, t }) {
+      const groups = d.memberEvidence?.length ? d.memberEvidence : [{ sessionId, name: '', ...(d.requestEvidence ?? {}) }];
+      return h('div', { className: 'ctm-ov-block' },
+        h('p', { className: 'ctm-sub ctm-ov-help' }, t('evidence.hint')),
+        ...groups.map((member, index) => {
+          const records = member.records ?? [];
+          const self = member.sessionId === sessionId;
+          return h('details', { key: member.sessionId ?? index, className: 'ctm-ov-group', open: index === 0 },
+            h('summary', null,
+              h('span', { className: 'ctm-name' }, member.name || t('logs.thisSession')),
+              self && member.name ? badge(t('logs.thisSession'), 'brand', 'self') : null,
+              h('span', { className: 'ctm-sub' }, fmt(t('logs.count'), { n: records.length }))),
+            member.unavailable ? h('p', { className: 'ctm-ov-note ctm-warn' }, member.unavailable) : null,
+            records.length ? h(CollapsibleList, {
+              items: records,
+              limit: 5,
+              className: 'ctm-ov-logs',
+              t,
+              renderItem: record => h('div', { key: record.seq, className: 'ctm-ov-log' },
+                h('span', { className: 'ctm-sub ctm-ov-seq' }, `#${record.seq}`),
+                h('span', { className: 'ctm-ov-route', title: `${record.provider}/${record.model}` }, `${record.provider}/${record.model}`),
+                badge(t('evidence.short.' + record.evidence), record.evidence === 'assistant-message' ? 'success' : undefined, 'kind'),
+                record.interrupted ? badge(t('logs.interrupted'), 'warn', 'int') : null,
+                h('span', { className: 'ctm-sub ctm-ov-time', title: t('evidence.' + record.evidence) }, when(record.time))),
+            })
+              : h('p', { className: 'ctm-sub' }, t('evidence.empty')));
+        }));
+    }
+
+    /**
+     * Live roster without any logged command: Lead + direct children from the read-only subagent catalog,
+     * running/idle from host-pushed agent status, names/models/tasks from the last manual snapshot.
+     */
+    /** Pushed status wins; otherwise the catalog/snapshot, never trusting a possibly stale "running". */
+    function memberStatus(member, push, fresh) {
+      if (push) {
+        if (push.error && !push.running) return 'failed';
+        return push.running ? 'running' : 'idle';
+      }
+      if (member.resident === false) return 'inactive';
+      if (member.status === 'running' && !fresh) return 'idle';
+      return member.status ?? (member.resident ? 'idle' : 'inactive');
+    }
+    function liveRoster(leadId, snapshot, children, live, snapshotAt) {
+      // A snapshot status is trusted only if no push could have been missed since it was taken.
+      const fresh = !live || (snapshotAt ?? 0) >= live.startedAt;
+      if (!snapshot && !children) return null;
+      const known = new Map((snapshot?.members ?? []).map(m => [m.id, m]));
+      const rows = children
+        ? [known.get(leadId) ?? { id: leadId, name: 'lead', role: 'lead', diagnostics: [] },
+          ...children.filter(c => c.kind === 'child').map(c => ({ ...(known.get(c.id) ?? { name: c.label ?? c.id, role: 'teammate', diagnostics: [] }), id: c.id, resident: c.activity === 'running' }))]
+        : snapshot.members ?? [];
+      const members = rows.map(m => {
+        const push = live?.status?.(m.id);
+        const status = memberStatus(m, push, fresh);
+        return { ...m, status, since: push?.running ? push.since : undefined,
+          diagnostics: push?.error && !push.running ? [push.error, ...(m.diagnostics ?? [])] : m.diagnostics ?? [] };
+      });
+      return { members, tasks: snapshot?.tasks ?? [], unavailable: snapshot?.unavailable, at: live ? Date.now() : undefined };
+    }
+    const LIVE = { running: 'brand', provisioning: 'brand', idle: 'success', failed: 'error', inactive: undefined };
+    const elapsed = ms => { const s = Math.max(0, Math.floor(ms / 1000)); return s < 60 ? `${s}s` : `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`; };
+    /** Join configured roles with live roster rows: Lead by role, teammates by their spawn name (= role id). */

package/client/06b-model-source.js

@@ -0,0 +1,67 @@
+    // ---------- which model a member is shown with ----------
+    // The host's listMembers model is not kept in sync with real requests, so it is never displayed. Priority:
+    // 1) the route of the latest request header, from this plugin's own capabilityTeamUsage.lastRoute
+    //    (live projection, else the last refresh) — the model a request was actually sent to, failover included;
+    // 2) older checkpoints without lastRoute: the recorded usage routes, with modelSelection.next accepted only
+    //    when it is one of them;
+    // 3) otherwise nothing here, and the board falls back to the configured primary, labelled "config".
+    // The Lead follows the user's pick (lead-route.js); before its first request it shows that pick, labelled as such.
+    const isRouteKey = route => typeof route === 'string' && route !== 'unknown' && route.indexOf('/') > 0;
+    /** Routes this member actually sent requests to, in the order the plugin first recorded them. */
+    function recordedRoutes(values, snapshotUsage) {
+      const own = values?.capabilityTeamUsage?.routes;
+      const rows = (own?.length ? own : snapshotUsage?.routes) ?? [];
+      return rows.map(row => row?.route).filter(isRouteKey);
+    }
+    /** Route of the latest request header, or null when none is recorded. */
+    function latestRequestRoute(values, snapshotUsage) {
+      const last = values?.capabilityTeamUsage?.lastRoute ?? snapshotUsage?.lastRoute;
+      return isRouteKey(last) ? last : null;
+    }
+    /** Latest trusted route for one member, or null when the plugin has not recorded a request yet. */
+    function trustedRoute(values, snapshotUsage) {
+      const latest = latestRequestRoute(values, snapshotUsage);
+      if (latest) return latest;
+      const routes = recordedRoutes(values, snapshotUsage);
+      if (!routes.length) return null;
+      const next = values?.modelSelection?.next;
+      const pick = next?.provider && next.model ? `${next.provider}/${next.model}` : null;
+      return pick && routes.includes(pick) ? pick : routes[routes.length - 1];
+    }
+    /** The Lead's actual route; before any recorded request, the model the user picked in the conversation. */
+    function leadRoute(values, snapshotUsage) {
+      const actual = trustedRoute(values, snapshotUsage);
+      if (actual) return { route: actual, from: 'request' };
+      const next = values?.modelSelection?.next;
+      return next?.provider && next.model ? { route: `${next.provider}/${next.model}`, from: 'pick' } : null;
+    }
+    /** Replace every roster member's model with its trusted route; members without one carry no model. */
+    function withTrustedRoutes(roster, live, d) {
+      if (!roster) return roster;
+      const evidence = new Map((d?.memberEvidence ?? []).map(m => [m.sessionId, m.usage]));
+      if (d?.sessionId && !evidence.has(d.sessionId) && d.requestEvidence?.usage) evidence.set(d.sessionId, d.requestEvidence.usage);
+      return { ...roster, members: (roster.members ?? []).map(m => {
+        const { provider: _hostProvider, model: _hostModel, ...rest } = m;
+        const values = live?.projections?.(m.id), usage = evidence.get(m.id);
+        const shown = m.role === 'lead' ? leadRoute(values, usage) : (r => r ? { route: r, from: 'request' } : null)(trustedRoute(values, usage));
+        return shown ? { ...rest, ...splitRoute(shown.route), modelFrom: shown.from } : rest;
+      }) };
+    }
+    /** Routes a role may legitimately use: its primary, declared fallbacks and long-context route. */
+    function allowedRoutes(role, allocation) {
+      const list = [allocation?.primary ?? (role?.provider ? `${role.provider}/${role.model}` : null),
+        ...(allocation?.fallbacks ?? []), ...(Array.isArray(role?.fallbacks) ? role.fallbacks : []).map(routeText),
+        role?.longContext?.provider ? `${role.longContext.provider}/${role.longContext.model}` : null];
+      return [...new Set(list.filter(isRouteKey))];
+    }
+    const isLeadRole = role => role?.id === 'lead' || role?.capability === 'orchestrator';
+    /** True when a trusted route lies outside what the role is configured for; unknown config and the Lead never warn. */
+    function routeOutsideConfig(route, role, allocation) {
+      if (isLeadRole(role)) return false;
+      const allowed = allowedRoutes(role, allocation);
+      return !!(isRouteKey(route) && allowed.length && !allowed.includes(route));
+    }
+    /** Small warning marker for a model outside the role's primary and fallbacks. */
+    function routeWarnBadge(t) {
+      return h('span', { key: 'route-warn', className: 'ctm-badge', 'data-tone': 'warn', 'data-route-warn': '', title: t('live.routeWarnHint') }, t('live.routeWarn'));
+    }