@aiwuk/team 0.0.0-stage → 5.0.8

package/token-discipline.js

@@ -0,0 +1,116 @@
+import { m as modelText } from './i18n.js';
+// Token rules for the team (part of the iron rules). Measured on this project: prompt caching already works
+// (93–98% of prompt tokens are cache reads), so cost is driven by how much context every step resends —
+// sessions ran at ~150k tokens per step because DSH compacts only at 80% of the window. The levers are a small,
+// stable prefix and a small working context, without breaking the cache:
+// 1. Idle compaction: when a team member goes idle above `idleCompactRatio` of its window, compact it then.
+//    The provider cache expires after a few idle minutes anyway, so this costs almost no cache.
+// 2. Oversized command/search output is cut to head + tail at once (the full text is spilled to a file),
+//    instead of riding along in every later step until DSH's own pruner runs at compaction time.
+// 3. The prefix stays stable: plugin context only changes on events, and routes do not flip per step.
+import { mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promptTokens } from './long-context.js';
+import { ownsCapabilityTeam } from './preset-guard.js';
+import { createTokenMetrics, usageSample } from './token-metrics.js';
+import { restrictiveToolName } from './tool-names.js';
+export const TOKEN_RULES = { idleCompactRatio: 0.35, trimToolOutputChars: 6000, keepHeadChars: 3000, keepTailChars: 1500 };
+const KEYS = Object.keys(TOKEN_RULES);
+/** Tools whose output is a log or listing rather than content the model must read whole. */
+export const TRIMMED_TOOLS = new Set(['bash', 'pwsh', 'grep', 'glob', 'job_output', 'web_fetch', 'web_search', 'omni_fetch', 'omni_search', 'session_search', 'session_event_search']);
+export function validateTokenRules(value) {
+  if (value === undefined || value === null) return { ...TOKEN_RULES };
+  if (value === false) return false;
+  if (typeof value !== 'object' || Array.isArray(value)) throw new Error(modelText('token-discipline.552'));
+  const extra = Object.keys(value).filter(k => !KEYS.includes(k));
+  if (extra.length) throw new Error(modelText('token-discipline.553', { 0: extra.join(', ') }));
+  const out = { ...TOKEN_RULES, ...value };
+  if (typeof out.idleCompactRatio !== 'number' || out.idleCompactRatio < 0.1 || out.idleCompactRatio > 0.9) throw new Error(modelText('token-discipline.554'));
+  for (const k of ['trimToolOutputChars', 'keepHeadChars', 'keepTailChars']) if (!Number.isSafeInteger(out[k]) || out[k] < 200 || out[k] > 200000) throw new Error(modelText('token-discipline.555', { 0: k }));
+  if (out.keepHeadChars + out.keepTailChars >= out.trimToolOutputChars) throw new Error(modelText('token-discipline.556'));
+  return out;
+}
+/** Model-facing token rules, appended to the file rules in the team policy. */
+export function tokenRuleText(rules) {
+  if (!rules) return '';
+  return modelText('token-discipline.557', { 0: rules.trimToolOutputChars, 1: Math.round(rules.idleCompactRatio * 100) });
+}
+/** Head + tail of a long text with a pointer to the full copy. Pure. */
+export function trimText(text, rules, spillPath) {
+  const head = text.slice(0, rules.keepHeadChars);
+  const tail = text.slice(-rules.keepTailChars);
+  return modelText('token-discipline.558', { 0: head, 1: text.length - head.length - tail.length, 2: text.length, 3: spillPath, 4: tail });
+}
+export function createTokenDiscipline(ctx, team, { spillDir = join(tmpdir(), 'capability-team-spill'), rulesOf, trimmedTools = TRIMMED_TOOLS, ratesOf } = {}) {
+  const compacting = new WeakSet();
+  const metrics = createTokenMetrics({ ratesOf });
+  // `compaction` is not in the plugin's inject list, and cordis throws on a direct read of an un-injected
+  // service (that once stopped the DSH host). It arrives through ctx.inject when the host provides it.
+  let compactionService;
+  const compaction = () => compactionService;
+  const rules = agent => {
+    if (rulesOf) return rulesOf(agent);
+    const project = team.pinned(agent);
+    if (!project) return TOKEN_RULES;
+    try { return team.loadSync(project, agent).effective.workflow.tokens; } catch { return TOKEN_RULES; }
+  };
+  const isMember = agent => ownsCapabilityTeam(ctx, agent) && !!ctx.agentTeams.tryMembership(agent);
+  const ratioOf = agent => {
+    try {
+      const projections = ctx.get?.('sessionProjections');
+      const tokens = promptTokens(projections, agent.session);
+      const window = projections?.stateOf(agent.session, 'contextPressure')?.contextWindow;
+      return tokens !== undefined && window ? tokens / window : undefined;
+    } catch { return undefined; }
+  };
+  async function compactIdleUnsafe(agent) {
+    const r = rules(agent);
+    const service = compaction();
+    if (!r || compacting.has(agent) || !isMember(agent) || typeof service?.compactNow !== 'function') return false;
+    const ratio = ratioOf(agent);
+    if (ratio === undefined || ratio < r.idleCompactRatio) return false;
+    compacting.add(agent);
+    const started = Date.now();
+    try { const done = (await service.compactNow(agent, AbortSignal.timeout(180000))) !== null; if (done) metrics.compact(agent, Date.now() - started); return done; }
+    finally { compacting.delete(agent); }
+  }
+  const api = {
+    metrics,
+    /** Compact an idle member whose context is above the idle threshold. Never throws; returns true when it ran. */
+    async compactIdle(agent) {
+      // busy (new work arrived), nothing compactable or any host error: skip, and try again on the next idle
+      try { return await compactIdleUnsafe(agent); } catch { return false; }
+    },
+    /** Post-execute decision: trim an oversized log/listing result for a team member. */
+    async trim(exec, result) {
+      const r = rules(exec.agent);
+      if (!r || !new Set(trimmedTools).has(restrictiveToolName(exec.name, new Set(trimmedTools))) || !isMember(exec.agent) || !Array.isArray(result?.content)) return undefined;
+      const text = result.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+      if (text.length <= r.trimToolOutputChars || result.content.some(b => b.type !== 'text')) return undefined;
+      await mkdir(spillDir, { recursive: true });
+      const path = join(spillDir, `${String(exec.callId ?? Date.now()).replace(/[^\w.-]/g, '_')}.txt`);
+      await writeFile(path, text);
+      const trimmed = trimText(text, r, path);
+      metrics.trim(exec.agent, text.length, trimmed.length);
+      return [{ type: 'text', text: trimmed }];
+    },
+    register() {
+      ctx.on('agent/request', async (payload, next) => {
+        const result = await next();
+        if (isMember(payload.agent)) metrics.sample(payload.agent, payload.turn, payload.step, usageSample(ctx.get?.('sessionProjections'), payload.agent.session));
+        return result;
+      });
+      try { ctx.inject?.(['compaction'], scoped => { compactionService = scoped.compaction; scoped.effect?.(() => () => { compactionService = undefined; }); }); } catch { /* host without compaction */ }
+      // Listeners must never reject: an unhandled rejection inside a host event stops the DSH host.
+      ctx.on('agent/status', ({ agent, status }) => { if (status === 'idle') api.compactIdle(agent).catch(() => {}); });
+      ctx.on('tools/post-execute', async (exec, result, next) => {
+        const decision = await next();
+        if (decision?.kind !== 'accept' || decision.content !== undefined || result?.isError) return decision;
+        try { const content = await api.trim(exec, result); return content ? { ...decision, content } : decision; }
+        catch { return decision; }
+      });
+    },
+  };
+  return api;
+}

package/token-metrics.js

@@ -0,0 +1,37 @@
+// Numeric telemetry only; never injected into prompts. Provider billing rates are optional.
+export function usageSample(projections, session) {
+  try {
+    const state = projections?.stateOf(session, 'tokenUsage');
+    const value = state?.totals ?? state;
+    return value ? { ...value, inputTokens: value.inputTokens ?? value.uncachedInputTokens } : null;
+  } catch { return null; }
+}
+const n = x => Number.isFinite(x) && x >= 0 ? x : 0;
+export function estimateCost(usage, rates) {
+  if (!rates) return null;
+  return (n(usage.inputTokens) * n(rates.input) + n(usage.cacheReadTokens) * n(rates.cacheRead)
+    + n(usage.cacheWriteTokens) * n(rates.cacheWrite) + n(usage.outputTokens) * n(rates.output)) / 1e6;
+}
+export function createTokenMetrics({ now = Date.now, ratesOf = () => null } = {}) {
+  const sessions = new WeakMap();
+  const state = agent => { if (!sessions.has(agent)) sessions.set(agent, { steps: [], trimmedChars: 0, estimatedSavedTokens: 0, compactions: 0, compactionMs: 0 }); return sessions.get(agent); };
+  return {
+    sample(agent, turn, step, usage, route) {
+      if (!usage) return;
+      const row = { turn, step, at: now(), prompt: n(usage.inputTokens) + n(usage.cacheReadTokens) + n(usage.cacheWriteTokens),
+        cacheRead: n(usage.cacheReadTokens), cacheWrite: n(usage.cacheWriteTokens), output: n(usage.outputTokens),
+        estimatedCost: estimateCost(usage, ratesOf(route)), source: 'sessionProjections.tokenUsage' };
+      const s = state(agent), old = s.steps.findIndex(x => x.turn === turn && x.step === step);
+      const totals = { prompt: row.prompt, cacheRead: row.cacheRead, cacheWrite: row.cacheWrite, output: row.output };
+      const baseline = old >= 0 ? s.steps[old].baseline : (s.lastTotals ?? { prompt: 0, cacheRead: 0, cacheWrite: 0, output: 0 });
+      for (const key of Object.keys(totals)) row[key] = Math.max(0, totals[key] - baseline[key]);
+      row.baseline = baseline; s.lastTotals = totals;
+      row.estimatedCost = estimateCost({ inputTokens: Math.max(0, row.prompt - row.cacheRead - row.cacheWrite), cacheReadTokens: row.cacheRead, cacheWriteTokens: row.cacheWrite, outputTokens: row.output }, ratesOf(route));
+      if (old >= 0) s.steps[old] = row; else s.steps.push(row);
+      s.steps = s.steps.slice(-1000);
+    },
+    trim(agent, before, after) { const s = state(agent), saved = Math.max(0, before - after); s.trimmedChars += saved; s.estimatedSavedTokens += Math.ceil(saved / 4); },
+    compact(agent, duration) { const s = state(agent); s.compactions++; s.compactionMs += n(duration); },
+    snapshot(agent) { return structuredClone(state(agent)); },
+  };
+}

package/tool-names.js

@@ -0,0 +1,10 @@
+// Host aliases supported by the existing workflow: optional MCP envelope and one word prefix.
+// A suffix is NOT proof of native tool identity. Use these candidates only to ADD restrictions,
+// never to grant permissions, mark a tool read-only, or establish sandbox/confirmation trust.
+export function restrictiveToolName(name, known) {
+  const raw = String(name ?? '').replace(/^mcp__.+?__/, '');
+  const has = value => typeof known === 'function' ? known(value) : known instanceof Set ? known.has(value) : Object.hasOwn(known, value);
+  if (has(raw)) return raw;
+  const tail = raw.slice(raw.indexOf('_') + 1);
+  return raw.includes('_') && has(tail) ? tail : raw;
+}

package/tool-schema.js

@@ -0,0 +1,23 @@
+// ctx.tools.register sends `parameters` to the model verbatim as JSON Schema (draft 2020-12),
+// so tool parameters must be a raw object-rooted schema, not the defineTool shorthand
+// (`{name: {type, required: true}}`). DSH accepts only this keyword subset.
+const ALLOWED = new Set(['type', 'oneOf', 'properties', 'required', 'additionalProperties', 'items', 'enum', 'const', 'description', 'title', 'default', 'examples']);
+
+/** Object-rooted parameter schema; `required` lists property names. */
+export function params(properties = {}, required = []) {
+  for (const name of required) if (!Object.hasOwn(properties, name)) throw new Error(`required parameter ${name} is not declared`);
+  return { type: 'object', properties, ...(required.length ? { required } : {}) };
+}
+
+/** Throws when a schema uses keywords outside the DSH subset or the shorthand `required: true`. */
+export function assertToolSchema(schema, path = 'parameters') {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) throw new Error(`${path} must be a schema object`);
+  for (const [key, value] of Object.entries(schema)) {
+    if (!ALLOWED.has(key)) throw new Error(`${path}.${key} is not a supported keyword`);
+    if (key === 'required' && !(Array.isArray(value) && value.every(v => typeof v === 'string'))) throw new Error(`${path}.required must be an array of property names`);
+  }
+  if (path === 'parameters' && schema.type !== 'object') throw new Error('parameters must have type "object" at the root');
+  for (const [name, sub] of Object.entries(schema.properties ?? {})) assertToolSchema(sub, `${path}.properties.${name}`);
+  if (schema.items) assertToolSchema(schema.items, `${path}.items`);
+  for (const [i, sub] of (schema.oneOf ?? []).entries()) assertToolSchema(sub, `${path}.oneOf[${i}]`);
+}

package/transcribe.js

@@ -0,0 +1,104 @@
+// Speech to text through the configured gateway (integrations.audio). The file is read locally only after the
+// user approves that exact path in DSH's native question box, then uploaded as multipart with its real bytes;
+// fetch's FormData sets the boundary. The key goes into the Authorization header only, never into prompts,
+// tool arguments or logs. A 200 still has to carry text to count as a result.
+import { m, t } from './i18n.js';
+import { open, realpath } from 'node:fs/promises';
+import { basename, isAbsolute, relative, resolve } from 'node:path';
+import { keyOf, refreshCredentials, resolveIntegrations } from './integrations-config.js';
+import { gatewayBase, httpError } from './search.js';
+import { readCapped } from './search-engines.js';
+import { params } from './tool-schema.js';
+export const AUDIO_TYPES = { '.mp3': 'audio/mpeg', '.mp4': 'audio/mp4', '.m4a': 'audio/mp4', '.mpeg': 'audio/mpeg', '.mpga': 'audio/mpeg', '.wav': 'audio/wav', '.webm': 'audio/webm', '.ogg': 'audio/ogg', '.oga': 'audio/ogg', '.flac': 'audio/flac' };
+const AUDIO_BASE = { what: m('transcribe.559'), field: 'audio.baseUrl', envName: 'OMNI_AUDIO_BASE_URL' };
+const extOf = path => (/\.[^.\\/]+$/.exec(path)?.[0] ?? '').toLowerCase();
+export function audioSettings(resolved = resolveIntegrations()) {
+  return { config: resolved.effective.audio, key: keyOf('audio', resolved), keyEnv: resolved.keys.audio.env };
+}
+/**
+ * Check type and size on an open handle, call `approve(size)`, and only then read the bytes. Nothing is read
+ * before approval, and the size checked is the size of the file actually read (no stat/read race).
+ */
+export async function readAudio(path, maxBytes, approve = async () => {}) {
+  // A symlink named meeting.mp3 could point anywhere (e.g. a private key): check and show the real target.
+  const unsupported = name => new Error(m('transcribe.560', { 0: extOf(name) || m('transcribe.561'), 1: Object.keys(AUDIO_TYPES).join(' ') }));
+  if (!AUDIO_TYPES[extOf(path)]) throw unsupported(path);
+  const real = await realpath(path);
+  if (!AUDIO_TYPES[extOf(real)]) throw unsupported(real);
+  const handle = await open(real, 'r');
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw new Error(m('transcribe.562'));
+    if (stat.size > maxBytes) throw new Error(m('transcribe.563', { 0: (stat.size / 1048576).toFixed(1), 1: (maxBytes / 1048576).toFixed(1) }));
+    if (!stat.size) throw new Error(m('transcribe.564'));
+    await approve(stat.size, real);
+    const bytes = await handle.readFile();
+    if (bytes.byteLength > maxBytes) throw new Error(m('transcribe.565'));
+    return bytes;
+  } finally { await handle.close(); }
+}
+export async function transcribe({ bytes, name, language, prompt }, { settings, fetcher = fetch, signal } = {}) {
+  if (!settings) await refreshCredentials();
+  const { config, key, keyEnv } = settings ?? audioSettings();
+  if (!key) throw new Error(m('transcribe.566', { 0: keyEnv }));
+  const origin = gatewayBase(config.baseUrl, AUDIO_BASE);
+  const form = new FormData();
+  form.append('file', new Blob([bytes], { type: AUDIO_TYPES[extOf(name)] ?? 'application/octet-stream' }), name);
+  if (config.model) form.append('model', config.model);
+  if (language) form.append('language', language);
+  if (prompt) form.append('prompt', prompt);
+  const timeout = AbortSignal.timeout(config.timeoutMs);
+  const response = await fetcher(`${origin}${config.path}`, { method: 'POST', redirect: 'error', body: form,
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout, headers: { ...config.headers, Authorization: `Bearer ${key}` } });
+  if (!response.ok) throw httpError(m('transcribe.559'), response.status);
+  const text = await readCapped(response, m('transcribe.559'));
+  if (text.includes(key)) throw new Error(m('transcribe.569'));
+  let data; try { data = JSON.parse(text); } catch { data = { text }; }
+  if (typeof data?.text !== 'string' || !data.text.trim()) throw new Error(m('transcribe.570'));
+  return data;
+}
+export async function audioStatus({ settings, fetcher = fetch, signal } = {}) {
+  if (!settings) await refreshCredentials();
+  const { config, key, keyEnv } = settings ?? audioSettings();
+  if (!config.statusPath) throw new Error(m('transcribe.571'));
+  if (!key) throw new Error(m('transcribe.572', { 0: keyEnv }));
+  const timeout = AbortSignal.timeout(30000);
+  const response = await fetcher(`${gatewayBase(config.baseUrl, AUDIO_BASE)}${config.statusPath}`, { method: 'GET', redirect: 'error',
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout, headers: { ...config.headers, Authorization: `Bearer ${key}` } });
+  if (!response.ok) throw httpError(m('transcribe.573'), response.status);
+  const text = await readCapped(response, m('transcribe.573'));
+  if (text.includes(key)) throw new Error(m('transcribe.569'));
+  let status; try { status = JSON.parse(text); } catch { throw new Error(m('transcribe.576')); }
+  return { note: t('transcribe.577'), status };
+}
+/** Ask the user, in DSH's native question box, to allow uploading this one file. */
+async function approve(ctx, exec, path, size, cwd) {
+  const allowLabel = t('transcribe.582');
+  const outside = cwd && relative(cwd, path).startsWith('..') ? t('transcribe.578') : '';
+  const answer = await ctx.userQuestions.ask({ agent: exec.agent, signal: exec.signal, questions: [{
+    id: 'upload', header: t('transcribe.579'),
+    question: t('transcribe.580'),
+    detail: t('transcribe.581', { 0: path, 1: (size / 1048576).toFixed(2), 2: outside }),
+    options: [{ label: allowLabel, description: t('transcribe.583') }, { label: t('transcribe.584'), description: t('transcribe.585') }],
+  }] });
+  if (!answer.answers.find(a => a.id === 'upload')?.selected.includes(allowLabel)) throw new Error(m('transcribe.587'));
+}
+const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] };
+export function applyTranscribe(ctx) {
+  ctx.effect(() => ctx.tools.register({ name: 'omni_transcribe', output,
+    description: m('transcribe.588'),
+    parameters: params({ file_path: { type: 'string', description: m('transcribe.589') }, language: { type: 'string', description: m('transcribe.590') }, prompt: { type: 'string', description: m('transcribe.591') } }, ['file_path']),
+    async execute(args, exec) {
+      const cwd = await ctx.workingDirectory.ensure(exec.agent, exec.signal);
+      const path = isAbsolute(String(args.file_path)) ? String(args.file_path) : resolve(cwd, String(args.file_path));
+      const max = audioSettings().config.maxBytes;
+      const bytes = await readAudio(path, max, (size, real) => approve(ctx, exec, real, size, cwd)); // read only after approval
+      const result = await transcribe({ bytes, name: basename(path), language: args.language, prompt: args.prompt }, { signal: exec.signal });
+      return JSON.stringify(result);
+    },
+  }));
+  ctx.effect(() => ctx.tools.register({ name: 'omni_transcribe_status', output, parameters: params({}, []),
+    description: m('transcribe.592'),
+    async execute(_args, exec) { return JSON.stringify(await audioStatus({ signal: exec.signal })); },
+  }));
+}

package/ui.js

@@ -0,0 +1,113 @@
+/** Profile-wide, read-only diagnostics; never activates routing for unrelated sessions. */
+import { m, t } from './i18n.js';
+import { readTeamSnapshot, saveTeamPolicy } from './runtime-view.js';
+import { readRequestEvidence, readTeamEvidence } from './request-evidence.js';
+import { applyConfigProjection } from './config-projection.js';
+import { applyObservabilityProjections } from './observability-projection.js';
+import { applyObservabilityApi } from './observability-api.js';
+import { applyTaskControlApi } from './task-control-api.js';
+import { applyDispatchConfirmApi } from './dispatch-confirm.js';
+import { applyOnboardingApi } from './onboarding.js';
+import { registerManagedConfigRoute } from './managed-config-route.js';
+import { schemastery } from './settings-schema.js';
+export const inject = ['commands', 'agentPresets', 'tools'];
+// Only the welcome card's acknowledgement is a live setting (the client renders its own card, so no auto page).
+const z = schemastery('@aiwuk/team');
+export const Config = z ? z.object({ welcomeVersion: z.string().volatile() }) : undefined;
+/**
+ * Live roster state from the host's Agent Teams service: status and owned tasks. No log reads, cheap to poll.
+ * The host's member provider/model is not kept in sync with real requests, so it is deliberately not forwarded.
+ */
+export function teamActivity(ctx, agent) {
+  const teams = ctx.get?.('agentTeams');
+  if (!teams) return { members: [], tasks: [], unavailable: t('ui.593') };
+  let members, tasks = [];
+  try {
+    members = teams.listMembers(agent).map(m => ({ id: m.id, name: m.name, role: m.role, status: m.status, diagnostics: m.diagnostics ?? [] }));
+  } catch (error) { return { members: [], tasks: [], unavailable: t('ui.594', { 0: error.message ?? error }) }; }
+  try {
+    tasks = (teams.listTasks?.(agent) ?? []).filter(task => task.status !== 'deleted')
+      .map(task => ({ id: task.id, subject: task.subject, status: task.status, ...(task.ownerName ? { ownerName: task.ownerName } : {}) }));
+  } catch { /* task board is optional for the activity view */ }
+  return { members, tasks };
+}
+export async function inspectTeamRuntime(ctx, agent) {
+  const preset = ctx.agentPresets.composedPreset(agent.ctx) ?? null;
+  const roster = await ctx.agentPresets.list();
+  const definition = roster.find(p => p.id === 'capability-team');
+  const required = ['capability_team_read', 'capability_dispatch_plan', 'capability_free_task'];
+  const visible = ctx.tools.schemas(agent).map(t => t.name);
+  const missingTools = required.filter(name => !visible.includes(name));
+  let team = null, teamError = null;
+  if (preset === 'capability-team') {
+    try { team = await readTeamSnapshot(agent); }
+    catch (error) { teamError = String(error.message ?? error); }
+  }
+  const memberEvidence = preset === 'capability-team'
+    ? await readTeamEvidence(ctx.get?.('sessionQuery'), ctx.get?.('agentTeams'), agent) : [];
+  return {
+    sessionId: agent.id, preset, teamServicePresent: !!ctx.get?.('agentTeams'),
+    declared: !!definition, activationError: definition?.broken ?? null,
+    ready: preset === 'capability-team' && !!definition && !definition.broken && missingTools.length === 0 && team !== null && !teamError,
+    missingTools,
+    requestEvidence: memberEvidence.find(member => member.sessionId === agent.id) ?? await readRequestEvidence(ctx.get?.('sessionQuery'), agent.id),
+    memberEvidence,
+    team, teamError,
+    activity: preset === 'capability-team' ? teamActivity(ctx, agent) : null,
+    explanation: !definition ? t('ui.595')
+      : definition.broken ? t('ui.596', { 0: definition.broken })
+      : preset !== 'capability-team' ? t('ui.597')
+      : missingTools.length ? t('ui.598', { 0: missingTools.join(', ') })
+      : teamError ? t('ui.599')
+      : team === null ? t('ui.600')
+      : t('ui.601'),
+  };
+}
+/**
+ * The host logs every command result into the conversation, so the panel's snapshot is kept small:
+ * catalog rows become [key, tier, primaryFor?, fallbackFor?] tuples, derived/duplicate fields are dropped.
+ */
+export function compactStatus(status) {
+  const { team, requestEvidence, memberEvidence, ...rest } = status;
+  const self = memberEvidence.some(member => member.sessionId === status.sessionId);
+  const out = { ...rest, memberEvidence, ...(self ? {} : { requestEvidence }) };
+  if (!team) return { ...out, team };
+  const { autoMatch: _autoMatch, modelPolicy, ...teamRest } = team;
+  if (!modelPolicy) return { ...out, team: teamRest };
+  const { tierCatalog: _tiers, rows, ...policyRest } = modelPolicy;
+  const tuple = row => {
+    const value = [row.key, row.tiers?.[0] ?? null];
+    if (row.primaryFor?.length || row.fallbackFor?.length) value.push(row.primaryFor ?? []);
+    if (row.fallbackFor?.length) value.push(row.fallbackFor);
+    return value;
+  };
+  return { ...out, team: { ...teamRest, modelPolicy: { ...policyRest, rows: (rows ?? []).map(tuple) } } };
+}
+export async function savePolicyCommand(ctx, { agent, rawInput }) {
+  if (ctx.agentPresets.composedPreset(agent.ctx) !== 'capability-team') throw new Error(m('ui.602'));
+  const input = JSON.parse(rawInput);
+  if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(k => !['disabledRoutes', 'expectedRevision'].includes(k))) throw new Error(m('ui.603'));
+  const result = await saveTeamPolicy(agent, input.disabledRoutes, input.expectedRevision);
+  return { kind: 'success', text: JSON.stringify(result) };
+}
+export function apply(ctx) {
+  applyConfigProjection(ctx);
+  applyObservabilityProjections(ctx);
+  applyObservabilityApi(ctx);
+  applyTaskControlApi(ctx);
+  applyDispatchConfirmApi(ctx);
+  applyOnboardingApi(ctx);
+  registerManagedConfigRoute(ctx, 'team');
+  ctx.inject?.(['settings'], scoped => { scoped.effect(() => scoped.settings.configure({ auto: false }, ctx.fiber)); });
+  ctx.effect(() => ctx.commands.register({
+    name: 'capability-model-policy',
+    description: t('ui.604'),
+    input: { hint: t('ui.605') },
+    handler: invocation => savePolicyCommand(ctx, invocation),
+  }));
+  ctx.effect(() => ctx.commands.register({
+    name: 'capability-status',
+    description: t('ui.606'),
+    handler: async ({ agent }) => ({ kind: 'success', text: JSON.stringify(compactStatus(await inspectTeamRuntime(ctx, agent))) }),
+  }));
+}

package/usage.js

@@ -0,0 +1,96 @@
+import { m as modelText } from './i18n.js';
+// Own-session usage. Durable assistant/attempt settles a failed request, so the next
+// settlement is a distinct attempt even when plugin retry emits no llm/retry-started.
+// Token usage per team member:
+// each Assistant settlement contributes its last usage sample; a failed assistant/attempt
+// and llm/retry-started close the slot. Same-slot message corrections replace it. Samples are attributed to the
+// route of the latest request header, which is the route the attempt was sent to.
+// Why this fold stays instead of DSH's native `tokenUsage` projection: the native one has no route dimension (no
+// per-model rows, no lastRoute) and its init ignores the fork-inherited prefix, so a forked member would be charged
+// for its parent's tokens and role budgets (maxTokens) would trip early. Wall times (turns, steps, llm/tool/ttft/decode)
+// are not folded here; they come from the native `sessionStats` projection.
+const BUCKETS = ['uncachedInputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens'];
+export const zeroUsage = () => ({ uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
+const numeric = value => Number.isFinite(value) && value >= 0 ? Math.min(value, Number.MAX_SAFE_INTEGER) : 0;
+const bucketsFrom = usage => ({ uncachedInputTokens: numeric(usage.inputTokens), outputTokens: numeric(usage.outputTokens),
+  cacheReadTokens: numeric(usage.cacheReadTokens), cacheWriteTokens: numeric(usage.cacheWriteTokens) });
+const shift = (into, buckets, sign) => { for (const key of BUCKETS) into[key] = Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, into[key] + sign * buckets[key])); };
+/** Budget-counted tokens = uncached input + cache write + output; excludes cache reads and is not a bill amount. */
+export const billable = usage => (usage?.uncachedInputTokens ?? 0) + (usage?.cacheWriteTokens ?? 0) + (usage?.outputTokens ?? 0);
+export function sampleOf(event) {
+  if (event.type === 'assistant/message' && event.data?.usage && typeof event.data.usage === 'object' && !Array.isArray(event.data.usage)) return event.data.usage;
+  if (event.type !== 'assistant/message' && event.type !== 'assistant/attempt') return undefined;
+  const stream = Array.isArray(event.data?.stream) ? event.data.stream : [];
+  for (let i = stream.length - 1; i >= 0; i--) if (stream[i]?.type === 'chunk' && stream[i].chunk?.type === 'usage') return stream[i].chunk.usage;
+  return undefined;
+}
+export const OWN_USAGE_KEY = 'capabilityTeamUsage';
+export function initOwnUsage(inherited = 0) {
+  return { inherited, cursor: -1, totals: zeroUsage(), routes: [], route: null, last: null, settledAttempt: false, reportedSamples: 0, attemptsWithoutUsage: 0, coverage: 'unknown', truncated: false };
+}
+/** Pure incremental fold. A durable attempt is a settlement, not an intermediate usage chunk. */
+export function applyOwnUsage(state, event) {
+  if (Number.isSafeInteger(event.seq) && (event.seq < state.inherited || event.seq <= state.cursor)) return state;
+  if (!['request/header', 'llm/retry-started', 'assistant/attempt', 'assistant/message'].includes(event.type)) return state;
+  const next = { ...state, cursor: Number.isSafeInteger(event.seq) ? event.seq : state.cursor };
+  if (event.type === 'request/header') {
+    const config = event.data?.header?.config;
+    if (typeof config?.provider === 'string' && config.provider.length <= 128 && typeof config?.model === 'string' && config.model.length <= 512) next.route = `${config.provider}/${config.model}`;
+    // Headers can be deduplicated by the host. Never rely on a header alone as an attempt boundary.
+    return next;
+  }
+  if (event.type === 'llm/retry-started') {
+    if (state.last?.turn === event.data?.turn && state.last?.step === event.data?.step) next.last = null;
+    next.settledAttempt = false;
+    return next;
+  }
+  const sample = sampleOf(event);
+  if (!sample || typeof sample !== 'object' || Array.isArray(sample) || !['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens'].some(key => typeof sample[key] === 'number')) {
+    next.attemptsWithoutUsage += 1;
+    next.last = null;
+    next.settledAttempt = event.type === 'assistant/attempt';
+    next.coverage = 'partial';
+    return next;
+  }
+  const totals = { ...state.totals }, routes = new Map(state.routes.map(row => [row.route, { ...row }]));
+  const buckets = bucketsFrom(sample), key = state.route ?? 'unknown';
+  if (Object.values(sample).some(value => typeof value === 'number' && (!Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER))) next.attemptsWithoutUsage += 1;
+  const { turn, step } = event.data;
+  if (!state.settledAttempt && state.last?.turn === turn && state.last?.step === step) {
+    shift(totals, state.last.buckets, -1);
+    if (routes.has(state.last.route)) shift(routes.get(state.last.route), state.last.buckets, -1);
+  }
+  if (!routes.has(key)) routes.set(key, { route: key, ...zeroUsage() });
+  shift(totals, buckets, 1); shift(routes.get(key), buckets, 1);
+  if (routes.size > 24 || BUCKETS.some(k => totals[k] === Number.MAX_SAFE_INTEGER)) next.truncated = true;
+  next.totals = totals; next.routes = [...routes.values()].slice(-24); next.last = { turn, step, route: key, buckets };
+  next.settledAttempt = event.type === 'assistant/attempt';
+  next.reportedSamples += 1;
+  next.coverage = next.attemptsWithoutUsage ? 'partial' : 'complete';
+  return next;
+}
+/** `lastRoute` is the route of this session's latest request header: the model a request was actually sent to. */
+export function ownUsageView(state) {
+  return { schemaVersion: 1, scope: 'own-session-events', totals: state.totals, routes: state.routes, lastRoute: state.route ?? null,
+    reportedSamples: state.reportedSamples, attemptsWithoutUsage: state.attemptsWithoutUsage, coverage: state.coverage, truncated: state.truncated };
+}
+/** Usage of one session log, excluding events inherited from a parent session. */
+export function foldUsage(snapshot) {
+  const own = snapshot.events.slice(snapshot.inheritedEventCount ?? 0).reduce(applyOwnUsage, initOwnUsage());
+  return { totals: own.totals, routes: own.routes.filter(u => billable(u) || u.cacheReadTokens), lastRoute: own.route ?? null,
+    reportedSamples: own.reportedSamples, attemptsWithoutUsage: own.attemptsWithoutUsage, coverage: own.coverage };
+}
+/** Own-session budget totals only. Missing/unknown usage does not block; no inherited host fallback. */
+export function sessionUsage(projections, session) {
+  try {
+    const state = projections?.stateOf(session, OWN_USAGE_KEY);
+    return state ? state.totals ?? state : undefined;
+  } catch { return undefined; }
+}
+/** Denial for a role that has used up its per-session token budget, or undefined. */
+export function budgetDenial(role, usage) {
+  if (!role.maxTokens || !usage) return undefined;
+  const used = billable(usage);
+  if (used < role.maxTokens) return undefined;
+  return modelText('usage.607', { 0: role.displayName ?? role.id, 1: role.capability, 2: used, 3: role.maxTokens });
+}